ShortestPaths: neighbourPredicate, allow no path to be found

* neighbourPredicate makes the accessible grid cells customizable
* if no path can be found, let aStarAllPaths() return an empty list of paths

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/extensions/graphs/ShortestPaths.kt

@@ -86,5 +86,5 @@ fun <N> aStarAllPaths(
     }
 
     // Open set is empty but goal was never reached
-    error("No path found from $start to goal")
+    return emptyList()
 }

src/main/kotlin/de/ronny_h/aoc/extensions/grids/Grid.kt

@@ -183,20 +183,24 @@ abstract class Grid<T>(
             } else {
                 writer.print(element)
             }
-            if (position.col == width - 1) writer.println()
+            if (position.col == width - 1) writer.print('\n')
         }.last()
     }
 
     /**
      * Determines all shortest paths possible from [start] to [goal] with the following conditions:
-     * - The Grid's [nullElement] is the obstacle.
+     * - The [neighbourPredicate] defines the cells that are no obstacle - the obstacle defaults to the Grid's [nullElement].
      * - No path outside the Grid is possible.
      * - Only direct neighbours (no diagonal ones) are considered.
      * - The cost of moving to a neighbour equals 1.
      */
-    fun shortestPaths(start: Coordinates, goal: Coordinates): List<ShortestPath<Coordinates>> {
+    fun shortestPaths(
+        start: Coordinates,
+        goal: Coordinates,
+        neighbourPredicate: (Coordinates) -> Boolean = { getAt(it) != nullElement }
+    ): List<ShortestPath<Coordinates>> {
         val neighbours: (Coordinates) -> List<Coordinates> = { position ->
-            position.neighbours().filter { getAt(it) != nullElement }
+            position.neighbours().filter(neighbourPredicate)
         }
 
         val d: (Coordinates, Coordinates) -> Int = { a, b ->

src/test/kotlin/de/ronny_h/aoc/extensions/graphs/ShortestPathTest.kt

@@ -177,4 +177,14 @@ class ShortestPathTest : StringSpec({
         aStar(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe
                 ShortestPath(listOf(start, a, b, goal), 9)
     }
+
+    "When there is no path at all, aStarAllPaths returns an empty list" {
+        val start = Node(At(0, 0))
+        val goal = Node(At(0, 10))
+
+        val d: (Node, Node) -> Int = { _, _ -> 0 }
+        val h: (Node) -> Int = { n -> n.position taxiDistanceTo goal.position }
+
+        aStarAllPaths(start, goal::positionEquals, { emptyList() }, d, h) shouldBe emptyList()
+    }
 })

src/test/kotlin/de/ronny_h/aoc/extensions/grids/GridTest.kt

@@ -11,7 +11,7 @@ import io.kotest.matchers.shouldNotBe
 
 class GridTest : StringSpec() {
 
-    private val newLine: String = System.lineSeparator()
+    private val newLine = '\n'
 
     init {
         "a grid can be constructed from List of String" {

src/test/kotlin/de/ronny_h/aoc/extensions/grids/SimpleCharGridTest.kt

@@ -109,6 +109,22 @@ class SimpleCharGridTest : StringSpec({
         )
     }
 
+    "customized obstacles are not part of the shortest path" {
+        val grid = SimpleCharGrid(listOf("0X2", "3#5", "678"), '#')
+        grid.shortestPaths(
+            start = Coordinates(0, 0),
+            goal = Coordinates(0, 2),
+            neighbourPredicate = { grid.getAt(it) !in listOf('X', '#') }
+        ) shouldBe listOf(
+            ShortestPath(
+                listOf(
+                    Coordinates(0, 0), Coordinates(1, 0), Coordinates(2, 0),
+                    Coordinates(2, 1), Coordinates(2, 2), Coordinates(1, 2), Coordinates(0, 2)
+                ), 6
+            ),
+        )
+    }
+
     "cluster regions of same char with a single region" {
         val input = """
             xx