Day 12

Author: WVerlaek

src/main/kotlin/common/datastructures/Grid.kt

@@ -19,6 +19,11 @@ class Grid<T>(val rows: List<List<Cell<T>>>) {
             Cell<T>(row, col, constructor(row, col))
         }.toList()
     }.toList())
+    constructor(input: List<String>, constr: (row: Int, col: Int, c: Char) -> T) : this(Array(input.size) { row ->
+        Array(input[0].length) { col ->
+            Cell<T>(row, col, constr(row, col, input[row][col]))
+        }.toList()
+    }.toList())
 
     operator fun get(row: Int) = rows[row]
     operator fun get(p: Point) = rows[p.row][p.col]

src/main/kotlin/y24/Day12.kt

@@ -0,0 +1,120 @@
+package y24
+
+import common.puzzle.solvePuzzle
+import common.puzzle.Input
+import common.puzzle.Puzzle
+import common.datastructures.*
+
+
+fun main() = solvePuzzle(year = 2024, day = 12) { Day12(it) }
+
+class Day12(val input: Input) : Puzzle {
+
+    data class Price(
+        val area: Int,
+        val perimeter: Int,
+    ) {
+        val total: Int = area * perimeter
+    }
+
+    private fun pricePerimeter(grid: Grid<Char>, cell: Cell<Char>, visited: MutableSet<Point>): Price {
+        val p = cell.toPoint()
+        if (p in visited) return Price(0, 0)
+
+        visited += p
+
+        var area = 1
+        var perimeter = 0
+        directions.forEach { dir ->
+            val neigh = p + dir.toPoint()
+            when {
+                !grid.withinBounds(neigh.row, neigh.col) -> {
+                    perimeter++
+                }
+                grid[neigh].value != cell.value -> {
+                    perimeter++
+                }
+                else -> {
+                    val (neighArea, neighPerimeter) = pricePerimeter(grid, grid[neigh], visited)
+                    area += neighArea
+                    perimeter += neighPerimeter
+                }
+            }
+        }
+
+        return Price(area, perimeter)
+    }
+
+    private fun perimeter(grid: Grid<Char>, cell: Cell<Char>): List<Dir> {
+        val p = cell.toPoint()
+        return directions.mapNotNull { dir ->
+            val neigh = p + dir.toPoint()
+            when {
+                !grid.withinBounds(neigh.row, neigh.col) -> dir
+                grid[neigh].value != cell.value -> dir
+                else -> null
+            }
+        }
+    }
+
+    private fun priceNumSides(grid: Grid<Char>, cell: Cell<Char>, visited: MutableSet<Point>): Price {
+        val disjointSets = DisjointSets<Pair<Point, Dir>>()
+        val area = priceNumSidesInternal(grid, cell, null, emptyList(), visited, disjointSets)
+        val numSides = disjointSets.sets.size
+        return Price(area, numSides)
+    }
+
+    private fun priceNumSidesInternal(grid: Grid<Char>, cell: Cell<Char>, from: Point?, fromPerimeter: List<Dir>, visited: MutableSet<Point>, disjointSets: DisjointSets<Pair<Point, Dir>>): Int {
+        val p = cell.toPoint()
+        val perimeter = perimeter(grid, cell)
+        perimeter.forEach { disjointSets.find(p to it) }
+
+        from?.let {
+            // Merge perimeter
+            perimeter
+                .filter { it in fromPerimeter }
+                .forEach { dir ->
+                    // dir is shared perimeter between p and from
+                    disjointSets.union(p to dir, from to dir)
+                }
+        }
+
+        if (p in visited) {
+            return 0
+        }
+
+        visited += p
+        return 1 + directions.sumOf { dir ->
+            val neigh = p + dir.toPoint()
+            when {
+                !grid.withinBounds(neigh.row, neigh.col) -> 0
+                grid[neigh].value != cell.value -> 0
+                else -> priceNumSidesInternal(grid, grid[neigh], p, perimeter, visited, disjointSets)
+            }
+        }
+    }
+
+    private val grid = Grid(input.lines) { _, _, c -> c }
+
+    override fun solveLevel1(): Any {
+        val visited = mutableSetOf<Point>()
+        var totalCost = 0
+
+        grid.cells().forEach { cell ->
+            totalCost += pricePerimeter(grid, cell, visited).total
+        }
+
+        return totalCost
+    }
+
+    override fun solveLevel2(): Any {
+        val visited = mutableSetOf<Point>()
+        var totalCost = 0
+
+        grid.cells().forEach { cell ->
+            totalCost += priceNumSides(grid, cell, visited).total
+        }
+
+        return totalCost
+    }
+}

src/test/kotlin/common/ext/NumberTest.kt

@@ -7,11 +7,11 @@ import org.junit.jupiter.api.Assertions.*
 internal class NumberTest {
     @Test
     fun numDigits() {
-        assertEquals(1, 0.numDigits())
-        assertEquals(1, 1.numDigits())
-        assertEquals(1, 9.numDigits())
-        assertEquals(2, 10.numDigits())
-        assertEquals(2, 99.numDigits())
-        assertEquals(3, 100.numDigits())
+        assertEquals(1, 0L.numDigits())
+        assertEquals(1, 1L.numDigits())
+        assertEquals(1, 9L.numDigits())
+        assertEquals(2, 10L.numDigits())
+        assertEquals(2, 99L.numDigits())
+        assertEquals(3, 100L.numDigits())
     }
 }

src/test/kotlin/y24/Day12Test.kt

@@ -0,0 +1,26 @@
+package y24
+
+import common.puzzle.Input
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class Day12Test {
+    private val sample = Input("""
+    AAAA
+    BBCD
+    BBCC
+    EEEC
+    """.trimIndent())
+
+    private val day = Day12(sample)
+
+    @Test
+    fun solveLevel1() {
+        assertEquals(140, day.solveLevel1())
+    }
+
+    @Test
+    fun solveLevel2() {
+         assertEquals(80, day.solveLevel2())
+    }
+}