Solution Day 24, part two (Crossed Wires)

The final solution is not really implemented out in Kotlin.
* The Kotlin Notebook delivered a graphical representation of the circuit network
* Considerations of how a binary adder works have led to the discovery of the
  swapped wires in the circuit network
* Actually swapping these wires is implemented. For some sample addends, including
  some edge cases, the fixed circuit calculates the right results.

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/year24/day24/CrossedWires.kt

@@ -4,9 +4,9 @@ import de.ronny_h.aoc.AdventOfCode
 import de.ronny_h.aoc.extensions.toBoolean
 import de.ronny_h.aoc.extensions.toDigit
 
-fun main() = CrossedWires().run(66055249060558, 0)
+fun main() = CrossedWires().run("66055249060558", "fcd,fhp,hmk,rvf,tpc,z16,z20,z33")
 
-class CrossedWires : AdventOfCode<Long>(2024, 24) {
+class CrossedWires : AdventOfCode<String>(2024, 24) {
 
     class And : (Boolean, Boolean) -> Boolean {
         override fun invoke(a: Boolean, b: Boolean) = a && b
@@ -51,12 +51,13 @@ class CrossedWires : AdventOfCode<Long>(2024, 24) {
             Gate(in1.trim(), in2.trim(), operation, result.trim())
         }
 
-    override fun part1(input: List<String>): Long {
+    override fun part1(input: List<String>): String {
         val gates = parseGates(input)
         return parseWires(input)
             .associateBy(Wire::name)
             .simulateGates(gates)
             .withPrefixAsDecimal("z")
+            .toString()
     }
 
     private fun Map<String, Wire>.withPrefixAsDecimal(prefix: String): Long = withPrefixAsBinary(prefix)
@@ -83,31 +84,84 @@ class CrossedWires : AdventOfCode<Long>(2024, 24) {
         return wires
     }
 
-    override fun part2(input: List<String>): Long {
+    override fun part2(input: List<String>): String {
         // inputs: x00..x44, y00..y44
         // outputs: z00..z45
-        val gates = parseGates(input)
         val wires = parseWires(input).associateBy(Wire::name)
-
+        val gates = parseGates(input)
         simulateGates(wires, gates)
-        add(0, 0, wires, gates)
-        add("1".repeat(45).toLong(2), 0, wires, gates)
-        add(0, "1".repeat(45).toLong(2), wires, gates)
-        add("1".repeat(45).toLong(2), "1".repeat(45).toLong(2), wires, gates)
 
-        return 0
+        val fixedGates = fixBySwappingTheRightOutputWires(gates)
+        simulateGates(wires, fixedGates)
+
+        val largest45BitNumber = "1".repeat(45).toLong(2)
+        listOf(
+            Pair(0L, 0L),
+            Pair(1000L, 0L),
+            Pair(0L, 1000L),
+            Pair(largest45BitNumber, 0L),
+            Pair(0L, largest45BitNumber),
+            Pair(largest45BitNumber, largest45BitNumber),
+        ).forEach { (x, y) ->
+            check(add(x, y, wires, fixedGates) == x + y)
+        }
+
+        return listOf("z16", "hmk", "z20", "fhp", "rvf", "tpc", "z33", "fcd").sorted().joinToString(",")
+    }
+
+    /*
+    Using only XOR, AND and OR gates, a simple adder works like this:
+
+    The first digit:
+    - the digit: z_0 = x_0 XOR y_0
+    - carryover: c_1 = x_0 AND y_0
+
+    For higher digits:
+    - the digit: z_i   = x_i XOR y_i XOR c_i
+    - carryover: c_i+1 = (x_i AND y_i) OR ((x_i XOR y_i) AND c_i)
+
+    Looking at the graph generated by PlotCrossedWires.ipynb from top to bottom, the first z_i that is not a
+    successor of an XOR node, is z_16.
+    Its predecessor is AND, in the input: y16 AND x16 -> z16
+    It should have been the XOR node on the same level as z16: vmr XOR bnc -> hmk.
+    => swap `z16,hmk`
+
+    The same with z_20
+    => swap `z20,fhp`
+
+    z_27 has only one XOR as predecessor
+    => swap `rvf,tpc`
+
+    z_33 has an OR as predecessor
+    => swap `z33,fcd`
+     */
+    fun fixBySwappingTheRightOutputWires(gates: List<Gate>): List<Gate> = gates
+        .swapOutWires("z16", "hmk")
+        .swapOutWires("z20", "fhp")
+        .swapOutWires("rvf", "tpc")
+        .swapOutWires("z33", "fcd")
+
+    private fun List<Gate>.swapOutWires(
+        firstOut: String,
+        secondOut: String
+    ): List<Gate> {
+        val first = first { it.out == firstOut }
+        val second = first { it.out == secondOut }
+        val oneSwapped = first.copy(out = secondOut)
+        val twoSwapped = second.copy(out = firstOut)
+        return filter { it.out !in listOf(firstOut, secondOut) } + oneSwapped + twoSwapped
     }
 
-    private fun add(
+    fun add(
         x: Long,
         y: Long,
         wires: Map<String, Wire>,
         gates: List<Gate>
-    ) {
+    ): Long {
         val modifiedWires = wires.toMutableMap()
         modifiedWires.putAll(x.toWires("x"))
         modifiedWires.putAll(y.toWires("y"))
-        simulateGates(modifiedWires, gates)
+        return simulateGates(modifiedWires, gates)
     }
 
     private fun Long.toWires(prefix: String): Map<String, Wire> = toString(2)
@@ -121,7 +175,7 @@ class CrossedWires : AdventOfCode<Long>(2024, 24) {
     private fun simulateGates(
         wires: Map<String, Wire>,
         gates: List<Gate>
-    ) {
+    ): Long {
         println("--- simulating gates ---")
         val x0 = wires.withPrefixAsDecimal("x")
         val y0 = wires.withPrefixAsDecimal("y")
@@ -164,6 +218,8 @@ class CrossedWires : AdventOfCode<Long>(2024, 24) {
 
         val gatesToChange = gates.filter { it.out in wrongWires }
         println("gates to change: $gatesToChange")
+
+        return sumSimulated
     }
 }
 

src/test/kotlin/de/ronny_h/aoc/year24/day24/CrossedWiresTest.kt

@@ -104,10 +104,10 @@ class CrossedWiresTest : StringSpec({
     }
 
     "part1 small: The decimal number output on the wires starting with z" {
-        CrossedWires().part1(smallInput) shouldBe 4
+        CrossedWires().part1(smallInput) shouldBe "4"
     }
 
     "part1: The decimal number output on the wires starting with z" {
-        CrossedWires().part1(input) shouldBe 2024
+        CrossedWires().part1(input) shouldBe "2024"
     }
 })