full solution for day 10

Author: shahata

src/2025/day10.js

@@ -1,89 +1,87 @@
+import { memoize } from "../utils/memoize.js";
+
+// Helper function to generate all combinations
+function* product(...arrays) {
+  if (arrays.length === 0) yield [];
+  else {
+    const [head, ...tail] = arrays;
+    for (const item of head) {
+      for (const rest of product(...tail)) {
+        yield [item, ...rest];
+      }
+    }
+  }
+}
+
 function parse(input) {
+  let parseTuple = str => str.slice(1, -1).split(",").map(Number);
   let machines = input.split("\n").map(line => {
-    let [indicator, ...buttons] = line.split(" ");
-    let joltage = buttons.pop();
-    indicator = indicator
-      .slice(1, -1)
-      .split("")
-      .map((x, i) => (x === "#" ? i : null))
-      .filter(x => x !== null);
-    buttons = buttons.map(button => {
-      button = button
-        .slice(1, -1)
-        .split(",")
-        .map(x => parseInt(x, 10));
-      return new Set(button);
-    });
-    joltage = joltage
-      .slice(1, -1)
-      .split(",")
-      .map(x => parseInt(x, 10));
-    return { indicator: new Set(indicator), buttons: buttons, joltage };
+    const parts = line.split(" ");
+    const dia = Array.from(parts[0].slice(1, -1)).map(c => (c === "#" ? 1 : 0));
+    const buttons = parts.slice(1, -1).map(x => parseTuple(x));
+    const jolts = parseTuple(parts[parts.length - 1]);
+    return { dia, buttons, jolts };
   });
   return machines;
 }
 
-function minimumPresses(machine) {
-  let { indicator, buttons } = machine;
-  let queue = [];
-  let visited = new Set();
-  buttons.forEach(button => {
-    queue.push({ pressed: 1, state: button });
-  });
-  while (queue.length > 0) {
-    let { pressed, state } = queue.shift();
-    let stateKey = Array.from(state)
-      .sort((a, b) => a - b)
-      .join(",");
-    if (visited.has(stateKey)) continue;
-    visited.add(stateKey);
-    if (indicator.symmetricDifference(state).size === 0) {
-      return pressed;
-    }
-    buttons.forEach(button => {
-      queue.push({
-        pressed: pressed + 1,
-        state: button.symmetricDifference(state),
-      });
-    });
-  }
-}
-
-function minimumPresses2(machine) {
-  let { buttons, joltage } = machine;
-  let queue = [];
-  let visited = new Set();
-  queue.push({ pressed: 0, state: [...joltage], pushes: [] });
-  while (queue.length > 0) {
-    let { pressed, state, pushes } = queue.shift();
-    let stateKey = state.join(",");
-    if (visited.has(stateKey)) continue;
-    visited.add(stateKey);
-    if (state.every(x => x === 0)) return pressed;
-    if (state.some(x => x < 0)) continue;
-    for (let i = 0; i < buttons.length; i++) {
-      let button = buttons[i];
-      let next = [...state];
-      button.forEach(pos => next[pos]--);
-      queue.push({
-        pressed: pressed + 1,
-        state: next,
-        pushes: pushes.concat(i),
-      });
+function producePatterns(buttons, jolts) {
+  const ops = {},
+    patterns = {};
+  for (const pressed of product(...Array(buttons.length).fill([0, 1]))) {
+    const jolt = Array(jolts.length).fill(0);
+    for (let i = 0; i < pressed.length; i++) {
+      if (pressed[i]) {
+        for (const j of buttons[i]) jolt[j] += pressed[i];
+      }
     }
+    const lights = jolt.map(x => x % 2);
+    const key = JSON.stringify(pressed);
+    const lightsKey = JSON.stringify(lights);
+    ops[key] = jolt;
+    if (!patterns[lightsKey]) patterns[lightsKey] = [];
+    patterns[lightsKey].push(pressed);
   }
+  return { ops, patterns };
 }
 
 export function part1(input) {
   let machines = parse(input);
-  let result = 0;
-  machines.forEach(machine => (result += minimumPresses(machine)));
-  return result;
+  let p1 = 0;
+  for (const { dia, buttons, jolts } of machines) {
+    const { patterns } = producePatterns(buttons, jolts);
+    const diaKey = JSON.stringify(dia);
+    p1 += Math.min(...patterns[diaKey].map(x => x.reduce((a, b) => a + b, 0)));
+  }
+  return p1;
 }
 
 export function part2(input) {
+  let p2 = 0;
   let machines = parse(input);
-  let result = 0;
-  machines.forEach(machine => (result += minimumPresses2(machine)));
-  return result;
+
+  for (const { buttons, jolts } of machines) {
+    const { ops, patterns } = producePatterns(buttons, jolts);
+
+    let presses = memoize(target => {
+      if (target.every(x => x === 0)) return 0;
+      if (target.some(x => x < 0)) return Infinity;
+
+      const lights = target.map(x => x % 2);
+      const lightsKey = JSON.stringify(lights);
+      if (!patterns[lightsKey]) return Infinity;
+
+      let total = Infinity;
+      for (const pressed of patterns[lightsKey]) {
+        const diff = ops[JSON.stringify(pressed)];
+        const newTarget = diff.map((a, i) => (target[i] - a) / 2);
+        const sum = pressed.reduce((a, b) => a + b, 0);
+        total = Math.min(total, sum + 2 * presses(newTarget));
+      }
+      return total;
+    });
+
+    p2 += presses(jolts);
+  }
+  return p2;
 }

src/2025/day10.test.js

@@ -36,8 +36,8 @@ describe("day10 2025", () => {
       ).toEqual(33);
     });
 
-    test.skip("it should work for part 2 input", () => {
-      expect(part2(input)).toEqual(0); // solved with z3, will implement in code later
+    test("it should work for part 2 input", () => {
+      expect(part2(input)).toEqual(15489);
     });
   });
 });