Day 10 complete with some refactoring.

Author: sraaphorst

src/main/kotlin/common/intpos2d/intpos2d.kt

@@ -16,3 +16,24 @@ operator fun Int.times(pos: IntPos2D): IntPos2D =
 
 operator fun IntPos2D.times(factor: Int) =
     factor * this
+
+enum class Direction(val delta: IntPos2D) {
+    NORTH(IntPos2D(-1, 0)),
+    EAST(IntPos2D(0, 1)),
+    SOUTH(IntPos2D(1, 0)),
+    WEST(IntPos2D(0, -1));
+
+    fun clockwise(): Direction = when (this) {
+        NORTH -> EAST
+        EAST -> SOUTH
+        SOUTH -> WEST
+        WEST -> NORTH
+    }
+
+    fun counterClockwise(): Direction = when (this) {
+        NORTH -> WEST
+        WEST -> SOUTH
+        SOUTH -> EAST
+        EAST -> NORTH
+    }
+}

src/main/kotlin/day06/day06.kt

@@ -9,23 +9,6 @@ package day06
 import common.aocreader.fetchAdventOfCodeInput
 import common.intpos2d.*
 
-/**
- * The direction that the guard is facing and moves in.
- */
-private enum class Direction(val delta: IntPos2D) {
-    NORTH(IntPos2D(-1, 0)),
-    SOUTH(IntPos2D(1, 0)),
-    EAST(IntPos2D(0, 1)),
-    WEST(IntPos2D(0, -1));
-
-    fun clockwise(): Direction = when (this) {
-        NORTH -> EAST
-        EAST -> SOUTH
-        SOUTH -> WEST
-        WEST -> NORTH
-    }
-}
-
 private typealias Orientation = Pair<Direction, IntPos2D>
 
 private data class MapGrid(val rows: Int,

src/main/kotlin/day09/day09.kt

@@ -191,7 +191,7 @@ fun answer2(input: String): BigInteger =
 fun main() {
     val input = fetchAdventOfCodeInput(2024, 9)
 
-    println("--- Day 9: Resonant Collinearity ---")
+    println("--- Day 9: Disk Fragmenter ---")
 
     // Part 1: 6384282079460
     println("Part 1: ${answer1(input)}")

src/main/kotlin/day10/day10.kt

@@ -5,80 +5,64 @@ package day10
 
 import common.aocreader.fetchAdventOfCodeInput
 import common.intpos2d.*
-import common.parsing.parseGrid
 
 private typealias Trail = List<IntPos2D>
 private typealias Trails = Set<List<IntPos2D>>
 
-private enum class Direction(val delta: IntPos2D) {
-    NORTH(IntPos2D(-1, 0)),
-    EAST(IntPos2D(0, 1)),
-    SOUTH(IntPos2D(1, 0)),
-    WEST(IntPos2D(0, -1)),
-}
-
 private fun parse(input: String): List<List<Int>> =
     input.trim().lines()
-        .map { line -> line.trim().toList().map { it.digitToInt() } }
+        .map { line -> line.trim().toList().map { it.digitToIntOrNull() ?: -1 } }
 
-private fun findTrailheads(grid: List<List<Int>>): Map<IntPos2D, Trails> {
+private fun findTrails(grid: List<List<Int>>): Map<IntPos2D, Trails> {
     val height = grid.size
     val width = grid[0].size
 
-    // Instead of going from zeros to nines, we go from nines to zeros
-    // to count the number of trails to the peak.
-    // Find the nines, i.e. the ending positions of the map.
-    val nines = grid.flatMapIndexed { rowIdx, row ->
+    val zeros = grid.flatMapIndexed { rowIdx, row ->
         row.mapIndexedNotNull { colIdx, height ->
-            if (height == 9) IntPos2D(rowIdx, colIdx) else null
+            if (height == 0) IntPos2D(rowIdx, colIdx) else null
         }
     }.toSet()
 
-    // We need to track the number of trails to each nine.
-    val trails: MutableMap<IntPos2D, Trails> = mutableMapOf()
-
     // For each 9, we want to find the trails that lead to the peak.
     fun aux(trailSoFar: Trail): Trails {
         val currentPos = trailSoFar.last()
         val (currY, currX) = currentPos
         val currHeight = grid[currY][currX]
-        if (currHeight == 0) return setOf(trailSoFar)
+        if (currHeight == 9) return setOf(trailSoFar)
 
         // Try all the valid neighbours.
         val neighbours = Direction.entries
             .map { currentPos + it.delta }
             .filter { coords -> coords.first in 0 until height && coords.second in 0 until width }
-            .filter { coords -> grid[coords.first][coords.second] == currHeight - 1 }
+            .filter { coords -> grid[coords.first][coords.second] == currHeight + 1 }
         if (neighbours.isEmpty()) return emptySet()
 
         return neighbours.flatMap { pos -> aux(trailSoFar + pos) }.toSet()
     }
 
-    nines.forEach { nine ->
-        val allTrails = aux(listOf(nine))
-        trails[nine] = allTrails
-    }
-
-    return trails
+    return zeros.associate { zero -> zero to aux(listOf(zero)) }
 }
 
-fun countTrailheads(trails: Map<IntPos2D, Trails>): Int =
-    trails.values.flatten().toSet().size
+private fun countTrailheads(trails: Map<IntPos2D, Trails>): Int =
+    trails.values.sumOf { it.map { it.last() }.toSet().size }
+
+private fun countTrails(trails: Map<IntPos2D, Trails>): Int =
+    trails.values.sumOf { it.count() }
 
 fun answer1(input: String): Int =
-    parse(input).let(::findTrailheads).let(::countTrailheads)
+    parse(input).let(::findTrails).let(::countTrailheads)
 
 fun answer2(input: String): Int =
-    TODO()
+    parse(input).let(::findTrails).let(::countTrails)
 
 fun main() {
     val input = fetchAdventOfCodeInput(2024, 10)
 
-    println("--- Day 10: Resonant Collinearity ---")
+    println("--- Day 10: Hoof It ---")
 
-    // Part 1:
+    // Part 1: 719
     println("Part 1: ${answer1(input)}")
 
-    // Part 2:
+    // Part 2: 1530
     println("Part 2: ${answer2(input)}")
 }

src/test/kotlin/day10/day10.kt

@@ -27,5 +27,5 @@ class Day10Test {
 
     @Test
     fun `Problem 2 example`() =
-        assertEquals(TODO(), answer2(input))
+        assertEquals(81, answer2(input))
 }