Day 7

Author: WVerlaek

src/main/kotlin/common/puzzle/Input.kt

@@ -7,4 +7,5 @@ class Input(val string: String) {
 }
 
 fun String.splitToInts(separator: String = ",") = split(separator).map { it.toInt() }
+fun String.splitToLongs(separator: String = ",") = split(separator).map { it.toLong() }
 fun List<String>.toInts() = map { it.toInt() }

src/main/kotlin/y24/Day7.kt

@@ -0,0 +1,70 @@
+package y24
+
+import common.datastructures.*
+import common.ext.*
+import common.puzzle.*
+import common.util.*
+import java.util.*
+import kotlin.math.*
+import kotlin.system.exitProcess
+
+fun main() = solvePuzzle(year = 2024, day = 7, dryRun = false) { Day7(it) }
+
+class Day7(val input: Input) : Puzzle {
+
+    enum class Operator(val s: String, val op: (a: Long, b: Long) -> Long) {
+        Add("+", { a, b -> a + b }),
+        Multiply("*", { a, b -> a * b }),
+        Concatenate("||", {a, b -> "$a$b".toLong() }),
+    }
+    data class Equation(val testValue: Long, val numbers: List<Long>)
+    data class Solution(val operators: List<Operator>)
+
+    fun findSolutions(eq: Equation, availableOperators: List<Operator>, i: Int = 1, curTestValue: Long = eq.numbers[0], operators: MutableList<Operator> = mutableListOf()): List<Solution> {
+        if (curTestValue > eq.testValue) {
+            // No negative numbers, cannot reach testValue anymore.
+            return emptyList()
+        }
+
+        if (i == eq.numbers.size) {
+            if (curTestValue == eq.testValue) {
+                return listOf(Solution(operators.toList()))
+            }
+
+            return emptyList()
+        }
+
+        val num = eq.numbers[i]
+        return availableOperators.flatMap { op ->
+            val newTestValue = op.op(curTestValue, num)
+
+            operators.add(op)
+            val solutions = findSolutions(eq, availableOperators, i + 1, newTestValue, operators)
+            operators.removeLast()
+            solutions
+        }
+    }
+
+    private fun parseInput(lines: List<String>): List<Equation> {
+        return lines.map { line ->
+            val (testValue, numbers) = line.split(": ")
+            Equation(testValue.toLong(), numbers.splitToLongs(" "))
+        }
+    }
+
+    override fun solveLevel1(): Any {
+        val equations = parseInput(input.lines)
+
+        return equations.filter { eq ->
+            findSolutions(eq, listOf(Operator.Add, Operator.Multiply)).isNotEmpty()
+        }.sumOf { it.testValue }
+    }
+
+    override fun solveLevel2(): Any {
+        val equations = parseInput(input.lines)
+
+        return equations.filter { eq ->
+            findSolutions(eq, listOf(Operator.Add, Operator.Multiply, Operator.Concatenate)).isNotEmpty()
+        }.sumOf { it.testValue }
+    }
+}

src/test/kotlin/y24/Day7Test.kt

@@ -0,0 +1,31 @@
+package y24
+
+import common.puzzle.Input
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class Day7Test {
+    private val sample = Input("""
+    190: 10 19
+    3267: 81 40 27
+    83: 17 5
+    156: 15 6
+    7290: 6 8 6 15
+    161011: 16 10 13
+    192: 17 8 14
+    21037: 9 7 18 13
+    292: 11 6 16 20
+    """.trimIndent())
+
+    private val day = Day7(sample)
+
+    @Test
+    fun solveLevel1() {
+        assertEquals(3749L, day.solveLevel1())
+    }
+
+    @Test
+    fun solveLevel2() {
+         assertEquals(11387L, day.solveLevel2())
+    }
+}