Day 17

Part 1 is fine. Part 2 isn't exactly clever, but it works well enough.

Author: cluddles

.gitignore

@@ -3,6 +3,7 @@ build/
 !gradle/wrapper/gradle-wrapper.jar
 !**/src/main/**/build/
 !**/src/test/**/build/
+*.hprof
 
 ### IntelliJ IDEA ###
 .idea

aoc-secret

@@ -22,6 +22,7 @@ fun main() {
         Day14,
         Day15,
         Day16,
+        Day17,
     )
 
     measureTime {

src/main/kotlin/com/cluddles/aoc/y2024/All2024.kt

@@ -0,0 +1,93 @@
+package com.cluddles.aoc.y2024
+
+import com.cluddles.aoc.core.Harness
+import com.cluddles.aoc.core.Solver
+import com.cluddles.aoc.core.SolverInput
+import kotlin.math.pow
+
+/** Chronospatial Computer */
+object Day17: Solver<Day17.Input, String> {
+
+    data class Input(val a: Long, val b: Long, val c: Long, val program: List<Int>)
+
+    override fun prepareInput(src: SolverInput): Input {
+        val reg = src.lines().take(3).map { it.split(": ")[1].toLong() }.toList()
+        return Input(
+            reg[0],
+            reg[1],
+            reg[2],
+            src.lines()
+                .dropWhile { !it.contains("Program") }
+                .first()
+                .split(": ")[1]
+                .split(",")
+                .map { it.toInt() }
+        )
+    }
+
+    data class State(var a: Long, var b: Long, var c: Long, var ip: Int, val out: MutableList<Int>)
+
+    enum class Instruction { ADV, BXL, BST, JNZ, BXC, OUT, BDV, CDV }
+
+    fun apply(state: State, i: Instruction, operand: Int) {
+        var skipIpUpdate = false
+        when (i) {
+            Instruction.ADV -> state.a = state.a / (2.0).pow(combo(state, operand).toDouble()).toLong()
+            Instruction.BXL -> state.b = state.b xor operand.toLong()
+            Instruction.BST -> state.b = combo(state, operand) % 8
+            Instruction.JNZ -> if (state.a != 0L) { state.ip = operand; skipIpUpdate = true }
+            Instruction.BXC -> state.b = state.b xor state.c
+            Instruction.OUT -> state.out += (combo(state, operand) % 8).toInt()
+            Instruction.BDV -> state.b = state.a / (2.0).pow(combo(state, operand).toDouble()).toLong()
+            Instruction.CDV -> state.c = state.a / (2.0).pow(combo(state, operand).toDouble()).toLong()
+        }
+        if (!skipIpUpdate) state.ip += 2
+    }
+
+    private fun combo(state: State, v: Int): Long {
+        return when(v) {
+            0, 1, 2, 3 -> v.toLong()
+            4 -> state.a
+            5 -> state.b
+            6 -> state.c
+            else -> error("Unsupported $v")
+        }
+    }
+
+    fun run(input: Input): State {
+        val state = State(input.a, input.b, input.c, 0, mutableListOf())
+        while (state.ip < input.program.size) {
+            apply(state, Instruction.entries[input.program[state.ip]], input.program[state.ip + 1])
+        }
+        return state
+    }
+
+    override fun solvePart1(input: Input): String {
+        return run(input).out.joinToString(",")
+    }
+
+    override fun solvePart2(input: Input): String {
+        // For my input (And possibly others? It works on the test input too)
+        // Each iteration around the program reduces the "a" register by dividing it by 8
+        // So we can try to find a match for the last digit, then multiply by 8 and try for the next digit, and so on
+        // Doing this with string.endsWith is probably not optimal, but it is concise...
+        var a = 0L
+        val inputProgStr = input.program.joinToString()
+        while (true) {
+            val stateOutStr = run(Input(a, input.b, input.c, input.program)).out.joinToString()
+            if (stateOutStr == inputProgStr) {
+                return a.toString()
+            } else if (inputProgStr.endsWith(stateOutStr)) {
+                // 0*8 = 0... try not to get stuck
+                a = maxOf(a * 8, 1)
+            } else {
+                a++
+            }
+        }
+    }
+
+}
+
+fun main() {
+    Harness.run(Day17)
+}

src/main/kotlin/com/cluddles/aoc/y2024/Day17.kt

@@ -0,0 +1,51 @@
+package com.cluddles.aoc.y2024
+
+import com.cluddles.aoc.core.SolverInput
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class Day17Test {
+
+    val solver = Day17
+
+    val input = solver.prepareInput(SolverInput.fromPath(solver.examplePath))
+
+    private fun testInput(program: String, a: Int = 0, b: Int = 0, c: Int = 0): Day17.Input {
+        return Day17.Input(a.toLong(), b.toLong(), c.toLong(), program.split(",").map { it.toInt() })
+    }
+
+    @Test fun instructionOp_ex1() {
+        assertThat(solver.run(testInput("2,6", c = 9)).b).isEqualTo(1)
+    }
+
+    @Test fun instructionOp_ex2() {
+        assertThat(solver.run(testInput("5,0,5,1,5,4", a = 10)).out).isEqualTo(listOf(0,1,2))
+    }
+
+    @Test fun instructionOp_ex3() {
+        val state = solver.run(testInput("0,1,5,4,3,0", a = 2024))
+        assertThat(state.out).isEqualTo(listOf(4,2,5,6,7,7,7,7,3,1,0))
+        assertThat(state.a).isEqualTo(0)
+    }
+
+    @Test fun instructionOp_ex4() {
+        assertThat(solver.run(testInput("1,7", b = 29)).b).isEqualTo(26)
+    }
+
+    @Test fun instructionOp_ex5() {
+        assertThat(solver.run(testInput("4,0", b = 2024, c = 43690)).b).isEqualTo(44354)
+    }
+
+    @Test fun part1() {
+        assertThat(solver.solvePart1(input)).isEqualTo("4,6,3,5,6,3,5,2,1,0")
+    }
+
+    @Test fun part2_check() {
+        assertThat(solver.run(testInput("0,3,5,4,3,0", a = 117440)).out).isEqualTo(listOf(0,3,5,4,3,0))
+    }
+
+    @Test fun part2() {
+        assertThat(solver.solvePart2(testInput("0,3,5,4,3,0"))).isEqualTo("117440")
+    }
+
+}

src/test/kotlin/com/cluddles/aoc/y2024/Day17Test.kt

@@ -0,0 +1,5 @@
+Register A: 729
+Register B: 0
+Register C: 0
+
+Program: 0,1,5,4,3,0