Solution 2025-11 (Reactor)

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/year2025/day11/Reactor.kt

@@ -0,0 +1,56 @@
+package de.ronny_h.aoc.year2025.day11
+
+import de.ronny_h.aoc.AdventOfCode
+import de.ronny_h.aoc.extensions.memoize
+
+fun main() = Reactor().run(643, 417190406827152)
+
+class Reactor : AdventOfCode<Long>(2025, 11) {
+    override fun part1(input: List<String>): Long = ServerRack(input).numberOfPathsToOut()
+
+    override fun part2(input: List<String>): Long = ServerRack(input).numberOfPathsToOutVisitingDacAndFft()
+}
+
+data class Device(val id: String, val outputs: List<String>)
+
+fun List<String>.parseDevices() = map {
+    val (id, outputs) = it.split(": ")
+    Device(id, outputs.split(" "))
+}
+
+class ServerRack(input: List<String>) {
+    private val startId = "you"
+    private val mainOutId = "out"
+    private val serverId = "svr"
+    private val dacId = "dac"
+    private val fftId = "fft"
+
+    private val devicesById = input.parseDevices().associateBy { it.id }
+
+    fun numberOfPathsToOut(): Long = numberOfPathsBetween(startId to mainOutId)
+
+    fun numberOfPathsToOutVisitingDacAndFft(): Long {
+        val fromDacToFft = numberOfPathsBetween(dacId to fftId)
+
+        return if (fromDacToFft != 0L) {
+            numberOfPathsBetween(serverId to dacId) * fromDacToFft * numberOfPathsBetween(fftId to mainOutId)
+        } else {
+            numberOfPathsBetween(serverId to fftId) * numberOfPathsBetween(fftId to dacId) * numberOfPathsBetween(dacId to mainOutId)
+        }
+    }
+
+    private fun numberOfPathsBetween(devices: Pair<String, String>): Long {
+        println("searching from '${devices.first}' to '${devices.second}'")
+
+        lateinit var numberOfPathsBetweenRec: (Pair<String, String>) -> Long
+        numberOfPathsBetweenRec = { p: Pair<String, String> ->
+            when (p.first) {
+                p.second -> 1
+                mainOutId -> 0
+                else -> devicesById.getValue(p.first).outputs.sumOf { numberOfPathsBetweenRec(it to p.second) }
+            }
+        }.memoize()
+
+        return numberOfPathsBetweenRec(devices).also { println("-> $it") }
+    }
+}

src/test/kotlin/de/ronny_h/aoc/year2025/day11/ReactorTest.kt

@@ -0,0 +1,126 @@
+package de.ronny_h.aoc.year2025.day11
+
+import de.ronny_h.aoc.extensions.asList
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+
+class ReactorTest : StringSpec({
+
+    "parse devices" {
+        """
+            aaa: you hhh
+            you: bbb ccc
+        """.asList().parseDevices() shouldBe listOf(
+            Device("aaa", listOf("you", "hhh")),
+            Device("you", listOf("bbb", "ccc")),
+        )
+    }
+
+    "part 1: the number of paths to out" {
+        val input = """
+            aaa: you hhh
+            you: bbb ccc
+            bbb: ddd eee
+            ccc: ddd eee fff
+            ddd: ggg
+            eee: out
+            fff: out
+            ggg: out
+            hhh: ccc fff iii
+            iii: out
+        """.asList()
+        Reactor().part1(input) shouldBe 5
+    }
+
+    "part 2: exactly one straight path" {
+        val input = """
+            svr: aaa
+            aaa: dac
+            dac: ccc
+            ccc: fft
+            fft: out
+        """.asList()
+        Reactor().part2(input) shouldBe 1
+    }
+
+    "part 2: exactly one path with a bypass right" {
+        val input = """
+            svr: aaa
+            aaa: dac bya
+            dac: ccc
+            bya: ccc
+            ccc: fft
+            fft: out
+        """.asList()
+        Reactor().part2(input) shouldBe 1
+    }
+
+    "part 2: exactly one path with a bypass left" {
+        val input = """
+            svr: aaa
+            aaa: bya dac
+            bya: ccc
+            dac: ccc
+            ccc: fft
+            fft: out
+        """.asList()
+        Reactor().part2(input) shouldBe 1
+    }
+
+    "part 2: 2 paths above fft and dac" {
+        val input = """
+            svr: aaa bbb
+            aaa: dac
+            bbb: dac
+            dac: ccc
+            ccc: fft
+            fft: out
+        """.asList()
+        Reactor().part2(input) shouldBe 2
+    }
+
+    "part 2: 2 paths below fft and dac" {
+        val input = """
+            svr: aaa
+            aaa: dac
+            dac: bbb
+            bbb: fft
+            fft: ccc ddd
+            ccc: out
+            ddd: out
+        """.asList()
+        Reactor().part2(input) shouldBe 2
+    }
+
+    "part 2: 2 paths between fft and dac" {
+        val input = """
+            svr: aaa
+            aaa: dac
+            dac: bbb
+            bbb: ccc ddd
+            ccc: fft
+            ddd: fft
+            fft: out
+        """.asList()
+        Reactor().part2(input) shouldBe 2
+    }
+
+    "part 2: the number of paths from svr to out visiting ffd and dac" {
+        val input = """
+            svr: aaa bbb
+            aaa: fft
+            fft: ccc
+            bbb: tty
+            tty: ccc
+            ccc: ddd eee
+            ddd: hub
+            hub: fff
+            eee: dac
+            dac: fff
+            fff: ggg hhh
+            ggg: out
+            hhh: out
+        """.asList()
+        Reactor().part2(input) shouldBe 2
+    }
+})