Day 18 finished

Author: jwcarman

src/main/kotlin/adventofcode/day18/RamRun.kt

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2025 James Carman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package adventofcode.day18
+
+import adventofcode.util.geom.plane.Point2D
+import adventofcode.util.graph.Graphs
+import adventofcode.util.grid.TextGrid
+
+fun String.parsePoints(): List<Point2D> = lines()
+    .map { it.split(',').map { split -> split.toInt() } }
+    .map { (x, y) -> Point2D(x, y) }
+
+fun List<Point2D>.generateMap() = TextGrid(List(maxOf { it.y } + 1) { ".".repeat(maxOf { it.x } + 1) })
+
+fun String.findFirstByteThatBlocksExit(): Point2D {
+    val points = parsePoints()
+    val map = points.generateMap()
+    val start = map.coordinates().first()
+    val end = map.coordinates().last()
+    val vertices = map.coordinates().filter { map[it] != '#' }.toSet()
+    val neighbors = { p: Point2D -> p.neighbors().filter { it in map }.filter { map[it] != '#' } }
+    return points.find { p ->
+        map[p] = '#'
+        !Graphs.shortestPaths(start, vertices, neighbors).pathExists(end)
+    } ?: throw IllegalStateException("No byte blocks exit")
+}
+
+fun String.findShortestPathToExitAfter(nBytes: Int): Int {
+    val points = parsePoints()
+    val map = points.generateMap()
+    points.take(nBytes).forEach { map[it] = '#' }
+    val vertices = map.coordinates().filter { map[it] != '#' }.toSet()
+    val neighbors = { p: Point2D -> p.neighbors().filter { it in map }.filter { map[it] != '#' } }
+    return Graphs.shortestPaths(
+        map.coordinates().first(),
+        vertices,
+        neighbors
+    ) { _, _ -> 1.0 }.pathTo(map.coordinates().last()).size - 1
+}

src/main/kotlin/adventofcode/util/graph/Graphs.kt

@@ -89,7 +89,7 @@ object Graphs {
         start: V,
         vertices: Set<V>,
         neighbors: (V) -> List<V>,
-        weight: (V, V) -> Double
+        weight: (V, V) -> Double = { _, _ -> 1.0 }
     ): ShortestPaths<V> {
         val pred = mutableMapOf<V, V>()
         val dist = mutableMapOf<V, Double>()

src/test/kotlin/adventofcode/Day18Test.kt

@@ -16,32 +16,35 @@
 
 package adventofcode
 
+import adventofcode.day18.findFirstByteThatBlocksExit
+import adventofcode.day18.findShortestPathToExitAfter
+import adventofcode.util.geom.plane.Point2D
 import io.kotest.matchers.shouldBe
 import org.junit.jupiter.api.Test
 
 class Day18Test {
 
     @Test
     fun example1() {
-        calculatePart1(readExample1()) shouldBe 0
+        calculatePart1(readExample1(), 12) shouldBe 22
     }
 
     @Test
     fun part1() {
-        calculatePart1(readInput()) shouldBe 0
+        calculatePart1(readInput(), 1024) shouldBe 326
     }
 
     @Test
     fun example2() {
-        calculatePart2(readExample2()) shouldBe 0
+        calculatePart2(readExample2()) shouldBe Point2D(6,1)
     }
 
     @Test
     fun part2() {
-        calculatePart2(readInput()) shouldBe 0
+        calculatePart2(readInput()) shouldBe Point2D(18,62)
     }
 
-    private fun calculatePart1(input: String): Int = 0
+    private fun calculatePart1(input: String, bytes:Int): Int = input.findShortestPathToExitAfter(bytes)
 
-    private fun calculatePart2(input: String): Int = 0
+    private fun calculatePart2(input: String): Point2D = input.findFirstByteThatBlocksExit()
 }

src/test/resources/day18-example1.txt

@@ -0,0 +1,25 @@
+5,4
+4,2
+4,5
+3,0
+2,1
+6,3
+2,4
+1,5
+0,6
+3,3
+2,6
+5,1
+1,2
+5,5
+2,5
+6,5
+1,4
+0,4
+6,4
+1,1
+6,1
+1,0
+0,5
+1,6
+2,0

src/test/resources/day18-example2.txt

@@ -0,0 +1,25 @@
+5,4
+4,2
+4,5
+3,0
+2,1
+6,3
+2,4
+1,5
+0,6
+3,3
+2,6
+5,1
+1,2
+5,5
+2,5
+6,5
+1,4
+0,4
+6,4
+1,1
+6,1
+1,0
+0,5
+1,6
+2,0