Day 8

src/day08.ts

···
+// JS sets preserve insertion order, which is useful for part 2
+type Circuit = Set<Vector3>;
+
+export function solvePart1(input: string, numberOfPairs = 1000) {
+  const points = parseInput(input);
+
+  const circuits = connectClosestPairs(points, numberOfPairs);
+
+  const threeLargestCircuits = circuits
+    .sort((a, b) => b.size - a.size)
+    .slice(0, 3);
+
+  return String(
+    threeLargestCircuits.reduce((sum, circuit) => sum * circuit.size, 1),
+  );
+}
+
+export function solvePart2(input: string) {
+  const points = parseInput(input);
+
+  const circuits = connectClosestPairs(points);
+
+  // There should just be one circuit now because we iterated over all pairs
+  const circuit = circuits[0]!;
+
+  return String(
+    [...circuit].slice(-2).reduce((xProduct, point) => xProduct * point.x, 1),
+  );
+}
+
+function connectClosestPairs(points: Vector3[], numberOfPairs?: number) {
+  // ~500k pairs lol
+  const pairDistances = makePairs(points).map((p) => ({
+    pair: p,
+    distanceSquared: p[0].distanceToSquared(p[1]),
+  }))
+    .toArray()
+    .sort((a, b) => a.distanceSquared - b.distanceSquared);
+
+  const circuits = [] as Circuit[];
+  // Circuit lookup to avoid O(n) searches over `circuits` array every time
+  const circuitLookup = new Map<Vector3, Circuit>();
+
+  const pairsToProcess = numberOfPairs
+    ? pairDistances.slice(0, numberOfPairs)
+    : pairDistances;
+
+  for (const { pair: [a, b] } of pairsToProcess) {
+    const circuitA = circuitLookup.get(a);
+    const circuitB = circuitLookup.get(b);
+
+    if (circuitA && circuitB) {
+      if (circuitA === circuitB) {
+        // both points already in the same circuit
+        continue;
+      }
+
+      // merge circuits
+      for (const point of circuitB) {
+        circuitA.add(point);
+        circuitLookup.set(point, circuitA);
+      }
+      circuits.splice(circuits.indexOf(circuitB), 1);
+      // Rearrange circuitA to place a and b at the end for part 2
+      circuitA.delete(a);
+      circuitA.delete(b);
+      circuitA.add(a);
+      circuitA.add(b);
+    } else if (circuitA || circuitB) {
+      const existingCircuit = circuitA || circuitB!;
+      const newPoint = circuitA ? b : a;
+      circuitLookup.set(newPoint, existingCircuit);
+
+      // Delete and re-add to ensure a and b are at the end to preserve order for part 2
+      existingCircuit.delete(a);
+      existingCircuit.delete(b);
+      existingCircuit.add(a);
+      existingCircuit.add(b);
+    } else {
+      // create new circuit
+      const newCircuit = new Set<Vector3>([a, b]);
+      circuits.push(newCircuit);
+      circuitLookup.set(a, newCircuit);
+      circuitLookup.set(b, newCircuit);
+    }
+  }
+
+  return circuits;
+}
+
+function* makePairs<T>(arr: T[]) {
+  for (let i = 0; i < arr.length; i++) {
+    for (let j = i + 1; j < arr.length; j++) {
+      yield [arr[i]!, arr[j]!] as const;
+    }
+  }
+}
+
+//613037
+//1344696
+function parseInput(input: string): Vector3[] {
+  return input.trim().split("\n").map((line) => {
+    const [x, y, z] = line.split(",").map((coord) => Number(coord.trim()));
+    return new Vector3(x!, y!, z!);
+  });
+}
+
+class Vector3 {
+  readonly x: number;
+  readonly y: number;
+  readonly z: number;
+
+  constructor(x: number, y: number, z: number) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+
+  distanceTo(other: Vector3): number {
+    return Math.sqrt(this.distanceToSquared(other));
+  }
+
+  // distanceToSquared can be used to compare distances without computing a square root which is more efficient
+  distanceToSquared(other: Vector3): number {
+    const dx = this.x - other.x;
+    const dy = this.y - other.y;
+    const dz = this.z - other.z;
+
+    return dx * dx + dy * dy + dz * dz;
+  }
+}