Refactor Grid: Use x and y instead of col and row

... and bring them in their canonical order

Author: rhaendel

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

@@ -62,65 +62,65 @@ abstract class Grid<T>(
         initGrid(input)
     }
 
-    protected fun initGrid(input: List<String>) = input.forEachIndexed { row, line ->
-        line.forEachIndexed { col, char ->
-            grid[row][col] = char.toElementType()
+    protected fun initGrid(input: List<String>) = input.forEachIndexed { y, line ->
+        line.forEachIndexed { x, char ->
+            grid[y][x] = char.toElementType()
         }
     }
 
     /**
      * @return The value at the specified cell.
      */
-    operator fun get(row: Int, col: Int): T {
+    operator fun get(x: Int, y: Int): T {
         return grid
-            .getOrNull(row)
-            ?.getOrNull(col)
+            .getOrNull(y)
+            ?.getOrNull(x)
             ?: fallbackElement
     }
 
-    operator fun set(row: Int, col: Int, value: T) {
-        grid[row][col] = value
+    operator fun set(x: Int, y: Int, value: T) {
+        grid[y][x] = value
     }
 
-    fun getAt(position: Coordinates) = get(position.y, position.x)
+    fun getAt(position: Coordinates) = get(position.x, position.y)
     fun setAt(position: Coordinates, element: T) {
-        this[position.y, position.x] = element
+        this.set(position.x, position.y, element)
     }
 
     /**
-     * @return a view of the portion of this Grid between the specified [row], [col] (inclusive) and [row] + [height], [col] + [width] (exclusive).
+     * @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
      * in this Grid, and vice-versa.
      * Structural changes in the base Grid make the behavior of the view undefined.
      */
-    fun subGridAt(row: Int, col: Int, height: Int, width: Int = height): List<List<T>> {
+    fun subGridAt(x: Int, y: Int, width: Int, height: Int = width): List<List<T>> {
         return buildList {
-            for (r in row..<row + height) {
-                add(grid[r].subList(col, col + width))
+            for (r in y..<y + height) {
+                add(grid[r].subList(x, x + width))
             }
         }
     }
 
-    fun <R> forEachIndex(action: (row: Int, col: Int) -> R): Sequence<R> = sequence {
-        for (row in grid.indices) {
-            for (col in grid[0].indices) {
-                yield(action(row, col))
+    fun <R> forEachIndex(action: (x: Int, y: Int) -> R): Sequence<R> = sequence {
+        for (y in grid.indices) {
+            for (x in grid[0].indices) {
+                yield(action(x, y))
             }
         }
     }
 
-    fun <R> forEachElement(action: (row: Int, col: Int, element: T) -> R): Sequence<R> = sequence {
-        for (row in grid.indices) {
-            for (col in grid[0].indices) {
-                yield(action(row, col, get(row, col)))
+    fun <R> forEachElement(action: (x: Int, y: Int, element: T) -> R): Sequence<R> = sequence {
+        for (y in grid.indices) {
+            for (x in grid[0].indices) {
+                yield(action(x, y, get(x, y)))
             }
         }
     }
 
     fun <R> forEachCoordinates(action: (position: Coordinates, element: T) -> R): Sequence<R> = sequence {
-        for (row in grid.indices) {
-            for (col in grid[0].indices) {
-                yield(action(Coordinates(col, row), get(row, col)))
+        for (y in grid.indices) {
+            for (x in grid[0].indices) {
+                yield(action(Coordinates(x, y), get(x, y)))
             }
         }
     }
@@ -130,8 +130,8 @@ abstract class Grid<T>(
      *
      * @throws NoSuchElementException If no matching element can be found.
      */
-    fun find(value: T): Coordinates = forEachElement { row, col, element ->
-        if (element == value) Coordinates(col, row) else null
+    fun find(value: T): Coordinates = forEachElement { x, y, element ->
+        if (element == value) Coordinates(x, y) else null
     }.filterNotNull().first()
 
     override fun toString(): String = toString(setOf())

src/main/kotlin/de/ronny_h/aoc/year2017/day21/FractalArt.kt

@@ -113,17 +113,17 @@ class FractalArtGrid(size: Int) : Grid<Char>(size, size, off) {
     }
 
     private fun applyRuleAt(rule: Rule, start: Coordinates) {
-        rule.replacement.forEachIndexed { row, rowString ->
-            rowString.forEachIndexed { col, value ->
-                this[start.y + row, start.x + col] = value
+        rule.replacement.forEachIndexed { y, rowString ->
+            rowString.forEachIndexed { x, value ->
+                this[start.x + x, start.y + y] = value
             }
         }
     }
 
     private fun forEachSquareOfSize(size: Int, block: (Coordinates, List<List<Char>>) -> Unit) {
-        for (row in 0..<height step size) {
-            for (col in 0..<height step size) {
-                block(Coordinates(col, row), subGridAt(row, col, size))
+        for (y in 0..<height step size) {
+            for (x in 0..<height step size) {
+                block(Coordinates(x, y), subGridAt(x, y, width = size))
             }
         }
     }

src/main/kotlin/de/ronny_h/aoc/year2018/day11/ChronalCharge.kt

@@ -19,12 +19,12 @@ class PowerCellGrid(serialNumber: Int) : Grid<Int>(300, 300, -1000) {
     private val cache = mutableMapOf<Configuration, Int>()
 
     init {
-        forEachIndex { y, x ->
+        forEachIndex { x, y ->
             val rackId = x + 10
             val powerLevel = rackId * y + serialNumber
             val hundredsDigit = (powerLevel * rackId).digit(3)
-            this[y, x] = hundredsDigit - 5
-            cache[Configuration(Coordinates(x, y), 1)] = this[y, x]
+            this[x, y] = hundredsDigit - 5
+            cache[Configuration(Coordinates(x, y), 1)] = this[x, y]
         }.last()
     }
 
@@ -55,9 +55,9 @@ class PowerCellGrid(serialNumber: Int) : Grid<Int>(300, 300, -1000) {
             } else {
                 val total = cache[Configuration(coordinates, squareSize - 1)]?.let { cached ->
                     val additionalColumnTotal =
-                        (0..<squareSize).sumOf { this[coordinates.y + it, coordinates.x + squareSize - 1] }
+                        (0..<squareSize).sumOf { this[coordinates.x + squareSize - 1, coordinates.y + it] }
                     val additionalRowTotal =
-                        (0..<squareSize - 1).sumOf { this[coordinates.y + squareSize - 1, coordinates.x + it] }
+                        (0..<squareSize - 1).sumOf { this[coordinates.x + it, coordinates.y + squareSize - 1] }
                     cached + additionalColumnTotal + additionalRowTotal
                 } ?: sumOfSquare(coordinates, squareSize)
                 cache[config] = total
@@ -77,7 +77,7 @@ class PowerCellGrid(serialNumber: Int) : Grid<Int>(300, 300, -1000) {
 
     private fun sumOfSquare(coordinates: Coordinates, squareSize: Int): Int = (0..<squareSize).sumOf { r ->
         (0..<squareSize).sumOf { c ->
-            this[coordinates.y + r, coordinates.x + c]
+            this[coordinates.x + c, coordinates.y + r]
         }
     }
 

src/main/kotlin/de/ronny_h/aoc/year2024/day04/CeresSearch.kt

@@ -24,23 +24,23 @@ class XMasGrid(input: List<String>) : Grid<Char>(input, ' ') {
 
     fun searchForMASCross() = forEachIndex(::searchForMASCrossAt).sum()
 
-    private fun searchForXMASAt(row: Int, col: Int): Int {
+    private fun searchForXMASAt(x: Int, y: Int): Int {
         var sum = 0
-        sum += searchForXMAS(row, col, { a, _ -> a }, { a, b -> a + b }) // →
-        sum += searchForXMAS(row, col, { a, _ -> a }, { a, b -> a - b }) // ←
-        sum += searchForXMAS(row, col, { a, b -> a + b }, { a, _ -> a }) // ↓
-        sum += searchForXMAS(row, col, { a, b -> a - b }, { a, _ -> a }) // ↑
-        sum += searchForXMAS(row, col, { a, b -> a + b }, { a, b -> a + b }) // ↘
-        sum += searchForXMAS(row, col, { a, b -> a + b }, { a, b -> a - b }) // ↙
-        sum += searchForXMAS(row, col, { a, b -> a - b }, { a, b -> a - b }) // ↖
-        sum += searchForXMAS(row, col, { a, b -> a - b }, { a, b -> a + b }) // ↗
+        sum += searchForXMAS(x, y, { a, b -> a + b }) { a, _ -> a } // →
+        sum += searchForXMAS(x, y, { a, b -> a - b }) { a, _ -> a } // ←
+        sum += searchForXMAS(x, y, { a, _ -> a }) { a, b -> a + b } // ↓
+        sum += searchForXMAS(x, y, { a, _ -> a }) { a, b -> a - b } // ↑
+        sum += searchForXMAS(x, y, { a, b -> a + b }) { a, b -> a + b } // ↘
+        sum += searchForXMAS(x, y, { a, b -> a - b }) { a, b -> a + b } // ↙
+        sum += searchForXMAS(x, y, { a, b -> a - b }) { a, b -> a - b } // ↖
+        sum += searchForXMAS(x, y, { a, b -> a + b }) { a, b -> a - b } // ↗
         return sum
     }
 
-    private fun searchForXMAS(row: Int, col: Int, rowOp: (Int, Int) -> Int, colOp: (Int, Int) -> Int): Int {
+    private fun searchForXMAS(x: Int, y: Int, xOp: (Int, Int) -> Int, yOp: (Int, Int) -> Int): Int {
         var matchIndex = 0
         for (index in word.indices) {
-            if (get(rowOp(row, index), colOp(col, index)) == word[matchIndex]) {
+            if (get(xOp(x, index), yOp(y, index)) == word[matchIndex]) {
                 if (matchIndex == word.lastIndex) {
                     return 1
                 }
@@ -52,24 +52,24 @@ class XMasGrid(input: List<String>) : Grid<Char>(input, ' ') {
         return 0
     }
 
-    private fun searchForMASCrossAt(row: Int, col: Int): Int {
-        if (get(row, col) != 'A') {
+    private fun searchForMASCrossAt(x: Int, y: Int): Int {
+        if (get(x, y) != 'A') {
             return 0
         }
-        if ((mainDiagIsMAS(row, col) || mainDiagIsSAM(row, col)) &&
-            (secDiagIsMAS(row, col) || secDiagIsSAM(row, col))
+        if ((mainDiagIsMAS(x, y) || mainDiagIsSAM(x, y)) &&
+            (secDiagIsMAS(x, y) || secDiagIsSAM(x, y))
         ) {
             return 1
         }
         return 0
     }
 
-    private fun mainDiagIsMAS(row: Int, col: Int) = get(row - 1, col - 1) == 'M' && get(row + 1, col + 1) == 'S'
+    private fun mainDiagIsMAS(x: Int, y: Int) = get(x - 1, y - 1) == 'M' && get(x + 1, y + 1) == 'S'
 
-    private fun mainDiagIsSAM(row: Int, col: Int) = get(row - 1, col - 1) == 'S' && get(row + 1, col + 1) == 'M'
+    private fun mainDiagIsSAM(x: Int, y: Int) = get(x - 1, y - 1) == 'S' && get(x + 1, y + 1) == 'M'
 
-    private fun secDiagIsMAS(row: Int, col: Int) = get(row - 1, col + 1) == 'M' && get(row + 1, col - 1) == 'S'
+    private fun secDiagIsMAS(x: Int, y: Int) = get(x + 1, y - 1) == 'M' && get(x - 1, y + 1) == 'S'
 
-    private fun secDiagIsSAM(row: Int, col: Int) = get(row - 1, col + 1) == 'S' && get(row + 1, col - 1) == 'M'
+    private fun secDiagIsSAM(x: Int, y: Int) = get(x + 1, y - 1) == 'S' && get(x - 1, y + 1) == 'M'
 
 }

src/main/kotlin/de/ronny_h/aoc/year2024/day06/GuardGallivant.kt

@@ -60,8 +60,8 @@ private class Lab(input: List<String>) : Grid<Char>(input, ' ') {
 
     @OptIn(ExperimentalCoroutinesApi::class)
     fun freePositions(scope: CoroutineScope, bufferSize: Int) = scope.produce(capacity = bufferSize) {
-        forEachElement { row, col, char ->
-            if (char == free) Coordinates(col, row) else null
+        forEachElement { x, y, char ->
+            if (char == free) Coordinates(x, y) else null
         }
             .filterNotNull()
             .forEach {

src/main/kotlin/de/ronny_h/aoc/year2024/day08/ResonantCollinearity.kt

@@ -27,9 +27,9 @@ private class CityMap(input: List<String>) : Grid<Char>(input, '.') {
     private val rowIndices = input.indices
 
     private val antennas: Map<Char, List<Coordinates>> = buildMap<Char, MutableList<Coordinates>> {
-        forEachElement { row, col, char ->
+        forEachElement { x, y, char ->
             if (char != nullElement) {
-                getOrPut(char, ::mutableListOf).add(Coordinates(col, row))
+                getOrPut(char, ::mutableListOf).add(Coordinates(x, y))
             }
         }.last()
     }

src/main/kotlin/de/ronny_h/aoc/year2024/day10/HoofIt.kt

@@ -21,8 +21,8 @@ private class TopographicMap(input: List<String>) : Grid<Int>(input, Int.MIN_VAL
 
     override fun Char.toElementType() = if (isDigit()) digitToInt() else nullElement
 
-    private fun heights(): Sequence<Pair<Coordinates, Int>> = forEachElement { row, col, height ->
-        Coordinates(col, row) to height
+    private fun heights(): Sequence<Pair<Coordinates, Int>> = forEachElement { x, y, height ->
+        Coordinates(x, y) to height
     }
 
     private fun heightAt(coordinates: Coordinates) = getAt(coordinates)

src/main/kotlin/de/ronny_h/aoc/year2024/day15/WarehouseWoes.kt

@@ -66,9 +66,9 @@ abstract class Warehouse(input: List<String>) : Grid<Char>(input, '#') {
     }
 
     // GPS = Goods Positioning System
-    fun sumGPSCoordinates(): Int = forEachElement { row, col, element ->
+    fun sumGPSCoordinates(): Int = forEachElement { x, y, element ->
         if (element == leftGoodsChar) {
-            100 * row + col
+            100 * y + x
         } else {
             0
         }

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

@@ -38,8 +38,8 @@ class GridTest : StringSpec() {
         "charAt returns the input values from the right indices" {
             val grid = SimpleCharGrid(listOf("12", "34"))
             grid[0, 0] shouldBe '1'
-            grid[0, 1] shouldBe '2'
-            grid[1, 0] shouldBe '3'
+            grid[1, 0] shouldBe '2'
+            grid[0, 1] shouldBe '3'
             grid[1, 1] shouldBe '4'
         }
 
@@ -48,52 +48,52 @@ class GridTest : StringSpec() {
                 override fun Char.toElementType() = digitToInt()
             }
             grid[0, 0] shouldBe 1
-            grid[0, 1] shouldBe 2
-            grid[1, 0] shouldBe 3
+            grid[1, 0] shouldBe 2
+            grid[0, 1] shouldBe 3
             grid[1, 1] shouldBe 4
         }
 
         "charAt with indices returns the same as charAt with Coordinates" {
             val grid = SimpleCharGrid(listOf("12", "34"))
             grid[0, 0] shouldBe grid.getAt(Coordinates(0, 0))
-            grid[0, 1] shouldBe grid.getAt(Coordinates(1, 0))
-            grid[1, 0] shouldBe grid.getAt(Coordinates(0, 1))
+            grid[0, 1] shouldBe grid.getAt(Coordinates(0, 1))
+            grid[1, 0] shouldBe grid.getAt(Coordinates(1, 0))
             grid[1, 1] shouldBe grid.getAt(Coordinates(1, 1))
         }
 
         "charAt with index out of the input values returns the nullElement of a Char Grid" {
             val grid = SimpleCharGrid(listOf("12", "34"), ' ')
-            grid[-1, 0] shouldBe ' '
-            grid[0, 2] shouldBe ' '
-            grid[1, -1] shouldBe ' '
+            grid[0, -1] shouldBe ' '
+            grid[2, 0] shouldBe ' '
+            grid[-1, 1] shouldBe ' '
             grid[2, 2] shouldBe ' '
         }
 
         "charAt with index out of the input values returns the nullElement of an Int Grid" {
             val grid = object : Grid<Int>(listOf("12", "34"), Int.MIN_VALUE) {
                 override fun Char.toElementType() = digitToInt()
             }
-            grid[-1, 0] shouldBe Int.MIN_VALUE
-            grid[0, 2] shouldBe Int.MIN_VALUE
-            grid[1, -1] shouldBe Int.MIN_VALUE
+            grid[0, -1] shouldBe Int.MIN_VALUE
+            grid[2, 0] shouldBe Int.MIN_VALUE
+            grid[-1, 1] shouldBe Int.MIN_VALUE
             grid[2, 2] shouldBe Int.MIN_VALUE
         }
 
         "setAt sets the element at the given coordinates" {
             val grid = SimpleCharGrid(listOf("12", "34"))
             grid.setAt(Coordinates(0, 1), '5')
             grid[0, 0] shouldBe '1'
-            grid[0, 1] shouldBe '2'
-            grid[1, 0] shouldBe '5'
+            grid[1, 0] shouldBe '2'
+            grid[0, 1] shouldBe '5'
             grid[1, 1] shouldBe '4'
         }
 
         "set with array access sets the element at the given coordinates" {
             val grid = SimpleCharGrid(listOf("12", "34"))
-            grid[1, 0] = '5'
+            grid[0, 1] = '5'
             grid[0, 0] shouldBe '1'
-            grid[0, 1] shouldBe '2'
-            grid[1, 0] shouldBe '5'
+            grid[1, 0] shouldBe '2'
+            grid[0, 1] shouldBe '5'
             grid[1, 1] shouldBe '4'
         }
 
@@ -104,24 +104,24 @@ class GridTest : StringSpec() {
                 90AB
                 CDEF
             """.asList()
-            SimpleCharGrid(input).subGridAt(1, 1, 2) shouldBe listOf(
+            SimpleCharGrid(input).subGridAt(1, 1, width = 2) shouldBe listOf(
                 listOf('6', '7'),
                 listOf('0', 'A'),
             )
         }
 
         "forEachIndex calls the provided function on each element in the expected order" {
             val grid = SimpleCharGrid(listOf("12", "34"))
-            val chars = grid.forEachIndex { row, column ->
-                grid[row, column]
+            val chars = grid.forEachIndex { x, y ->
+                grid[x, y]
             }.toList()
             chars shouldBe listOf('1', '2', '3', '4')
         }
 
         "forEachElement calls the provided function on each element in the expected order" {
             val grid = SimpleCharGrid(listOf("12", "34"))
-            val strings = grid.forEachElement { row, column, char ->
-                "$row,$column:$char"
+            val strings = grid.forEachElement { x, y, char ->
+                "$y,$x:$char"
             }.toList()
             strings shouldBe
                     listOf(

src/test/kotlin/de/ronny_h/aoc/year2018/day11/ChronalChargeTest.kt

@@ -14,7 +14,7 @@ class ChronalChargeTest : StringSpec({
             row(217, 196, 39, 0),
             row(101, 153, 71, 4),
         ) { x, y, serialNumber, powerLevel ->
-            PowerCellGrid(serialNumber)[y, x] shouldBe powerLevel
+            PowerCellGrid(serialNumber)[x, y] shouldBe powerLevel
         }
     }