Not yet a solution for Day 16, part one

The small examples are computed right. But for the puzzle input the
computed value is too high.

Author: rhaendel

src/main/kotlin/Day16.kt

@@ -0,0 +1,136 @@
+import de.ronny_h.extensions.Coordinates
+import de.ronny_h.extensions.Direction
+import de.ronny_h.extensions.Grid
+import de.ronny_h.extensions.aStar
+
+fun main() {
+    val day = "Day16"
+
+    println("$day part 1")
+
+    fun part1(input: List<String>): Int {
+        val maze = ReindeerMaze(input)
+        maze.printGrid()
+        return maze.calculateLowestScore()
+    }
+
+    printAndCheck(
+        """
+            ###############
+            #.......#....E#
+            #.#.###.#.###.#
+            #.....#.#...#.#
+            #.###.#####.#.#
+            #.#.#.......#.#
+            #.#.#####.###.#
+            #...........#.#
+            ###.#.#####.#.#
+            #...#.....#.#.#
+            #.#.#.###.#.#.#
+            #.....#...#.#.#
+            #.###.#.#.#.#.#
+            #S..#.....#...#
+            ###############
+        """.trimIndent().lines(),
+        ::part1, 7036
+    )
+
+    printAndCheck(
+        """
+            #################
+            #...#...#...#..E#
+            #.#.#.#.#.#.#.#.#
+            #.#.#.#...#...#.#
+            #.#.#.#.###.#.#.#
+            #...#.#.#.....#.#
+            #.#.#.#.#.#####.#
+            #.#...#.#.#.....#
+            #.#.#####.#.###.#
+            #.#.#.......#...#
+            #.#.###.#####.###
+            #.#.#...#.....#.#
+            #.#.#.#####.###.#
+            #.#.#.........#.#
+            #.#.#.#########.#
+            #S#.............#
+            #################
+        """.trimIndent().lines(),
+        ::part1, 11048
+    )
+
+    val input = readInput(day)
+    printAndCheck(input, ::part1, 89471)
+    // too high:  89472
+    // too high:  89471
+    // not right: 88971
+    // too low:   88472
+
+
+    println("$day part 2")
+
+    fun part2(input: List<String>) = input.size
+
+    printAndCheck(input, ::part2, 6512)
+}
+
+private class ReindeerMaze(input: List<String>) : Grid<Char>(input) {
+    private val wall = '#'
+    override val nullElement = wall
+    override fun Char.toElementType() = this
+
+    data class Node(val direction: Direction, val position: Coordinates) {
+        // hashCode and equals are used to determine if a Node was already visited.
+        // -> don't distinguish directions
+        override fun hashCode() = position.hashCode()
+        override fun equals(other: Any?): Boolean {
+            if (other !is Node) {
+                return false
+            }
+            return position == other.position
+        }
+        override fun toString() = "$position$direction"
+    }
+
+    fun calculateLowestScore(): Int {
+        // A* algorithm
+        // - heuristic function: manhattan distance
+        // - weight function:
+        //   * 1 for going forward
+        //   * 1000 for each 90° turn
+        val start = Node(Direction.EAST, Coordinates(height - 2, 1))
+        val goal = Node(Direction.EAST, Coordinates(1, width - 2))
+
+        val neighbours: (Node) -> List<Node> = { n ->
+            n.position.directedNeighbours()
+                .filter { !it.first.isOpposite(n.direction) } // don't go back
+                .filter { getAt(it.second) != wall }
+                .map { Node(it.first, it.second) }
+        }
+
+        val d: (Node, Node) -> Int = { a, b ->
+            require(a.position in b.position.neighbours())
+            if (a.position == goal.position && b.position == goal.position) {
+                // direction at goal doesn't care
+                0
+            } else if (a.direction - b.direction == 0) {
+                // straight ahead
+                1
+            } else {
+                // turn left, right or u-turn -> turn cost + move cost
+                (a.direction - b.direction) * 1000 + 1
+            }
+        }
+
+        val h: (Node) -> Int = { n -> n.position taxiDistanceTo goal.position }
+
+        val printIt: (Set<Node>, Node, () -> String) -> Unit = { visited, current, info ->
+            printGrid(visited.map { it.position }.toSet(), 'o', current.position, current.direction)
+            println(info.invoke())
+        }
+
+        val shortestPath = aStar(start, goal, neighbours, d, h) //, printIt)
+        printGrid(path = shortestPath.path.associate { it.position to it.direction.asChar() })
+        return shortestPath.distance
+    }
+
+}

src/main/kotlin/de/ronny_h/extensions/Coordinates.kt

@@ -12,11 +12,19 @@ data class Coordinates(val row: Int, val col: Int) {
     operator fun plus(direction: Direction) = Coordinates(row + direction.row, col + direction.col)
 
     fun neighbours() = listOf(this + EAST, this + SOUTH, this + WEST, this + NORTH)
+    fun directedNeighbours() = listOf(
+        EAST to this + EAST,
+        SOUTH to this + SOUTH,
+        WEST to this + WEST,
+        NORTH to this + NORTH,
+    )
 
     /**
      * Calculates the taxi distance, a.k.a. Manhattan distance, between this and the other Coordinates instance.
      */
     infix fun taxiDistanceTo(other: Coordinates): Int = abs(other.col - col) + abs(other.row - row)
+
+    override fun toString() = "($row,$col)"
 }
 
 operator fun Int.times(other: Coordinates) = Coordinates(this * other.row, this * other.col)
@@ -51,4 +59,30 @@ enum class Direction(val row: Int, val col: Int) {
 
     fun isHorizontal(): Boolean = this == EAST || this == WEST
     fun isVertical(): Boolean = this == NORTH || this == SOUTH
+
+    fun isOpposite(other: Direction) = when (this) {
+        NORTH -> other == SOUTH
+        EAST -> other == WEST
+        SOUTH -> other == NORTH
+        WEST -> other == EAST
+    }
+
+    /**
+     * Returns the minimal number of 90° rotations necessary to rotate this
+     * to other.
+     */
+    operator fun minus(other: Direction): Int {
+        return when {
+            this == other -> 0
+            this.isOpposite(other) -> 2
+            else -> 1
+        }
+    }
+
+    override fun toString() = when (this) {
+        NORTH -> "N"
+        EAST -> "E"
+        SOUTH -> "S"
+        WEST -> "W"
+    }
 }

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

@@ -52,11 +52,14 @@ abstract class Grid<T>(input: List<String>) {
         overrides: Set<Coordinates> = setOf(),
         overrideChar: Char = '#',
         highlightPosition: Coordinates? = null,
-        highlightDirection: Direction? = null
+        highlightDirection: Direction? = null,
+        path: Map<Coordinates, Char> = mapOf(),
     ) {
         forEachCoordinates { position, element ->
             if (highlightPosition == position && highlightDirection != null) {
                 print(highlightDirection.asChar())
+            } else if (path.contains(position)) {
+                print(path[position])
             } else if (overrides.contains(position)) {
                 print(overrideChar)
             } else {

src/main/kotlin/de/ronny_h/extensions/ShortestPath.kt

@@ -26,7 +26,8 @@ data class ShortestPath<N>(val path: List<N>, val distance: Int)
  * @param d is the distance/cost function. d(m,n) provides the distance (or cost) to reach node n from node m.
  * @param h is the heuristic function. h(n) estimates the cost to reach goal from node n.
  */
-fun <N> aStar(start: N, goal: N, neighbors: (N) -> List<N>, d: (N, N) -> Int, h: (N) -> Int): ShortestPath<N> {
+fun <N> aStar(start: N, goal: N, neighbors: (N) -> List<N>, d: (N, N) -> Int, h: (N) -> Int,
+              printIt: (visited: Set<N>, current: N, additionalInfo: () -> String) -> Unit = {_, _, _ -> }): ShortestPath<N> {
     // For node n, fScore[n] := gScore[n] + h(n). fScore[n] represents our current best guess as to
     // how cheap a path could be from start to finish if it goes through n.
     val fScore = mutableMapOf<N, Int>() // map with default value of Infinity
@@ -68,6 +69,9 @@ fun <N> aStar(start: N, goal: N, neighbors: (N) -> List<N>, d: (N, N) -> Int, h:
                     openSet.add(neighbor)
                 }
             }
+            printIt(cameFrom.keys, neighbor) {
+                "current: $current=${fScore[current]}, neighbor: $neighbor=${fScore[neighbor]}, open: " + openSet.joinToString { "$it=${fScore[it]}" }
+            }
         }
     }
 

src/test/kotlin/de/ronny_h/extensions/CoordinatesTest.kt

@@ -62,6 +62,15 @@ class CoordinatesTest : StringSpec({
         )
     }
 
+    "Directed neighbours" {
+        Coordinates(5, 5).directedNeighbours() shouldContainAll listOf(
+            NORTH to Coordinates(4, 5),
+            SOUTH to Coordinates(6, 5),
+            EAST to Coordinates(5, 6),
+            WEST to Coordinates(5, 4),
+        )
+    }
+
     "Direction turnRight() turns right" {
         NORTH.turnRight() shouldBe EAST
         EAST.turnRight() shouldBe SOUTH
@@ -94,4 +103,18 @@ class CoordinatesTest : StringSpec({
         WEST.isVertical() shouldBe false
         WEST.isHorizontal() shouldBe true
     }
+
+    "Opposite directions" {
+        NORTH.isOpposite(SOUTH) shouldBe true
+        SOUTH.isOpposite(NORTH) shouldBe true
+        EAST.isOpposite(WEST) shouldBe true
+        WEST.isOpposite(EAST) shouldBe true
+    }
+
+    "Difference between directions" {
+        NORTH - NORTH shouldBe 0
+        NORTH - EAST shouldBe 1
+        NORTH - SOUTH shouldBe 2
+        NORTH - WEST shouldBe 1
+    }
 })