Solution 2015-18 (Like a GIF For Your Yard)

Author: rhaendel

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

@@ -1,25 +1,31 @@
 package de.ronny_h.aoc.extensions.grids
 
+import de.ronny_h.aoc.extensions.grids.Direction.*
 import kotlin.math.abs
 
 data class Coordinates(val row: Int, val col: Int) {
 
     companion object {
         val ZERO = Coordinates(0, 0)
     }
+
     operator fun plus(other: Coordinates) = Coordinates(row + other.row, col + other.col)
     operator fun minus(other: Coordinates) = Coordinates(row - other.row, col - other.col)
 
     operator fun times(other: Int) = Coordinates(row * other, col * other)
 
     operator fun plus(direction: Direction) = Coordinates(row + direction.row, col + direction.col)
 
-    fun neighbours() = listOf(this + Direction.EAST, this + Direction.SOUTH, this + Direction.WEST, this + Direction.NORTH)
+    fun neighbours() = listOf(this + EAST, this + SOUTH, this + WEST, this + NORTH)
+
+    fun neighboursIncludingDiagonals() = neighbours() +
+            listOf(this + EAST + NORTH, this + SOUTH + EAST, this + WEST + SOUTH, this + NORTH + WEST)
+
     fun directedNeighbours() = listOf(
-        Direction.EAST to this + Direction.EAST,
-        Direction.SOUTH to this + Direction.SOUTH,
-        Direction.WEST to this + Direction.WEST,
-        Direction.NORTH to this + Direction.NORTH,
+        EAST to this + EAST,
+        SOUTH to this + SOUTH,
+        WEST to this + WEST,
+        NORTH to this + NORTH,
     )
 
     /**

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

@@ -19,16 +19,30 @@ abstract class Grid<T>(
 
     abstract fun Char.toElementType(): T
 
-    constructor(height: Int, width: Int, nullElement: T, overrideElement: T = nullElement, overrides: List<Coordinates> = emptyList()) : this(height, width, nullElement, overrideElement) {
+    constructor(
+        height: Int,
+        width: Int,
+        nullElement: T,
+        overrideElement: T = nullElement,
+        overrides: List<Coordinates> = emptyList()
+    ) : this(height, width, nullElement, overrideElement) {
         overrides.forEach {
             grid[it.row][it.col] = overrideElement
         }
     }
 
-    constructor(input: List<String>, nullElement: T, overrideElement: T = nullElement) : this(input.size, input[0].length, nullElement, overrideElement, emptyList()){
-        input.forEachIndexed { row, line ->
-            line.forEachIndexed { col, char -> grid[row][col] = char.toElementType() }
-        }
+    constructor(input: List<String>, nullElement: T, overrideElement: T = nullElement) : this(
+        input.size,
+        input[0].length,
+        nullElement,
+        overrideElement,
+        emptyList()
+    ) {
+        initGrid(input)
+    }
+
+    fun initGrid(input: List<String>) = input.forEachIndexed { row, line ->
+        line.forEachIndexed { col, char -> grid[row][col] = char.toElementType() }
     }
 
     operator fun get(row: Int, col: Int): T {

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

@@ -0,0 +1,63 @@
+package de.ronny_h.aoc.year2015.day18
+
+import de.ronny_h.aoc.AdventOfCode
+import de.ronny_h.aoc.extensions.grids.Coordinates
+import de.ronny_h.aoc.extensions.grids.Grid
+
+fun main() = LikeAGIFForYourYard().run(768, 0)
+
+class LikeAGIFForYourYard : AdventOfCode<Int>(2015, 18) {
+
+    override fun part1(input: List<String>): Int = GameOfLightGrid(input).animateSteps(100).countLightsOn()
+
+    override fun part2(input: List<String>): Int =
+        GameOfLightGrid(input).animateStepsWithCornersStuckOn(100).countLightsOn()
+
+    companion object {
+        fun GameOfLightGrid.animateSteps(steps: Int): GameOfLightGrid {
+            var grid = this
+            repeat(steps) { grid = grid.animateStep() }
+            return grid
+        }
+
+        fun GameOfLightGrid.animateStepsWithCornersStuckOn(steps: Int): GameOfLightGrid {
+            var grid = this.withCornersStuckOn()
+            repeat(steps) { grid = grid.animateStep().withCornersStuckOn() }
+            return grid
+        }
+
+        private fun GameOfLightGrid.animateStep(): GameOfLightGrid {
+            val nextGeneration = GameOfLightGrid(this.height, this.width)
+            forEachCoordinates { position, light ->
+                val neighboursOn = position.neighboursIncludingDiagonals().count { getAt(it) == on }
+                val nextState = if (neighboursOn == 3 || light == on && neighboursOn == 2) on else off
+                nextGeneration.setAt(position, nextState)
+            }.last()
+            return nextGeneration
+        }
+
+        private fun GameOfLightGrid.withCornersStuckOn(): GameOfLightGrid {
+            setAt(Coordinates(0, 0), on)
+            setAt(Coordinates(0, width - 1), on)
+            setAt(Coordinates(height - 1, 0), on)
+            setAt(Coordinates(height - 1, width - 1), on)
+            return this
+        }
+    }
+}
+
+private const val on = '#'
+private const val off = '.'
+
+class GameOfLightGrid(height: Int, width: Int) : Grid<Char>(height, width, nullElement = off) {
+
+    constructor(input: List<String>) : this(input.size, input[0].length) {
+        initGrid(input)
+    }
+
+    override fun Char.toElementType() = this
+
+    fun countLightsOn(): Int = forEachElement { _, _, light ->
+        if (light == on) 1 else 0
+    }.sum()
+}

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

@@ -64,6 +64,19 @@ class CoordinatesTest : StringSpec({
         )
     }
 
+    "Neighbours including diagonals" {
+        Coordinates(5, 5).neighboursIncludingDiagonals() shouldContainAll listOf(
+            Coordinates(4, 5),
+            Coordinates(6, 5),
+            Coordinates(5, 4),
+            Coordinates(5, 6),
+            Coordinates(4, 6),
+            Coordinates(6, 6),
+            Coordinates(6, 4),
+            Coordinates(4, 4),
+        )
+    }
+
     "Directed neighbours" {
         Coordinates(5, 5).directedNeighbours() shouldContainAll listOf(
             Direction.NORTH to Coordinates(4, 5),

src/test/kotlin/de/ronny_h/aoc/year2015/day18/LikeAGIFForYourYardTest.kt

@@ -0,0 +1,30 @@
+package de.ronny_h.aoc.year2015.day18
+
+import de.ronny_h.aoc.year2015.day18.LikeAGIFForYourYard.Companion.animateSteps
+import de.ronny_h.aoc.year2015.day18.LikeAGIFForYourYard.Companion.animateStepsWithCornersStuckOn
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+
+class LikeAGIFForYourYardTest : StringSpec({
+
+    val input = listOf(
+        ".#.#.#",
+        "...##.",
+        "#....#",
+        "..#...",
+        "#.#..#",
+        "####..",
+    )
+
+    "part 1: the number of lights on after one and four iterations" {
+        val grid = GameOfLightGrid(input)
+        grid.animateSteps(1).countLightsOn() shouldBe 11
+        grid.animateSteps(4).countLightsOn() shouldBe 4
+    }
+
+    "part 2: the number of lights on after one and five iterations with corners stuck on" {
+        val grid = GameOfLightGrid(input)
+        grid.animateStepsWithCornersStuckOn(1).countLightsOn() shouldBe 18
+        grid.animateStepsWithCornersStuckOn(5).countLightsOn() shouldBe 17
+    }
+})