Day 13

Author: WVerlaek

src/main/kotlin/common/datastructures/LongPoint.kt

@@ -0,0 +1,28 @@
+package common.datastructures
+
+import kotlin.math.abs
+
+
+data class LongPoint(val col: Long, val row: Long) {
+    val x = col
+    val y = row
+
+    companion object {
+        val Zero = LongPoint(0, 0)
+
+        fun parse(line: String): LongPoint {
+            val (x, y) = line.split(",").map { it.toLong() }
+            return LongPoint(x, y)
+        }
+    }
+
+    operator fun plus(other: LongPoint) = LongPoint(col + other.col, row + other.row)
+    operator fun minus(other: LongPoint) = LongPoint(col - other.col, row - other.row)
+    operator fun times(n: Long) = LongPoint(col * n, row * n)
+
+    fun manhattanDistTo(other: LongPoint) = abs(x - other.x) + abs(y - other.y)
+
+    fun inBounds(numRows: Long, numCols: Long): Boolean {
+        return x in 0..<numCols && y in 0..<numRows
+    }
+}

src/main/kotlin/common/ext/String.kt

@@ -0,0 +1,5 @@
+package common.ext
+
+fun String.substringBetween(delimiterBefore: String, delimiterAfter: String): String {
+    return substringAfter(delimiterBefore).substringBefore(delimiterAfter)
+}

src/main/kotlin/y24/Day13.kt

@@ -0,0 +1,87 @@
+package y24
+
+import common.puzzle.solvePuzzle
+import common.puzzle.Input
+import common.puzzle.Puzzle
+import common.datastructures.*
+import common.ext.*
+import common.util.*
+import java.util.*
+import kotlin.math.*
+import kotlin.system.exitProcess
+
+
+fun main() = solvePuzzle(year = 2024, day = 13) { Day13(it) }
+
+class Day13(val input: Input) : Puzzle {
+    private val costA = 3
+    private val costB = 1
+
+    data class Machine(
+        val a: LongPoint,
+        val b: LongPoint,
+        val prize: LongPoint,
+    )
+
+    private fun parseButton(line: String): LongPoint {
+        val x = line.substringBetween("X+", ",").toLong()
+        val y = line.substringAfter("Y+").toLong()
+        return LongPoint(x, y)
+    }
+
+    private fun parsePrize(line: String): LongPoint {
+        val x = line.substringBetween("X=", ",").toLong()
+        val y = line.substringAfter("Y=").toLong()
+        return LongPoint(x, y)
+    }
+
+    private fun parseInput(lines: List<String>): List<Machine> {
+        val n = (lines.size + 1) / 4
+        return (0..<n).map { i ->
+            val a = parseButton(lines[i * 4])
+            val b = parseButton(lines[i * 4 + 1])
+            val prize = parsePrize(lines[i * 4 + 2])
+            Machine(a, b, prize)
+        }
+    }
+
+    private fun minCost(machine: Machine): Long? {
+        // Using Cramer's method
+        val d = (machine.a.x * machine.b.y) - (machine.b.x * machine.a.y)
+        if (d == 0L) {
+            return null
+        }
+
+        val dx = (machine.prize.x * machine.b.y) - (machine.b.x * machine.prize.y)
+        val dy = (machine.a.x * machine.prize.y) - (machine.prize.x * machine.a.y)
+
+        if (dx % d != 0L) {
+            return null
+        }
+        val m = dx / d
+
+        if (dy %d != 0L) {
+            return null
+        }
+        val n = dy / d
+
+        return m * costA + n * costB
+    }
+
+    override fun solveLevel1(): Any {
+        val machines = parseInput(input.lines)
+        return machines.mapNotNull { minCost(it) }.sum()
+    }
+
+    override fun solveLevel2(): Any {
+        val machines = parseInput(input.lines).map { machine ->
+            machine.copy(
+                prize = machine.prize.copy(
+                    col = machine.prize.col + 10000000000000L,
+                    row = machine.prize.row + 10000000000000L,
+                )
+            )
+        }
+        return machines.mapNotNull { minCost(it) }.sum()
+    }
+}

src/test/kotlin/y24/Day13Test.kt

@@ -0,0 +1,37 @@
+package y24
+
+import common.puzzle.Input
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class Day13Test {
+    private val sample = Input("""
+    Button A: X+94, Y+34
+    Button B: X+22, Y+67
+    Prize: X=8400, Y=5400
+    
+    Button A: X+26, Y+66
+    Button B: X+67, Y+21
+    Prize: X=12748, Y=12176
+    
+    Button A: X+17, Y+86
+    Button B: X+84, Y+37
+    Prize: X=7870, Y=6450
+    
+    Button A: X+69, Y+23
+    Button B: X+27, Y+71
+    Prize: X=18641, Y=10279
+    """.trimIndent())
+
+    private val day = Day13(sample)
+
+    @Test
+    fun solveLevel1() {
+        assertEquals(480L, day.solveLevel1())
+    }
+
+    @Test
+    fun solveLevel2() {
+         // No sample
+    }
+}