Extend GridBackand with width, height and min/max properties

... and use the MapGridBackend in ReservoirResearch.

Author: rhaendel

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

@@ -17,19 +17,24 @@ import java.nio.charset.StandardCharsets
  * @param fallbackElement Used for out of bound positions. Defaults to [nullElement].
  */
 abstract class Grid<T>(
-    val height: Int,
-    val width: Int,
+    height: Int, width: Int,
     val nullElement: T,
     private val fallbackElement: T = nullElement,
+    protected val grid: GridBackend<T> = ListGridBackend(width, height, nullElement),
 ) {
-
-    private val grid: GridBackend<T> = ListGridBackend(width, height, nullElement)
+    val height: Int get() = grid.height
+    val width: Int get() = grid.width
 
     /**
      * A function that maps each `Char` that may occur in the `input: List<String>` to a value of type [T].
      */
     abstract fun Char.toElementType(): T
 
+    /**
+     * Overwrite in sub-classes to perform actions before the [value] is set at [position].
+     */
+    open fun preSet(position: Coordinates, value: T) {}
+
     /**
      * Constructs a Grid with the specified dimensions filled with the [nullElement] as default value and all
      * coordinates in [overrides] set to [overrideElement].
@@ -38,9 +43,9 @@ abstract class Grid<T>(
         height: Int,
         width: Int,
         nullElement: T,
-        overrideElement: T = nullElement,
+        overrideElement: T,
         overrides: List<Coordinates> = emptyList()
-    ) : this(height, width, nullElement, overrideElement) {
+    ) : this(height, width, nullElement, fallbackElement = overrideElement) {
         overrides.forEach { grid[it] = overrideElement }
     }
 
@@ -72,14 +77,28 @@ abstract class Grid<T>(
     operator fun get(x: Int, y: Int): T = grid.getOrNull(x, y) ?: fallbackElement
 
     operator fun set(x: Int, y: Int, value: T) {
+        preSet(Coordinates(x, y), value)
         grid[x, y] = value
     }
 
-    fun getAt(position: Coordinates) = grid.getOrNull(position) ?: fallbackElement
-    fun setAt(position: Coordinates, element: T) {
+    operator fun get(position: Coordinates) = grid.getOrNull(position) ?: fallbackElement
+    operator fun set(position: Coordinates, element: T) {
+        preSet(position, element)
         grid[position] = element
     }
 
+    operator fun set(x: Int, yRange: IntRange, value: T) {
+        for (y in yRange) {
+            this[Coordinates(x, y)] = value
+        }
+    }
+
+    operator fun set(xRange: IntRange, y: Int, value: T) {
+        for (x in xRange) {
+            this[Coordinates(x, y)] = value
+        }
+    }
+
     /**
      * @return a view of the portion of this Grid between the specified [x], [y] (inclusive) and [x] + [width], [y] + [height] (exclusive).
      * The returned list of lists is backed by this Grid, so non-structural changes in the returned list are reflected
@@ -117,10 +136,11 @@ abstract class Grid<T>(
     fun toString(
         overrides: Set<Coordinates> = setOf(),
         overrideChar: Char = '#',
+        padding: Int = 0,
     ): String {
         val out = ByteArrayOutputStream()
         PrintStream(out, true, StandardCharsets.UTF_8).use {
-            printGrid(it, overrides = overrides, overrideChar = overrideChar)
+            printGrid(it, overrides = overrides, overrideChar = overrideChar, padding = padding)
         }
         return out.toString().trim()
     }
@@ -148,8 +168,11 @@ abstract class Grid<T>(
         highlightPosition: Coordinates? = null,
         highlightDirection: Direction? = null,
         path: Map<Coordinates, Char> = mapOf(),
+        padding: Int = 0,
     ) {
+        val paddingString = "$fallbackElement".repeat(padding)
         forEachCoordinates { position, element ->
+            if (position.x == grid.minX) writer.print(paddingString)
             if (highlightPosition == position && highlightDirection != null) {
                 writer.print(highlightDirection.asChar())
             } else if (path.contains(position)) {
@@ -159,7 +182,7 @@ abstract class Grid<T>(
             } else {
                 writer.print(element)
             }
-            if (position.x == width - 1) writer.print('\n')
+            if (position.x == grid.maxX) writer.print("$paddingString\n")
         }.last()
     }
 
@@ -173,7 +196,7 @@ abstract class Grid<T>(
     fun shortestPaths(
         start: Coordinates,
         goal: Coordinates,
-        isVisitable: (Coordinates) -> Boolean = { getAt(it) != nullElement }
+        isVisitable: (Coordinates) -> Boolean = { get(it) != nullElement }
     ): List<ShortestPath<Coordinates>> {
         val neighbours: (Coordinates) -> List<Coordinates> = { position ->
             position.neighbours().filter(isVisitable)
@@ -200,7 +223,7 @@ abstract class Grid<T>(
                 if (element == nullElement) null else position
             }.filterNotNull().toList(),
             edges = { from, to ->
-                if (to in from.neighbours().filter { !isObstacle(getAt(it)) }) 1 else null
+                if (to in from.neighbours().filter { !isObstacle(get(it)) }) 1 else null
             }
         )
         return dijkstraShortestPaths(graph, start, goals, stopAfterMinimalPathsAreFound)
@@ -235,7 +258,7 @@ abstract class Grid<T>(
         regionsCoordinates: MutableList<Coordinates> = mutableListOf(position),
     ): List<Coordinates> {
         position.neighbours().forEach { coordinates ->
-            if (getAt(coordinates) == value && visited.add(coordinates)) {
+            if (get(coordinates) == value && visited.add(coordinates)) {
                 regionsCoordinates.add(coordinates)
                 collectRegionAt(coordinates, value, visited, regionsCoordinates)
             }

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

@@ -25,9 +25,22 @@ interface GridBackend<T> {
     fun subGridAt(x: Int, y: Int, width: Int, height: Int = width): List<List<T>>
 
     fun <R> mapToSequence(transform: (x: Int, y: Int) -> R): Sequence<R>
+
+    val width: Int
+    val height: Int
+    val minX: Int
+    val minY: Int
+    val maxX: Int
+    val maxY: Int
+    val entries: Set<Pair<Coordinates, T>>
 }
 
-class ListGridBackend<T>(width: Int, height: Int, nullElement: T) : GridBackend<T> {
+class ListGridBackend<T>(override val width: Int, override val height: Int, nullElement: T) : GridBackend<T> {
+    override val minX: Int get() = 0
+    override val minY: Int get() = 0
+    override val maxX: Int get() = width - 1
+    override val maxY: Int get() = height - 1
+
     private val grid: MutableList<MutableList<T>> = MutableList(height) { MutableList(width) { nullElement } }
 
     override fun get(x: Int, y: Int) = grid[y][x]
@@ -60,13 +73,24 @@ class ListGridBackend<T>(width: Int, height: Int, nullElement: T) : GridBackend<
             }
         }
     }
+
+    override val entries: Set<Pair<Coordinates, T>>
+        get() = mapToSequence { x, y ->
+            Coordinates(x, y) to get(x, y)
+        }.toSet()
 }
 
 class MapGridBackend<T>(defaultValue: T) : GridBackend<T> {
-    private var minX = Int.MAX_VALUE
-    private var maxX = Int.MIN_VALUE
-    private var minY = Int.MAX_VALUE
-    private var maxY = Int.MIN_VALUE
+    override val height: Int get() = maxY + 1 - minY
+    override val width: Int get() = maxX + 1 - minX
+    override var minX = Int.MAX_VALUE
+        private set
+    override var maxX = Int.MIN_VALUE
+        private set
+    override var minY = Int.MAX_VALUE
+        private set
+    override var maxY = Int.MIN_VALUE
+        private set
 
     private val grid = mutableMapOf<Coordinates, T>().withDefault { defaultValue }
 
@@ -111,4 +135,6 @@ class MapGridBackend<T>(defaultValue: T) : GridBackend<T> {
             }
         }
     }
+
+    override val entries: Set<Pair<Coordinates, T>> get() = grid.entries.map { it.key to it.value }.toSet()
 }

src/main/kotlin/de/ronny_h/aoc/year2015/day18/LikeAGIFForYourYard.kt

@@ -29,18 +29,18 @@ class LikeAGIFForYourYard : AdventOfCode<Int>(2015, 18) {
         private fun GameOfLightGrid.animateStep(): GameOfLightGrid {
             val nextGeneration = GameOfLightGrid(this.height, this.width)
             forEachCoordinates { position, light ->
-                val neighboursOn = position.neighboursIncludingDiagonals().count { getAt(it) == on }
+                val neighboursOn = position.neighboursIncludingDiagonals().count { get(it) == on }
                 val nextState = if (neighboursOn == 3 || light == on && neighboursOn == 2) on else off
-                nextGeneration.setAt(position, nextState)
+                nextGeneration[position] = nextState
             }.last()
             return nextGeneration
         }
 
         private fun GameOfLightGrid.withCornersStuckOn(): GameOfLightGrid {
-            setAt(Coordinates(0, 0), on)
-            setAt(Coordinates(width - 1, 0), on)
-            setAt(Coordinates(0, height - 1), on)
-            setAt(Coordinates(width - 1, height - 1), on)
+            set(Coordinates(0, 0), on)
+            set(Coordinates(width - 1, 0), on)
+            set(Coordinates(0, height - 1), on)
+            set(Coordinates(width - 1, height - 1), on)
             return this
         }
     }

src/main/kotlin/de/ronny_h/aoc/year2017/day19/ASeriesOfTubes.kt

@@ -25,17 +25,17 @@ class RoutingDiagram(input: List<String>) : SimpleCharGrid(input, ' ') {
         var direction = SOUTH
         var steps = 0
 
-        while (getAt(position) != nullElement) {
-            if (getAt(position).isLetter()) {
-                letters.add(getAt(position))
+        while (get(position) != nullElement) {
+            if (get(position).isLetter()) {
+                letters.add(get(position))
             }
 
             position += direction
             steps++
 
-            if (getAt(position) == '+') {
+            if (get(position) == '+') {
                 val turnRight = direction.turnRight()
-                val charAtRight = getAt(position + turnRight)
+                val charAtRight = get(position + turnRight)
                 direction = if (charAtRight == turnRight.char() || charAtRight.isLetter()) {
                     turnRight
                 } else {

src/main/kotlin/de/ronny_h/aoc/year2018/day13/MineCartMadness.kt

@@ -29,22 +29,22 @@ class Track(input: List<String>) : SimpleCharGrid(input, ' ') {
             when (element) {
                 '<' -> {
                     add(Cart(position, WEST))
-                    setAt(position, '-')
+                    set(position, '-')
                 }
 
                 '>' -> {
                     add(Cart(position, EAST))
-                    setAt(position, '-')
+                    set(position, '-')
                 }
 
                 '^' -> {
                     add(Cart(position, NORTH))
-                    setAt(position, '|')
+                    set(position, '|')
                 }
 
                 'v' -> {
                     add(Cart(position, SOUTH))
-                    setAt(position, '|')
+                    set(position, '|')
                 }
             }
         }.last()
@@ -84,7 +84,7 @@ class Track(input: List<String>) : SimpleCharGrid(input, ' ') {
 
     private fun Cart.move() {
         position += direction
-        direction = when (getAt(position)) {
+        direction = when (get(position)) {
             '+' -> direction.turn(nextTurn())
             '/' -> if (direction == NORTH || direction == SOUTH) direction.turnRight() else direction.turnLeft()
             '\\' -> if (direction == NORTH || direction == SOUTH) direction.turnLeft() else direction.turnRight()

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

@@ -107,7 +107,7 @@ class CombatArea(input: List<String>, val elfAttackPower: Int = 3) : SimpleCharG
         }
 
         val targetsInRange = targets.flatMap { target ->
-            target.position.neighbours().filter { getAt(it) == cavern }
+            target.position.neighbours().filter { get(it) == cavern }
         }
         val shortestPaths = shortestPaths(
             start = position,
@@ -153,14 +153,14 @@ class CombatArea(input: List<String>, val elfAttackPower: Int = 3) : SimpleCharG
 
     private fun Player.moveTo(newPosition: Coordinates) {
         logger.debug { " $this moves to $newPosition" }
-        setAt(position, cavern)
-        setAt(newPosition, type.char)
+        set(position, cavern)
+        set(newPosition, type.char)
         position = newPosition
     }
 
     private fun Player.die() {
         logger.debug { " $this died" }
-        setAt(position, cavern)
+        set(position, cavern)
         units.remove(this)
         if (type == Elf) {
             anElfDied = true