Solution 2018-15, part 1 (Beverage Bandits)

* Enforce the "in reading order" by passing a list to the Dijkstra algorithm
  which's elements are in the right order. Since the algorithm always takes the
  first minimal element, we achieve what we want without further effort.
* The check `Player.isDead()` is necessary because we mutate the original `units`
  list while iterating a filtered copy of it.
* Add an import alias for `Coordinates` in `SimpleCharGridTest` to make that
  intense use of that data class better readable.

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/extensions/graphs/shortestpath/Dijkstra.kt

@@ -4,7 +4,7 @@ package de.ronny_h.aoc.extensions.graphs.shortestpath
  * A [Graph] consists of a set of [vertices] and a function [edges] that returns the weight of the edge
  * between two vertices, `null` if there is no edge between them.
  */
-data class Graph<V>(val vertices: Set<V>, val edges: (V, V) -> Int?)
+data class Graph<V>(val vertices: List<V>, val edges: (V, V) -> Int?)
 
 /**
  * The [DijkstraResult] consists of [distances], storing the minimal distance from the source to each vertex,
@@ -25,21 +25,22 @@ fun <V> dijkstra(graph: Graph<V>, source: V, targets: List<V>): List<ShortestPat
 
 /**
  * Dijkstra's algorithm finds the shortest path from node [source] to all vertices in the [graph].
+ *
+ * While traversing, when more than one vertex has the same minimal distance to the current one, the vertex that comes
+ * first in the [graph]'s `vertices` list is chosen.
  */
 fun <V> dijkstra(graph: Graph<V>, source: V): DijkstraResult<V> {
     val dist = mutableMapOf(source to 0).withDefault { LARGE_VALUE }
     val prev = mutableMapOf<V, V>()
-    val q = graph.vertices.toMutableSet()
+    val q = graph.vertices.toMutableList()
 
     while (q.isNotEmpty()) {
-        // TODO if minimum is not unique, choose by a configurable criteria (with 1st as default)
         val u = q.minBy { dist.getValue(it) }
         q.remove(u)
 
         for (v in q) {
             val edgeWeight = graph.edges(u, v) ?: continue
             val alt = dist.getValue(u) + edgeWeight
-            // TODO use <= and take the prev with highest precedence
             if (alt < dist.getValue(v)) {
                 dist[v] = alt
                 prev[v] = u

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

@@ -223,7 +223,7 @@ abstract class Grid<T>(
         val graph = Graph(
             vertices = forEachCoordinates { position, element ->
                 if (element == nullElement) null else position
-            }.filterNotNull().toSet(),
+            }.filterNotNull().toList(),
             edges = { from, to ->
                 if (to in from.neighbours().filter { !isObstacle(getAt(it)) }) 1 else null
             }

src/main/kotlin/de/ronny_h/aoc/year2018/day15/BeverageBandits.kt

@@ -2,7 +2,6 @@ package de.ronny_h.aoc.year2018.day15
 
 import de.ronny_h.aoc.AdventOfCode
 import de.ronny_h.aoc.extensions.collections.filterMinBy
-import de.ronny_h.aoc.extensions.graphs.shortestpath.ShortestPath
 import de.ronny_h.aoc.extensions.grids.Coordinates
 import de.ronny_h.aoc.extensions.grids.SimpleCharGrid
 import de.ronny_h.aoc.year2018.day15.CombatArea.PlayerType.Elf
@@ -11,54 +10,42 @@ import io.github.oshai.kotlinlogging.KotlinLogging
 
 private val logger = KotlinLogging.logger {}
 
-fun main() = BeverageBandits().run(0, 0)
+fun main() = BeverageBandits().run(218272, 0)
 
-class BeverageBandits : AdventOfCode<Long>(2018, 15) {
-    override fun part1(input: List<String>): Long {
+class BeverageBandits : AdventOfCode<Int>(2018, 15) {
+    override fun part1(input: List<String>): Int {
         val combatArea = CombatArea(input)
         while (combatArea.takeOneRound()) {
             // the action takes place in the condition
         }
         return combatArea.outcome()
     }
 
-    override fun part2(input: List<String>): Long {
+    override fun part2(input: List<String>): Int {
         return 0
     }
 }
 
 class CombatArea(input: List<String>) : SimpleCharGrid(input) {
     private val cavern = '.'
-
-    private data class Player(
-        val type: PlayerType,
-        var position: Coordinates,
-        val attackPower: Int = 3,
-        var hitPoints: Int = 200
-    )
-
-    private enum class PlayerType(val char: Char) {
-        Elf('E'), Goblin('G')
-    }
-
-    private val units = buildList {
-        forEachCoordinates { position, square ->
-            when (square) {
-                Elf.char -> add(Player(Elf, position))
-                Goblin.char -> add(Player(Goblin, position))
-            }
-        }.last()
-    }.toMutableList()
-
-    private var fullRounds = 0L
+    private val attackPower = 3
+
+    private var fullRounds = 0
+    private val units = forEachCoordinates { position, square ->
+        when (square) {
+            Elf.char -> Player(Elf, position)
+            Goblin.char -> Player(Goblin, position)
+            else -> null
+        }
+    }.filterNotNull().toMutableList()
 
     /**
      * @return if combat continues
      */
     fun takeOneRound(): Boolean {
-        if (fullRounds % 10 == 0L) logStats()
+        if (fullRounds % 50 == 0) logStats()
         units.sortedBy { it.position }.forEach { unit ->
-            logger.debug { "unit $unit" }
+            logger.trace { "unit $unit" }
             val enemyType = if (unit.type == Elf) Goblin else Elf
             val targets = units.filter { it.type == enemyType }
             if (targets.isEmpty()) {
@@ -72,14 +59,30 @@ class CombatArea(input: List<String>) : SimpleCharGrid(input) {
         return true
     }
 
-    fun outcome(): Long = fullRounds * units.sumOf { it.hitPoints }
+    fun outcome(): Int {
+        logStats()
+        val hitPointsLeft = units.sumOf { it.hitPoints }
+        logger.info { "rounds: $fullRounds, hit points left: $hitPointsLeft" }
+        return fullRounds * hitPointsLeft
+    }
+
+    private data class Player(
+        val type: PlayerType,
+        var position: Coordinates,
+        var hitPoints: Int = 200
+    ) {
+        fun isDead() = hitPoints <= 0
+        override fun toString(): String = "${type.char}${position}_$hitPoints"
+    }
 
-    private data class Target(val position: Coordinates, val path: ShortestPath<Coordinates>)
+    private enum class PlayerType(val char: Char) {
+        Elf('E'), Goblin('G')
+    }
 
     private fun Player.move(
         targets: List<Player>
     ) {
-        logger.debug { " moving $this" }
+        logger.trace { " moving $this" }
         if (targets.any { it.position in position.neighbours() }) {
             // already in range of a target
             return
@@ -88,51 +91,51 @@ class CombatArea(input: List<String>) : SimpleCharGrid(input) {
         val targetsInRange = targets.flatMap { target ->
             target.position.neighbours().filter { getAt(it) == cavern }
         }
-        // TODO make path precedence in reading order configurable
-        val targetsWithPaths = shortestPaths(
+        val shortestPaths = shortestPaths(
             start = position,
             goals = targetsInRange,
             isObstacle = { it != cavern })
-            .map { Target(it.path.last(), it) }
 
-        if (targetsWithPaths.isEmpty()) {
+        if (shortestPaths.isEmpty()) {
             // no path to any target found
             return
         }
-        logger.debug { "  ${targetsWithPaths.size} paths found" }
-        val nearestTargetPath = targetsWithPaths
-            .filterMinBy { it.path.distance }
-            .filterMinBy { it.position }
-            .filterMinBy { it.path.path[1] }
+        logger.trace { "  ${shortestPaths.size} paths found" }
+        val nearestTargetPath = shortestPaths
+            .filterMinBy { it.distance }
+            .filterMinBy { it.path.last() }
+            .filterMinBy { it.path[1] }
             .first()
-        moveTo(nearestTargetPath.path.path[1])
+        moveTo(nearestTargetPath.path[1])
     }
 
     private fun Player.attack(targets: List<Player>) {
-        logger.debug { " attacking with $this" }
+        if (this.isDead()) return
+        logger.trace { " attacking with $this" }
         val opponent = position
             .neighbours()
             .mapNotNull { neighbour -> targets.firstOrNull { it.position == neighbour } }
             .filterMinBy { it.hitPoints }
             .minByOrNull { it.position }
         if (opponent == null) return
 
-        logger.debug { "  hitting $opponent" }
         opponent.hitPoints -= attackPower
+        logger.debug { " $this hit $opponent" }
 
         if (opponent.hitPoints <= 0) {
             opponent.die()
         }
     }
 
     private fun Player.moveTo(newPosition: Coordinates) {
-        logger.debug { "  moving to $newPosition" }
+        logger.debug { " $this moves to $newPosition" }
         setAt(position, cavern)
         setAt(newPosition, type.char)
         position = newPosition
     }
 
     private fun Player.die() {
+        logger.debug { " $this died" }
         setAt(position, cavern)
         units.remove(this)
     }

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

@@ -63,7 +63,7 @@ class ShortestPathTest : StringSpec({
             )
         )
         aStar(start, goal::positionEquals, neighbours, d, h) shouldBe ShortestPath(listOf(start, goal), 1)
-        dijkstra(Graph(setOf(start, goal), d), start, listOf(goal)) shouldBe listOf(
+        dijkstra(Graph(listOf(start, goal), d), start, listOf(goal)) shouldBe listOf(
             ShortestPath(
                 listOf(start, goal),
                 1
@@ -100,7 +100,7 @@ class ShortestPathTest : StringSpec({
                 ShortestPath(listOf(start, a, goal), 10)
 
         val edges: (Node, Node) -> Int? = { m, n -> distances[m to n] }
-        dijkstra(Graph(setOf(start, a, b, goal), edges), start, listOf(goal)) shouldBe
+        dijkstra(Graph(listOf(start, a, b, goal), edges), start, listOf(goal)) shouldBe
                 listOf(ShortestPath(listOf(start, a, goal), 10))
     }
 
@@ -128,7 +128,7 @@ class ShortestPathTest : StringSpec({
                 listOf(ShortestPath(listOf(start, a, goal), 9))
         aStar(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe
                 ShortestPath(listOf(start, a, goal), 9)
-        dijkstra(Graph(setOf(start, a, goal), d), start, listOf(goal)) shouldBe
+        dijkstra(Graph(listOf(start, a, goal), d), start, listOf(goal)) shouldBe
                 listOf(ShortestPath(listOf(start, a, goal), 9))
     }
 
@@ -160,7 +160,7 @@ class ShortestPathTest : StringSpec({
                 listOf(ShortestPath(listOf(start, a, goal), 9))
         aStar(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe
                 ShortestPath(listOf(start, a, goal), 9)
-        dijkstra(Graph(setOf(start, a, goal), d), start, listOf(goal)) shouldBe
+        dijkstra(Graph(listOf(start, a, goal), d), start, listOf(goal)) shouldBe
                 listOf(ShortestPath(listOf(start, a, goal), 9))
     }
 
@@ -193,7 +193,7 @@ class ShortestPathTest : StringSpec({
                 ShortestPath(listOf(start, a, b, goal), 9)
 
         val edges: (Node, Node) -> Int? = { m, n -> distances[m to n] }
-        dijkstra(Graph(setOf(start, a, b, goal), edges), start, listOf(goal)) shouldBe
+        dijkstra(Graph(listOf(start, a, b, goal), edges), start, listOf(goal)) shouldBe
                 listOf(ShortestPath(listOf(start, a, b, goal), 9))
     }
 
@@ -205,7 +205,7 @@ class ShortestPathTest : StringSpec({
         val h: (Node) -> Int = { n -> n.position taxiDistanceTo goal.position }
 
         aStarAllPaths(start, goal::positionEquals, { emptyList() }, d, h) shouldBe emptyList()
-        dijkstra(Graph(setOf(start, goal), { _, _ -> null }), start, listOf(goal)) shouldBe emptyList()
+        dijkstra(Graph(listOf(start, goal), { _, _ -> null }), start, listOf(goal)) shouldBe emptyList()
 
         shouldThrow<IllegalStateException> { aStar(start, goal::positionEquals, { emptyList() }, d, h) }
     }