Solution 2017-08 (I Heard You Like Registers)

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/year2017/day08/IHeardYouLikeRegisters.kt

@@ -0,0 +1,94 @@
+package de.ronny_h.aoc.year2017.day08
+
+import de.ronny_h.aoc.AdventOfCode
+
+fun main() = IHeardYouLikeRegisters().run(8022, 9819)
+
+class IHeardYouLikeRegisters : AdventOfCode<Int>(2017, 8) {
+    override fun part1(input: List<String>): Int = executeInstructions(input).maxFinalValue
+    override fun part2(input: List<String>): Int = executeInstructions(input).maxProcessValue
+
+    data class Result(val maxFinalValue: Int, val maxProcessValue: Int)
+
+    private fun executeInstructions(input: List<String>): Result {
+        val registers = mutableMapOf<String, Int>()
+        var maxProcessValue = 0
+        input.parseInstructions().forEach {
+            if (it.condition.appliesTo(registers.getOrDefault(it.conditionRegister, 0), it.conditionValue)) {
+                val value = it.operation.applyTo(registers.getOrDefault(it.register, 0), it.amount)
+                if (value > maxProcessValue) {
+                    maxProcessValue = value
+                }
+                registers[it.register] = value
+            }
+        }
+        return Result(registers.values.max(), maxProcessValue)
+    }
+}
+
+enum class Operation(private val symbol: String) {
+    Increase("inc") {
+        override fun applyTo(first: Int, second: Int): Int = first + second
+    },
+    Decrease("dec") {
+        override fun applyTo(first: Int, second: Int): Int = first - second
+    };
+
+    abstract fun applyTo(first: Int, second: Int): Int
+
+    companion object {
+        private val bySymbol = Operation.entries.associateBy { it.symbol }
+
+        fun of(symbol: String) = bySymbol.getValue(symbol)
+    }
+}
+
+enum class Condition(private val symbol: String) {
+    Equal("==") {
+        override fun appliesTo(first: Int, second: Int): Boolean = first == second
+    },
+    NotEqual("!=") {
+        override fun appliesTo(first: Int, second: Int): Boolean = first != second
+    },
+    LessThan("<") {
+        override fun appliesTo(first: Int, second: Int): Boolean = first < second
+    },
+    LessThanOrEqual("<=") {
+        override fun appliesTo(first: Int, second: Int): Boolean = first <= second
+    },
+    GreaterThan(">") {
+        override fun appliesTo(first: Int, second: Int): Boolean = first > second
+    },
+    GreaterThanOrEqual(">=") {
+        override fun appliesTo(first: Int, second: Int): Boolean = first >= second
+    };
+
+    abstract fun appliesTo(first: Int, second: Int): Boolean
+
+    companion object {
+        private val bySymbol = Condition.entries.associateBy { it.symbol }
+
+        fun of(symbol: String) = bySymbol.getValue(symbol)
+    }
+}
+
+data class Instruction(
+    val register: String,
+    val operation: Operation,
+    val amount: Int,
+    val conditionRegister: String,
+    val condition: Condition,
+    val conditionValue: Int
+)
+
+fun List<String>.parseInstructions(): List<Instruction> = map {
+    val parameters = it.split(" ")
+    Instruction(
+        register = parameters[0],
+        operation = Operation.of(parameters[1]),
+        amount = parameters[2].toInt(),
+        conditionRegister = parameters[4],
+        condition = Condition.of(parameters[5]),
+        conditionValue = parameters[6].toInt(),
+    )
+}

src/test/kotlin/de/ronny_h/aoc/year2017/day08/IHeardYouLikeRegistersTest.kt

@@ -0,0 +1,35 @@
+package de.ronny_h.aoc.year2017.day08
+
+import de.ronny_h.aoc.extensions.asList
+import de.ronny_h.aoc.year2017.day08.Condition.*
+import de.ronny_h.aoc.year2017.day08.Operation.Decrease
+import de.ronny_h.aoc.year2017.day08.Operation.Increase
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+
+class IHeardYouLikeRegistersTest : StringSpec({
+
+    val input = """
+        b inc 5 if a > 1
+        a inc 1 if b < 5
+        c dec -10 if a >= 1
+        c inc -20 if c == 10
+    """.asList()
+
+    "input can be parsed" {
+        input.parseInstructions() shouldBe listOf(
+            Instruction("b", Increase, 5, "a", GreaterThan, 1),
+            Instruction("a", Increase, 1, "b", LessThan, 5),
+            Instruction("c", Decrease, -10, "a", GreaterThanOrEqual, 1),
+            Instruction("c", Increase, -20, "c", Equal, 10),
+        )
+    }
+
+    "part 1: the largest value in any register after completing the instructions" {
+        IHeardYouLikeRegisters().part1(input) shouldBe 1
+    }
+
+    "part 2: the highest value held in any register during this process" {
+        IHeardYouLikeRegisters().part2(input) shouldBe 10
+    }
+})