Solution Day 24, part one (Crossed Wires)

Author: rhaendel

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

@@ -0,0 +1,77 @@
+package de.ronny_h.aoc.year24.day24
+
+import de.ronny_h.aoc.AdventOfCode
+
+fun main() = CrossedWires().run(66055249060558, 0)
+
+class CrossedWires: AdventOfCode<Long>(2024, 24) {
+
+    companion object {
+        val and = { a: Boolean, b: Boolean -> a && b }
+        val or = { a: Boolean, b: Boolean -> a || b }
+        val xor = { a: Boolean, b: Boolean -> a xor b }
+    }
+
+    fun parseWires(input: List<String>) = input
+        .takeWhile { it.isNotEmpty() }
+        .map {
+            val (name, value) = it.split(": ")
+            Wire(name, value == "1")
+        }
+
+    fun parseGates(input: List<String>) = input
+        .dropWhile { it.isNotEmpty() }
+        .drop(1)
+        .map {
+            val (term, result) = it.split(" -> ")
+            val (in1, op, in2) = term.split(" ")
+            val operation = when(op) {
+                "AND" -> and
+                "OR" -> or
+                "XOR" -> xor
+                else -> error("Operation not supported: $op")
+            }
+            Gate(in1.trim(), in2.trim(), operation, result.trim())
+        }
+
+    override fun part1(input: List<String>): Long {
+        val wires = parseWires(input)
+            .associateBy(Wire::name)
+            .toMutableMap()
+        val gates = parseGates(input)
+        val zWiresToCalculate = gates.count { it.out.startsWith("z") }
+
+        do {
+            val simulatableGates = gates.filter { it.in1 in wires && it.in2 in wires }
+            val outWires = simulatableGates
+                .map { it.simulateWith(wires) }
+                .associateBy(Wire::name)
+            wires.putAll(outWires)
+        } while (zWiresToCalculate != wires.count { it.key.startsWith("z") })
+
+        return wires.values
+            .filter { it.name.startsWith("z") }
+            .sortedByDescending(Wire::name)
+            .joinToString("") {
+                when (it.value) {
+                    true -> "1"
+                    false -> "0"
+                }
+            }
+            .toLong(2)
+    }
+
+    override fun part2(input: List<String>): Long {
+        TODO("Not yet implemented")
+    }
+}
+
+data class Wire(val name: String, val value: Boolean)
+data class Gate(val in1: String, val in2: String, val operation: (Boolean, Boolean) -> (Boolean), val out: String) {
+    fun simulateWith(inWires: Map<String, Wire>): Wire = Wire(
+        out,
+        operation(inWires.valueOf(in1), inWires.valueOf(in2))
+    )
+}
+
+private fun Map<String, Wire>.valueOf(inWire: String): Boolean = getValue(inWire).value

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

@@ -0,0 +1,113 @@
+package de.ronny_h.aoc.year24.day24
+
+import de.ronny_h.aoc.extensions.asList
+import de.ronny_h.aoc.year24.day24.CrossedWires.Companion.and
+import de.ronny_h.aoc.year24.day24.CrossedWires.Companion.or
+import de.ronny_h.aoc.year24.day24.CrossedWires.Companion.xor
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.data.forAll
+import io.kotest.data.row
+import io.kotest.matchers.shouldBe
+
+class CrossedWiresTest : StringSpec({
+
+    val verySmallInput = """
+        y01: 1
+        y02: 0
+
+        x00 AND y00 -> z00
+        x01 XOR y01 -> z01
+    """.asList()
+    val smallInput = """
+        x00: 1
+        x01: 1
+        x02: 1
+        y00: 0
+        y01: 1
+        y02: 0
+
+        x00 AND y00 -> z00
+        x01 XOR y01 -> z01
+        x02 OR y02 -> z02
+    """.asList()
+    val input = """
+        x00: 1
+        x01: 0
+        x02: 1
+        x03: 1
+        x04: 0
+        y00: 1
+        y01: 1
+        y02: 1
+        y03: 1
+        y04: 1
+        
+        ntg XOR fgs -> mjb
+        y02 OR x01 -> tnw
+        kwq OR kpj -> z05
+        x00 OR x03 -> fst
+        tgd XOR rvg -> z01
+        vdt OR tnw -> bfw
+        bfw AND frj -> z10
+        ffh OR nrd -> bqk
+        y00 AND y03 -> djm
+        y03 OR y00 -> psh
+        bqk OR frj -> z08
+        tnw OR fst -> frj
+        gnj AND tgd -> z11
+        bfw XOR mjb -> z00
+        x03 OR x00 -> vdt
+        gnj AND wpb -> z02
+        x04 AND y00 -> kjc
+        djm OR pbm -> qhw
+        nrd AND vdt -> hwm
+        kjc AND fst -> rvg
+        y04 OR y02 -> fgs
+        y01 AND x02 -> pbm
+        ntg OR kjc -> kwq
+        psh XOR fgs -> tgd
+        qhw XOR tgd -> z09
+        pbm OR djm -> kpj
+        x03 XOR y03 -> ffh
+        x00 XOR y04 -> ntg
+        bfw OR bqk -> z06
+        nrd XOR fgs -> wpb
+        frj XOR qhw -> z04
+        bqk OR frj -> z07
+        y03 OR x01 -> nrd
+        hwm AND bqk -> z03
+        tgd XOR rvg -> z12
+        tnw OR pbm -> gnj
+    """.asList()
+
+    "wires can be parsed" {
+        CrossedWires().parseWires(verySmallInput) shouldBe listOf(Wire("y01", true), Wire("y02", false))
+    }
+
+    "gates can be parsed" {
+        CrossedWires().parseGates(verySmallInput) shouldBe listOf(
+                Gate("x00", "y00", and, "z00"),
+                Gate("x01", "y01", xor, "z01"),
+            )
+    }
+
+    "single gates can be simulated" {
+        val inWires = mapOf("x00" to Wire("x00", true), "y00" to Wire("y00", false))
+
+        forAll(
+            row(and, false),
+            row(or, true),
+            row(xor, true),
+        ) { operation, result ->
+            Gate("x00", "y00", operation, "z00").simulateWith(inWires) shouldBe Wire("z00", result)
+        }
+    }
+
+    "part1 small: The decimal number output on the wires starting with z" {
+        CrossedWires().part1(smallInput) shouldBe 4
+    }
+
+    "part1: The decimal number output on the wires starting with z" {
+        CrossedWires().part1(input) shouldBe 2024
+    }
+})