adventofcode 2025 Day 10 part 2 attempt

Reading that BFS/A* etc. isn't going to work. The search space is too
large.

Need to treat as "linear programming" problem and use something called
"Z3 Solver" which I haven't learnt.

GitOrigin-RevId: d553622a21e8436d78216be1e4393f7178c21772

Author: will-molloy

advent-of-code/src/main/kotlin/com/willmolloy/adventofcode/_2025/Day10.kt

@@ -3,92 +3,146 @@ package com.willmolloy.adventofcode._2025
 import com.willmolloy.adventofcode.common.Day
 import com.willmolloy.adventofcode.common.Input
 import com.willmolloy.adventofcode.common.extensions.debug
+import java.util.BitSet
 import java.util.concurrent.atomic.AtomicInteger
 
 /** https://adventofcode.com/2025/day/10 */
 object Day10 : Day(2025, 10) {
 
-  // lights = BITSET
-  private class Machine(val lights: Int, val buttons: Array<IntArray>, val joltage: IntArray){
+  private class Machine(
+    val lights: BooleanArray,
+    val buttons: Array<IntArray>,
+    val joltage: IntArray,
+  ) {
     override fun toString(): String {
-      return "Machine(lights=${lights}, buttons=${buttons.contentDeepToString()}, joltage=${joltage.contentToString()})"
+      return "Machine(lights=${lights.contentToString()}, buttons=${buttons.contentDeepToString()}, joltage=${joltage.contentToString()})"
     }
   }
 
-  fun Int.toggleBit(bit: Int): Int = this xor (1 shl bit)
+  private fun parse(input: Input): List<Machine> =
+    input.readLines().map { line ->
+      val match = Regex("\\[(.*)] \\((.*)\\) \\{(.*)}").matchEntire(line)!!
+      val (lights, buttons, joltage) = match.destructured
+
+      val lightsTyped = lights.toCharArray().map { it != '.' }.toBooleanArray()
+      val buttonsTyped =
+        buttons.split(") (").map { it.split(",").map { it.toInt() }.toIntArray() }.toTypedArray()
+      val joltageTyped = joltage.split(",").map { it.toInt() }.toIntArray()
+      Machine(lightsTyped, buttonsTyped, joltageTyped)
+    }
+
+  fun BooleanArray.toBitSet(): BitSet {
+    val bitSet = BitSet()
+    for ((i, b) in this.withIndex()) {
+      if (b) {
+        bitSet.flip(i)
+      }
+    }
+    return bitSet
+  }
 
   override fun part1(input: Input): Any {
     val machines = parse(input)
-
-    val solve = AtomicInteger(0)
+    val solveCount = AtomicInteger()
 
     fun solve(machine: Machine): Long {
-      "Solving ${solve.incrementAndGet()}/${machines.size}: $machine".debug()
+      "Solving ${solveCount.incrementAndGet()}/${machines.size}: $machine".debug()
+
+      // represent the graph node as a bitset; otherwise get OOM
+      val lightsBitSet = machine.lights.toBitSet()
 
       // BFS for shorted path
-      val queue = ArrayDeque<Int>()
+      val queue = ArrayDeque<BitSet>()
 
-      // initially all off
-      queue.add(0)
+      // initially all lights off
+      val root = BitSet()
+      queue.add(root)
 
-      val visited = mutableSetOf<Int>()
+      val visited = mutableSetOf<BitSet>()
 
       var depth = 0L
       while (!queue.isEmpty()) {
+        "Depth: $depth, breadth: ${queue.size}".debug()
 
-        val levelSize = queue.size
-        for (i in 0 until levelSize) {
+        (0..<queue.size).forEach { _ ->
           val node = queue.removeFirst()
 
-          if (node == machine.lights) {
+          if (node == lightsBitSet) {
             return depth
           }
 
-          for (button in machine.buttons.withIndex()) {
-            var adjNode = node
-            for (b in button.value) {
-              adjNode = adjNode.toggleBit(b)
-            }
+          for (button in machine.buttons) {
+            val adjNode = node.clone() as BitSet
+
+            // TODO possible to represent button as BitSet then flip all at once?
+            button.forEach { adjNode.flip(it) }
 
             if (visited.add(adjNode)) {
               queue.add(adjNode)
             }
           }
-
         }
         depth++
       }
 
-      error("Unsolved")
+      error("Failed to solve: $machine")
     }
 
     return machines.sumOf { solve(it) }
   }
 
   override fun part2(input: Input): Any {
-    return 2222222222222222
-  }
+    val machines = parse(input)
+    val solveCount = AtomicInteger()
 
-  private fun parse(input: Input): List<Machine> = input.readLines()
-    .mapNotNull { line ->
-      val match = Regex("\\[(.*)](.*)\\{(.*)}").matchEntire(line) ?: return@mapNotNull null
+    fun solve(machine: Machine): Long {
+      "Solving ${solveCount.incrementAndGet()}/${machines.size}: $machine".debug()
 
-      val (lights, buttons, joltage) = match.destructured
+      // TODO possible to represent the joltage as bitset too?
+      // TODO or is there a more efficient way to traverse the graph?
+      // TODO the subreddit mentions Z3...
 
-      val lightsTyped = lights.toCharArray().map { it != '.' }.toBooleanArray()
+      // BFS for shorted path
+      val queue = ArrayDeque<IntArray>()
 
-      val buttonsTyped = buttons.trim().removePrefix("(").removeSuffix(")").split(") (")
-        .map { it.split(",").map { it.toInt() }.toIntArray() }.toTypedArray()
+      // initially all joltage zero
+      val root = IntArray(machine.joltage.size) { 0 }
+      queue.add(root)
 
-      val joltageTyped = joltage.split(",").map { it.toInt() }.toIntArray()
+      val visited = mutableSetOf<String>()
+
+      var depth = 0L
+      while (!queue.isEmpty()) {
+        "Depth: $depth, breadth: ${queue.size}".debug()
+
+        (0..<queue.size).forEach { _ ->
+          val node = queue.removeFirst()
+
+          if (node.contentEquals(machine.joltage)) {
+            return depth
+          }
+
+          for (button in machine.buttons) {
+            val adjNode = node.clone()
 
-      var lightsBits = 0
-      for ((i, b) in lightsTyped.withIndex()) {
-        if (b) {
-          lightsBits = lightsBits.toggleBit(i)
+            button.forEach { adjNode[it]++ }
+
+            // prune nodes which exceed the joltage
+            if (adjNode.withIndex().any { adjNode[it.index] > machine.joltage[it.index] }) {
+              continue
+            }
+
+            if (visited.add(adjNode.contentToString())) {
+              queue.add(adjNode)
+            }
+          }
         }
+        depth++
       }
 
-      Machine(lightsBits, buttonsTyped, joltageTyped)
+      error("Failed to solve: $machine")
     }
+
+    return machines.sumOf { solve(it) }
+  }
 }

advent-of-code/src/test/kotlin/com/willmolloy/adventofcode/_2025/Day10Test.kt

@@ -1,10 +1,11 @@
 package com.willmolloy.adventofcode._2025
 
 import com.willmolloy.adventofcode.common.DayTest
+import org.junit.jupiter.api.Assumptions.abort
 
 object Day10Test : DayTest(Day10) {
 
   override fun part1() = Answer(7, 425)
 
-  override fun part2() = Answer(2222222222222222, 2222222222222222)
+  override fun part2() = Answer({ 33 }, { abort() })
 }

advent-of-code/src/test/kotlin/com/willmolloy/adventofcode/common/DayTest.kt

@@ -3,7 +3,6 @@ package com.willmolloy.adventofcode.common
 import com.google.common.truth.Truth.assertThat
 import org.junit.jupiter.api.Assumptions.abort
 import org.junit.jupiter.api.MethodOrderer
-import org.junit.jupiter.api.Order
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestMethodOrder
 
@@ -12,33 +11,37 @@ import org.junit.jupiter.api.TestMethodOrder
  *
  * @author <a href=https://willmolloy.com>Will Molloy</a>
  */
-@TestMethodOrder(MethodOrderer.OrderAnnotation::class)
+@TestMethodOrder(MethodOrderer.MethodName::class)
 abstract class DayTest(private val day: Day) {
   private val exampleInput: FileInput = FileInput.example(day)
   private val realInput: FileInput? = FileInput.real(day)
 
-  @Order(1)
   @Test
   fun part1_exampleInput() {
-    assertThat(day.part1(exampleInput)).isEqualTo(part1().example)
+    val expected = part1().example.invoke()
+    val actual = day.part1(exampleInput)
+    assertThat(actual).isEqualTo(expected)
   }
 
-  @Order(3)
   @Test
   fun part1_realInput() {
-    assertThat(day.part1(realInput ?: abort())).isEqualTo(part1().real)
+    val expected = part1().real.invoke()
+    val actual = day.part1(realInput ?: abort())
+    assertThat(actual).isEqualTo(expected)
   }
 
-  @Order(2)
   @Test
   fun part2_exampleInput() {
-    assertThat(day.part2(exampleInput)).isEqualTo(part2().example)
+    val expected = part2().example.invoke()
+    val actual = day.part2(exampleInput)
+    assertThat(actual).isEqualTo(expected)
   }
 
-  @Order(4)
   @Test
   fun part2_realInput() {
-    assertThat(day.part2(realInput ?: abort())).isEqualTo(part2().real)
+    val expected = part2().real.invoke()
+    val actual = day.part2(realInput ?: abort())
+    assertThat(actual).isEqualTo(expected)
   }
 
   protected abstract fun part1(): Answer
@@ -51,5 +54,7 @@ abstract class DayTest(private val day: Day) {
    * @param example expected example answer
    * @param real expected real answer
    */
-  data class Answer(val example: Any, val real: Any)
+  data class Answer(val example: () -> Any, val real: () -> Any) {
+    constructor(example: Any, real: Any) : this({ example }, { real })
+  }
 }