Solution 2017-23, part 1 (Coprocessor Conflagration)

Solved by extending solution for day 18 with two additional
instructions, Sub and JumpIfNotZero.

This solves part 1 directly why it doesn't terminate in reasonable
time for part 2. For that, in CoprocessorConflagration.kt a 1:1
transformation of the assembler code functions as a base for further
analysis and simplification.

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/year2017/day18/Duet.kt

@@ -21,8 +21,8 @@ class Duet : AdventOfCode<Long>(2017, 18) {
     override fun part2(input: List<String>): Long = runBlocking {
         val channel0 = Channel<Long>(UNLIMITED)
         val channel1 = Channel<Long>(UNLIMITED)
-        val program0 = Program(input, 0, channel0, channel1)
-        val program1 = Program(input, 1, channel1, channel0)
+        val program0 = Program(input, channel0, channel1, mapOf(P_REGISTER to 0, PROGRAM_NUMBER_REGISTER to 0))
+        val program1 = Program(input, channel1, channel0, mapOf(P_REGISTER to 1, PROGRAM_NUMBER_REGISTER to 1))
 
         val job0 = launch { program0.run() }
         val job1 = launch { program1.run() }
@@ -75,6 +75,11 @@ fun List<String>.parseInstructions(
             Add(register, value.toValue())
         }
 
+        "sub" -> {
+            val (register, value) = parameters.split(" ")
+            Sub(register, value.toValue())
+        }
+
         "mul" -> {
             val (register, value) = parameters.split(" ")
             Multiply(register, value.toValue())
@@ -92,6 +97,11 @@ fun List<String>.parseInstructions(
             JumpIfGreaterZero(value.toValue(), offset.toValue())
         }
 
+        "jnz" -> {
+            val (value, offset) = parameters.split(" ")
+            JumpIfNotZero(value.toValue(), offset.toValue())
+        }
+
         else -> error("unknown instruction: $it")
     }
 }
@@ -114,9 +124,11 @@ sealed interface Value {
     }
 }
 
+private const val P_REGISTER = "p"
 private const val PROGRAM_NUMBER_REGISTER = "programNumber"
 private const val LAST_PLAYED_SOUND_REGISTER = "lastPlayedSound"
 private const val NUMBER_OF_SENDS_REGISTER = "numberOfSends"
+private const val NUMBER_OF_MULTIPLY_REGISTER = "numberOfMultiply"
 
 sealed interface Instruction {
     suspend fun executeOn(registers: MutableMap<String, Long>): Long
@@ -154,9 +166,18 @@ sealed interface Instruction {
         }
     }
 
+    data class Sub(private val register: String, val value: Value) : Instruction {
+        override suspend fun executeOn(registers: MutableMap<String, Long>): Long {
+            registers[register] = registers.getValue(register) - value.toNumber(registers)
+            return registers.getValue(register)
+        }
+    }
+
     data class Multiply(private val register: String, val value: Value) : Instruction {
         override suspend fun executeOn(registers: MutableMap<String, Long>): Long {
             registers[register] = registers.getValue(register) * value.toNumber(registers)
+            val numberOfMultiplies = registers.getValue(NUMBER_OF_MULTIPLY_REGISTER) + 1
+            registers[NUMBER_OF_MULTIPLY_REGISTER] = numberOfMultiplies
             return registers.getValue(register)
         }
     }
@@ -186,33 +207,42 @@ sealed interface Instruction {
         }
     }
 
-    data class JumpIfGreaterZero(private val value: Value, private val offset: Value) : Instruction {
+    sealed interface Jump : Instruction
+
+    data class JumpIfGreaterZero(private val value: Value, private val offset: Value) : Jump {
         override suspend fun executeOn(registers: MutableMap<String, Long>): Long {
             if (value.toNumber(registers) > 0) {
                 return offset.toNumber(registers)
             }
             return 1
         }
     }
+
+    data class JumpIfNotZero(private val value: Value, private val offset: Value) : Jump {
+        override suspend fun executeOn(registers: MutableMap<String, Long>): Long {
+            if (value.toNumber(registers) != 0L) {
+                return offset.toNumber(registers)
+            }
+            return 1
+        }
+    }
 }
 
 class Program(
     input: List<String>,
-    programNumber: Long = 0,
     sendChannel: Channel<Long>? = null,
     receiveChannel: Channel<Long>? = null,
+    presetRegisters: Map<String, Long> = emptyMap()
 ) {
     var isReceiving = false
+        private set
 
     private val instructions = input.parseInstructions(sendChannel, receiveChannel)
-    private val registers = mutableMapOf(
-        "p" to programNumber,
-        PROGRAM_NUMBER_REGISTER to programNumber,
-    ).withDefault { 0 }
+    private val registers = presetRegisters.toMutableMap().withDefault { 0 }
     private var instructionPointer = 0L
 
     suspend fun run(): Long {
-        println("program ${registers[PROGRAM_NUMBER_REGISTER]} started")
+        println("program ${registers.getValue(PROGRAM_NUMBER_REGISTER)} started")
         while (instructionPointer in instructions.indices) {
             val instruction = instructions[instructionPointer.toIntChecked()]
             if (instruction is Receive) {
@@ -224,15 +254,17 @@ class Program(
                 println("program ${registers[PROGRAM_NUMBER_REGISTER]}: instruction \"Recover\" with register not zero -> terminating")
                 return result
             }
-            instructionPointer += if (instruction is JumpIfGreaterZero) {
+            instructionPointer += if (instruction is Jump) {
                 result
             } else {
                 1L
             }
         }
-        println("program ${registers[PROGRAM_NUMBER_REGISTER]}: instruction pointer ran out of bounds: $instructionPointer -> terminating")
+        println("program ${registers.getValue(PROGRAM_NUMBER_REGISTER)}: instruction pointer ran out of bounds: $instructionPointer -> terminating")
         return -1L
     }
 
     fun getNumberOfSends(): Long = registers.getValue(NUMBER_OF_SENDS_REGISTER)
+    fun getNumberOfMultiplies(): Long = registers.getValue(NUMBER_OF_MULTIPLY_REGISTER)
+    fun getRegisterValue(register: String): Long = registers.getValue(register)
 }

src/main/kotlin/de/ronny_h/aoc/year2017/day23/CoprocessorConflagration.kt

@@ -0,0 +1,69 @@
+package de.ronny_h.aoc.year2017.day23
+
+import de.ronny_h.aoc.AdventOfCode
+import de.ronny_h.aoc.year2017.day18.Program
+import kotlinx.coroutines.runBlocking
+
+fun main() = CoprocessorConflagration().run(4225, 0)
+
+class CoprocessorConflagration : AdventOfCode<Long>(2017, 23) {
+    override fun part1(input: List<String>): Long = runBlocking {
+        val program = Program(input)
+        program.run()
+        return@runBlocking program.getNumberOfMultiplies()
+    }
+
+    override fun part2(input: List<String>): Long = runBlocking {
+        val program = Program(input, presetRegisters = mapOf("a" to 1))
+        program.run()
+        return@runBlocking program.getRegisterValue("h")
+    }
+}
+
+private fun partTwoAsKotlin(): Int {
+    val a = 1
+    var d = 0
+    var e = 0
+    var f = 0
+    var g = 0
+    var h = 0
+
+    var b = 67
+    var c = b
+    if (a != 0) {
+        b *= 100
+        b += 100000
+        c = b
+        c += 17000
+    }
+    while (true) {
+        f = 1
+        d = 2
+        do {
+            e = 2
+            do {
+                g = d
+                g *= e
+                g -= b
+                if (g == 0) {
+                    f = 0
+                }
+                e++
+                g = e
+                g -= b
+            } while (g != 0)
+            d++
+            g = d
+            g -= b
+        } while (g != 0)
+        if (f == 0) {
+            h++
+        }
+        g = b
+        g -= c
+        if (g == 0) {
+            return h
+        }
+        b += 17
+    }
+}

src/test/kotlin/de/ronny_h/aoc/year2017/day23/CoprocessorConflagrationTest.kt

@@ -0,0 +1,38 @@
+package de.ronny_h.aoc.year2017.day23
+
+import de.ronny_h.aoc.extensions.asList
+import de.ronny_h.aoc.year2017.day18.Instruction.*
+import de.ronny_h.aoc.year2017.day18.Value.Number
+import de.ronny_h.aoc.year2017.day18.Value.Register
+import de.ronny_h.aoc.year2017.day18.parseInstructions
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+
+class CoprocessorConflagrationTest : StringSpec({
+
+    val input = """
+        set h 7
+        jnz b 2
+        jnz 1 1
+        mul b 4
+        sub c -1
+    """.asList()
+
+    "input can be parsed" {
+        input.parseInstructions(null, null) shouldBe listOf(
+            SetValue("h", Number(7)),
+            JumpIfNotZero(Register("b"), Number(2)),
+            JumpIfNotZero(Number(1), Number(1)),
+            Multiply("b", Number(4)),
+            Sub("c", Number(-1))
+        )
+    }
+
+    "part 1: there should be 1 multiplication executed in the test input" {
+        CoprocessorConflagration().part1(input) shouldBe 1
+    }
+
+    "part 2: at the end of the test program h should be 7" {
+        CoprocessorConflagration().part2(input) shouldBe 7
+    }
+})