Day 21

Author: WVerlaek

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

@@ -14,6 +14,14 @@ fun Point.toDir() = Dir(row, col)
 val directions: List<Dir> = (0..3).map { i -> Dir(neighsY[i], neighsX[i]) }
 val directionsWithDiagonals: List<Dir> = neighsYDiags.zip(neighsXDiags) { y, x -> Dir(y, x) }
 
+fun Dir.toChar() = when (this) {
+    Dir(-1, 0) -> '^'
+    Dir(0, 1) -> '>'
+    Dir(1, 0) -> 'v'
+    Dir(0, -1) -> '<'
+    else -> error("invalid dir")
+}
+
 class Grid<T>(val rows: List<List<Cell<T>>>) {
     constructor(rows: Int, cols: Int, constructor: (row: Int, col: Int) -> T) : this(Array(rows) { row ->
         Array(cols) { col ->
@@ -25,6 +33,15 @@ class Grid<T>(val rows: List<List<Cell<T>>>) {
             Cell<T>(row, col, constr(row, col, input[row][col]))
         }.toList()
     }.toList())
+    companion object {
+        fun <T> fromValues(rows: List<List<T>>): Grid<T> {
+            return Grid(rows.mapIndexed { rowId, row ->
+                row.mapIndexed { col, value ->
+                    Cell(rowId, col, value)
+                }
+            })
+        }
+    }
 
     operator fun get(row: Int) = rows[row]
     operator fun get(p: Point) = rows[p.row][p.col]

src/main/kotlin/y24/Day21.kt

@@ -0,0 +1,114 @@
+package y24
+
+import common.puzzle.solvePuzzle
+import common.puzzle.Input
+import common.puzzle.Puzzle
+import common.datastructures.*
+
+
+fun main() = solvePuzzle(year = 2024, day = 21) { Day21(it) }
+
+typealias PressMap = Map<Pair<Char, Char>, List<String>>
+
+class Day21(val input: Input) : Puzzle {
+    private val numpad = Grid(listOf(
+        "789",
+        "456",
+        "123",
+        " 0A",
+    )) { _, _, c -> c }
+    private val keypad = Grid(listOf(
+        " ^A",
+        "<v>",
+    )) { _, _, c -> c }
+
+    data class CacheKey(
+        val from: Char,
+        val to: Char,
+        val robots: Int,
+    )
+    private val cache = mutableMapOf<CacheKey, Long>()
+
+    private val numpadPresses: PressMap = createNumpadPresses(numpad)
+    private val keypadPresses: PressMap = createNumpadPresses(keypad)
+
+    private fun createNumpadPresses(grid: Grid<Char>): PressMap {
+        val result = mutableMapOf<Pair<Char, Char>, List<String>>()
+        grid.cells().forEach { c1 ->
+            grid.cells().forEach { c2 ->
+                result[c1.value to c2.value] = createPressesBetween(grid, c1.toPoint(), c2.toPoint(), mutableSetOf())
+            }
+        }
+
+        return result
+    }
+
+    private fun createPressesBetween(grid: Grid<Char>, from: Point, to: Point, visited: MutableSet<Char>): List<String> {
+        if (from == to) {
+            return listOf("A")
+        }
+
+        return directions.flatMap { dir ->
+            val neigh = from + dir.toPoint()
+            if (!grid.withinBounds(neigh.row, neigh.col)) {
+                return@flatMap emptyList()
+            }
+
+            val cell = grid[neigh]
+            if (cell.value == ' ' || cell.value in visited) {
+                return@flatMap emptyList()
+            }
+
+            visited += cell.value
+            return@flatMap createPressesBetween(grid, neigh, to, visited)
+                .map { sequence -> dir.toChar() + sequence }
+                .also {
+                    visited -= cell.value
+                }
+        }
+    }
+
+    private fun keyPresses(pressMap: PressMap, key: CacheKey): Long {
+        if (key in cache) {
+            return cache.getValue(key)
+        }
+
+        if (key.robots == 0) {
+            return 1L
+        }
+
+        return pressMap.getValue(key.from to key.to).minOf { pressSequence ->
+            var c = 'A'
+            pressSequence.sumOf { toPress ->
+                keyPresses(keypadPresses, CacheKey(c, toPress, key.robots - 1)).also {
+                    c = toPress
+                }
+            }
+        }.also {
+            cache[key] = it
+        }
+    }
+
+    private fun sequenceMinPresses(seq: String, numRobots: Int): Long {
+        var c = 'A'
+        return seq.sumOf { toC ->
+            keyPresses(numpadPresses, CacheKey(c, toC, numRobots + 1)).also {
+                c = toC
+            }
+        }
+    }
+
+    override fun solveLevel1(): Any {
+        return input.lines.sumOf { seq ->
+            val numeric = seq.filter { it.isDigit() }.toInt()
+            numeric * sequenceMinPresses(seq, 2)
+        }
+    }
+
+    override fun solveLevel2(): Any {
+        return input.lines.sumOf { seq ->
+            val numeric = seq.filter { it.isDigit() }.toInt()
+            numeric * sequenceMinPresses(seq, 25)
+        }
+    }
+}

src/test/kotlin/y24/Day21Test.kt

@@ -0,0 +1,27 @@
+package y24
+
+import common.puzzle.Input
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class Day21Test {
+    private val sample = Input("""
+    029A
+    980A
+    179A
+    456A
+    379A
+    """.trimIndent())
+
+    private val day = Day21(sample)
+
+    @Test
+    fun solveLevel1() {
+        assertEquals(126384L, day.solveLevel1())
+    }
+
+    @Test
+    fun solveLevel2() {
+         assertEquals(154115708116294L, day.solveLevel2())
+    }
+}