Solution 2017-11 (Hex Ed)

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/year2017/day11/HexEd.kt

@@ -0,0 +1,95 @@
+package de.ronny_h.aoc.year2017.day11
+
+import de.ronny_h.aoc.AdventOfCode
+import de.ronny_h.aoc.year2017.day11.HexagonalGrid.Direction.*
+import kotlin.math.abs
+import kotlin.math.max
+
+fun main() = HexEd().run(812, 1603)
+
+class HexEd : AdventOfCode<Int>(2017, 11) {
+    override fun part1(input: List<String>): Int {
+        val hexgrid = HexagonalGrid()
+        input.single()
+            .parseDirections()
+            .forEach { hexgrid.goInDirection(it) }
+        return hexgrid.start.distanceTo(hexgrid.currentPosition)
+    }
+
+    override fun part2(input: List<String>): Int {
+        val hexgrid = HexagonalGrid()
+        return input.single()
+            .parseDirections()
+            .maxOf {
+                hexgrid.goInDirection(it)
+                hexgrid.start distanceTo hexgrid.currentPosition
+            }
+    }
+}
+
+fun String.parseDirections(): List<HexagonalGrid.Direction> = split(",").map {
+    when (it) {
+        "n" -> NORTH
+        "ne" -> NORTH_EAST
+        "se" -> SOUTH_EAST
+        "s" -> SOUTH
+        "sw" -> SOUTH_WEST
+        "nw" -> NORTH_WEST
+        else -> error("illegal direction: $it")
+    }
+}
+
+/**
+ * We define coordinates for the hexagonal grid with columns and rows where columns that contain only even rows
+ * alternate with columns containing only odd rows.
+ *
+ * *Example:* From a hextile in the middle with coordinates (0,0), the adjacent hextiles' coordinates are:
+ * ```
+ *    +-+ -2,0 +-+
+ *       \ n  /
+ *  -1,-1 +--+ -1,1
+ *    nw /    \ ne
+ *    +-+ 0,0  +-+
+ *    sw \    / se
+ *   1,-1 +--+ 1,1
+ *       / s  \
+ *    +-+ 2,0  +-+
+ * ```
+ * */
+class HexagonalGrid {
+
+    data class Hextile(val row: Int, val col: Int) {
+
+        init {
+            check(if (abs(col) % 2 == 0) abs(row) % 2 == 0 else true) { "Invalid Hextile($row, $col): In even columns only even row numbers are allowed." }
+            check(if (abs(col) % 2 == 1) abs(row) % 2 == 1 else true) { "Invalid Hextile($row, $col): In odd columns only odd row numbers are allowed." }
+        }
+
+        operator fun plus(direction: Direction) = Hextile(row + direction.row, col + direction.col)
+
+        infix fun distanceTo(other: Hextile): Int {
+            // if hextiles would be in the same col:
+            val verticalDistance = abs((row - other.row) / 2)
+            // if hextiles would be in the "same" row:
+            val horizontalDistance = abs(col - other.col)
+            // in different rows/columns, per column, a distance of 1 in vertical direction can be made up
+            return horizontalDistance + max(verticalDistance - max(horizontalDistance - verticalDistance, 0), 0)
+        }
+    }
+
+    enum class Direction(val row: Int, val col: Int) {
+        NORTH(-2, 0),
+        NORTH_EAST(-1, +1),
+        SOUTH_EAST(+1, +1),
+        SOUTH(+2, 0),
+        SOUTH_WEST(+1, -1),
+        NORTH_WEST(-1, -1),
+    }
+
+    val start = Hextile(0, 0)
+    var currentPosition = start
+
+    fun goInDirection(direction: Direction) {
+        currentPosition += direction
+    }
+}

src/test/kotlin/de/ronny_h/aoc/year2017/day11/HexEdTest.kt

@@ -0,0 +1,92 @@
+package de.ronny_h.aoc.year2017.day11
+
+import de.ronny_h.aoc.year2017.day11.HexagonalGrid.Direction.*
+import de.ronny_h.aoc.year2017.day11.HexagonalGrid.Hextile
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.data.forAll
+import io.kotest.data.row
+import io.kotest.matchers.shouldBe
+
+class HexEdTest : StringSpec({
+
+    "input can be parsed" {
+        forAll(
+            row("n", listOf(NORTH)),
+            row("ne", listOf(NORTH_EAST)),
+            row("se", listOf(SOUTH_EAST)),
+            row("s", listOf(SOUTH)),
+            row("sw", listOf(SOUTH_WEST)),
+            row("nw", listOf(NORTH_WEST)),
+            row("nw,s,sw", listOf(NORTH_WEST, SOUTH, SOUTH_WEST)),
+        ) { input, expected ->
+            input.parseDirections() shouldBe expected
+        }
+    }
+
+    "go in directions leads to target hextile" {
+        forAll(
+            row("ne,ne,ne", Hextile(-3, 3)),
+            row("ne,ne,sw,sw", Hextile(0, 0)),
+            row("ne,ne,s,s", Hextile(2, 2)),
+            row("se,sw,se,sw,sw", Hextile(5, -1)),
+        ) { directions, hextile ->
+            val hexGrid = HexagonalGrid()
+            directions.parseDirections().forEach { hexGrid.goInDirection(it) }
+            hexGrid.currentPosition shouldBe hextile
+        }
+    }
+
+    "only valid hextiles can be created" {
+        forAll(
+            row(1, 0),
+            row(0, 1),
+            row(11, 10),
+        ) { row, col ->
+            shouldThrow<IllegalStateException> {
+                Hextile(row, col)
+            }
+        }
+    }
+
+    "hextile distances" {
+        forAll(
+            row(Hextile(0, 0), Hextile(0, 0), 0),
+            row(Hextile(0, 0), Hextile(2, 0), 1),
+            row(Hextile(0, 0), Hextile(10, 0), 5),
+            row(Hextile(-10, 0), Hextile(0, 0), 5),
+            row(Hextile(0, 0), Hextile(1, 1), 1),
+            row(Hextile(0, 0), Hextile(0, 2), 2),
+            row(Hextile(0, 0), Hextile(1, 3), 3),
+            row(Hextile(0, 0), Hextile(3, 3), 3),
+            row(Hextile(-3, -3), Hextile(0, 0), 3),
+            row(Hextile(-3, -3), Hextile(3, 3), 6),
+        ) { first, second, distance ->
+            first distanceTo second shouldBe distance
+        }
+    }
+
+    "part 1: the fewest number of steps to reach the target hextile" {
+        forAll(
+            row("ne,ne,ne", 3),
+            row("ne,ne,sw,sw", 0),
+            row("ne,ne,s,s", 2),
+            row("se,sw,se,sw,sw", 3),
+        ) { directions, distance ->
+            val input = listOf(directions)
+            HexEd().part1(input) shouldBe distance
+        }
+    }
+
+    "part 2: the furthest steps away on the path" {
+        forAll(
+            row("ne,ne,ne", 3),
+            row("ne,ne,sw,sw", 2),
+            row("ne,ne,s,s", 2),
+            row("se,sw,se,sw,sw", 3),
+        ) { directions, distance ->
+            val input = listOf(directions)
+            HexEd().part2(input) shouldBe distance
+        }
+    }
+})