Add solution for Y2024D18.

Author: Jadarma

Diff for: README.md

@@ -15,7 +15,7 @@ _"Anything that's worth doing, is worth overdoing."_
 Table of contents to jump straight to the problem you're looking for.
 
 <details open>
-    <summary>2024 (34x⭐)</summary>
+    <summary>2024 (36x⭐)</summary>
 
 | Day | Title                                                       | Stars |
 |:---:|:------------------------------------------------------------|:-----:|
@@ -36,6 +36,7 @@ Table of contents to jump straight to the problem you're looking for.
 | 15  | [Warehouse Woes](solutions/aockt/y2024/Y2024D15.kt)         |  ⭐⭐   |
 | 16  | [Reindeer Maze](solutions/aockt/y2024/Y2024D16.kt)          |  ⭐⭐   |
 | 17  | [Chronospatial Computer](solutions/aockt/y2024/Y2024D17.kt) |  ⭐⭐   |
+| 18  | [RAM Run](solutions/aockt/y2024/Y2024D18.kt)                |  ⭐⭐   |
 
 </details>
 

Diff for: inputs/aockt/y2024/d18/input.txt

@@ -3,7 +3,7 @@ package aockt.util
 import java.util.PriorityQueue
 
 /** A type implementing this interface can represent a network of nodes usable for search algorithms. */
-interface Graph<T : Any> {
+fun interface Graph<T : Any> {
 
     /** Returns all the possible nodes to visit starting from this [node] associated with the cost of travel. */
     fun neighboursOf(node: T): Iterable<Pair<T, Int>>

Diff for: inputs/aockt/y2024/d18/solution_part1.txt

@@ -0,0 +1,68 @@
+package aockt.y2024
+
+import aockt.util.*
+import aockt.util.spacial.*
+import io.github.jadarma.aockt.core.Solution
+
+object Y2024D18 : Solution {
+
+    /**
+     * Returns the minimum amount of steps needed to navigate the [area] from corner to corner, avoiding the
+     * [corrupted] points, or -1 if it is impossible to do so.
+     */
+    private fun stepsToEscape(area: Area, corrupted: Set<Point>): Int =
+        Graph<Pair<Point, Direction>> { (point, direction) ->
+            Direction.all
+                .asSequence()
+                .minus(direction.opposite)
+                .map { point.move(it) to it }
+                .filter { it.first in area }
+                .filterNot { it.first in corrupted }
+                .map { it to 1 }
+                .asIterable()
+        }.search(
+            start = Point(0, 0) to Direction.Right,
+            goalFunction = { it.first == Point(area.width - 1, area.height - 1) },
+        ).path()?.cost ?: -1
+
+    /**
+     * Parse the [input] and return the surrounding [Area] and the list of [Point]s that will get corrupted.
+     * If [partial], only returns some of the points from the actual input.
+     * The area size and partial count is determined by the size of the input, to allow for running examples.
+     */
+    private fun parseInput(input: String, partial: Boolean): Pair<Area, List<Point>> = parse {
+        val points = input
+            .lineSequence()
+            .map { it.split(',', limit = 2).map(String::toInt) }
+            .map { (x, y) -> Point(x, y) }
+            .toList()
+
+        val size = if (points.size > 50) 71 else 7
+
+        val corruptedPoints = when (partial) {
+            true -> if (size == 71) 1024 else 12
+            else -> Int.MAX_VALUE
+        }
+
+        Area(size, size) to points.take(corruptedPoints)
+    }
+
+    override fun partOne(input: String): Int {
+        val (area, points) = parseInput(input, partial = true)
+        return stepsToEscape(area, points.toSet())
+    }
+
+    override fun partTwo(input: String): String {
+        val (area, points) = parseInput(input, partial = false)
+        var blocker = Int.MAX_VALUE
+
+        points.indices.toList().binarySearch { index ->
+            val corrupted = points.take(index + 1).toSet()
+            val canEscape = stepsToEscape(area, corrupted) > -1
+
+            if (canEscape) -1 else 1.also { blocker = index }
+        }
+
+        return with(points[blocker]) { "$x,$y" }
+    }
+}

Diff for: inputs/aockt/y2024/d18/solution_part2.txt

@@ -0,0 +1,39 @@
+package aockt.y2024
+
+import io.github.jadarma.aockt.test.AdventDay
+import io.github.jadarma.aockt.test.AdventSpec
+
+@AdventDay(2024, 18, "RAM Run")
+class Y2024D18Test : AdventSpec<Y2024D18>({
+
+    val exampleInput = """
+        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
+    """.trimIndent()
+
+    partOne { exampleInput shouldOutput 22 }
+    partTwo { exampleInput shouldOutput "6,1" }
+})