Merge branch 'main' into patch-1

Author: jsoberg

src/main/kotlin/com/soberg/aoc/utlities/datastructures/Grid2D.kt

@@ -21,7 +21,7 @@ data class Grid2D<T>(
 
     infix operator fun get(location: Location): T = grid[location.row][location.col]
 
-    fun get(row: Int, col: Int): T = grid[row][col]
+    operator fun get(row: Int, col: Int): T = grid[row][col]
 
     /** @return true if the specified [location] is in the bounds of this grid, false if not. */
     fun isInBounds(location: Location): Boolean = isInBounds(location.row, location.col)
@@ -44,6 +44,36 @@ data class Grid2D<T>(
         } else null
     }
 
+    /** @return The collection of elements (as a [List]) that exist from the start [from] (inclusive)
+     * in [direction] for [numElementsToCollect], null if any location would be out of bounds of this grid.
+     *
+     * Note that [numElementsToCollect] is inclusive of the starting location - therefore, a value
+     * of 1 would result in a single item list of just the element at [from]. */
+    fun collect(
+        from: Location,
+        direction: Direction,
+        numElementsToCollect: Int,
+    ) : List<T>? {
+        val finalLocation = from.move(direction, numElementsToCollect - 1)
+        if (!isInBounds(finalLocation)) {
+            return null
+        }
+        return buildList {
+            for (i in 0..<numElementsToCollect) {
+                add(get(from.move(direction, i)))
+            }
+        }
+    }
+
+    /** Walks through each location in this grid. */
+    inline fun traverse(at: (location: Location) -> Unit) {
+        for (row in 0..<rowSize) {
+            for (col in 0..<colSize) {
+                at(Location(row, col))
+            }
+        }
+    }
+
     /** @return A new copy of this [Grid2D] with the specified [element] replaced at [location].
      * @throws [IllegalArgumentException] if [location] not in bounds for this grid. */
     fun replace(location: Location, element: T): Grid2D<T> {
@@ -95,3 +125,8 @@ data class Grid2D<T>(
 }
 
 fun <T> List<List<T>>.toGrid2D() = Grid2D(this)
+
+/** Converts the common AoC input (List of lines (as String) from input file). */
+inline fun <T> List<String>.toGrid2D(convertLine: (String) -> List<T>) = map { line ->
+    convertLine(line)
+}.toGrid2D()

src/test/kotlin/com/soberg/aoc/utlities/datastructures/Grid2DTest.kt

@@ -1,9 +1,11 @@
 package com.soberg.aoc.utlities.datastructures
 
 import assertk.assertThat
+import assertk.assertions.containsExactly
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
 import assertk.assertions.isFalse
+import assertk.assertions.isNotNull
 import assertk.assertions.isNull
 import assertk.assertions.isTrue
 import com.soberg.aoc.utlities.datastructures.Grid2D.Direction
@@ -78,6 +80,58 @@ class Grid2DTest {
             )
     }
 
+    @Test
+    fun `return expected elements for collect`() {
+        val actual = testGrid.collect(Location(2, 1), Direction.East, 3)
+        assertThat(actual)
+            .isNotNull()
+            .containsExactly(222, 333, 444)
+    }
+
+    @Test
+    fun `return null for collect when out of bounds`() {
+        val actual = testGrid.collect(Location(2, 1), Direction.East, 4)
+        assertThat(actual)
+            .isNull()
+    }
+
+    @Test
+    fun `touch all locations in grid for traverse`() {
+        val grid = listOf(
+            listOf(1, 2, 3),
+            listOf(4, 5, 6),
+        ).toGrid2D()
+        val actualTouched = buildList {
+            grid.traverse {
+                add(it.row to it.col)
+            }
+        }
+        assertThat(actualTouched)
+            .containsExactly(
+                0 to 0, 0 to 1, 0 to 2,
+                1 to 0, 1 to 1, 1 to 2,
+            )
+    }
+
+    @Test
+    fun `create expected grid from input`() {
+        val grid = listOf(
+            "ABC",
+            "123",
+        ).toGrid2D { line ->
+            line.toCharArray().asList()
+        }
+        assertThat(grid)
+            .isEqualTo(
+                Grid2D(
+                    listOf(
+                        listOf('A', 'B', 'C'),
+                        listOf('1', '2', '3'),
+                    )
+                )
+            )
+    }
+
     @Test
     fun `throw when attempting replace for out of bounds location`() {
         val exception = assertThrows<IllegalArgumentException> {