Solution 2017-14 (Disk Defragmentation)

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/year2017/day10/KnotHash.kt

@@ -8,18 +8,20 @@ class KnotHash : AdventOfCode<String>(2017, 10) {
     override fun part1(input: List<String>): String {
         val lengths = input.single().split(",").map(String::toInt)
         val size = if (lengths.size < 5) 5 else 256  // just for testing
-        return knotHash(size, lengths).toString()
+        return sparseHashProduct(size, lengths).toString()
     }
 
-    override fun part2(input: List<String>): String {
-        val lengths = input.single().toASCII() + listOf(17, 31, 73, 47, 23)
-        val denseHash = sparseHash(256, lengths, 64).reduceToDenseHash()
-        check(denseHash.size == 16)
-        return denseHash.joinToString("") { it.toString(16).padStart(2, '0') }
-    }
+    override fun part2(input: List<String>): String = input.single().knotHash()
+}
+
+fun String.knotHash(): String {
+    val lengths = toASCII() + listOf(17, 31, 73, 47, 23)
+    val denseHash = sparseHash(256, lengths, 64).reduceToDenseHash()
+    check(denseHash.size == 16)
+    return denseHash.joinToString("") { it.toString(16).padStart(2, '0') }
 }
 
-fun knotHash(size: Int, lengths: List<Int>): Int {
+fun sparseHashProduct(size: Int, lengths: List<Int>): Int {
     val circularList = sparseHash(size, lengths)
     return circularList[0] * circularList[1]
 }

src/main/kotlin/de/ronny_h/aoc/year2017/day14/DiskDefragmentation.kt

@@ -0,0 +1,66 @@
+package de.ronny_h.aoc.year2017.day14
+
+import de.ronny_h.aoc.AdventOfCode
+import de.ronny_h.aoc.extensions.grids.Coordinates
+import de.ronny_h.aoc.extensions.grids.SimpleCharGrid
+import de.ronny_h.aoc.year2017.day10.knotHash
+import java.math.BigInteger
+
+fun main() = DiskDefragmentation().run(8226, 1128)
+
+class DiskDefragmentation : AdventOfCode<Int>(2017, 14) {
+    override fun part1(input: List<String>): Int = input
+        .single()
+        .toBinaryKnotHashes()
+        .sumOf { binary -> binary.count { it == '1' } }
+
+    private fun String.toBinaryKnotHashes(): List<String> = (0..127)
+        .map { "$this-$it" }
+        .map { it.knotHash() }
+        .map(::hexToBinary)
+
+    override fun part2(input: List<String>): Int {
+        val binaryKnotHashes = input
+            .single()
+            .toBinaryKnotHashes()
+
+        return Disk(binaryKnotHashes)
+            .clusterRegions()
+            .size
+    }
+}
+
+class Disk(input: List<String>) : SimpleCharGrid(input, '0') {
+
+    fun clusterRegions(): List<List<Coordinates>> {
+        val assigned = mutableSetOf<Coordinates>()
+        return forEachCoordinates { position, element ->
+            if (element == '1' && position !in assigned) {
+                collectRegionAt(position, assigned)
+            } else {
+                null
+            }
+        }
+            .filterNotNull()
+            .toList()
+    }
+
+    private fun collectRegionAt(
+        position: Coordinates,
+        visited: MutableSet<Coordinates> = mutableSetOf(position),
+        regionsCoordinates: MutableList<Coordinates> = mutableListOf(position),
+    ): List<Coordinates> {
+        position.neighbours().forEach { coordinates ->
+            if (getAt(coordinates) == '1' && visited.add(coordinates)) {
+                regionsCoordinates.add(coordinates)
+                collectRegionAt(coordinates, visited, regionsCoordinates)
+            }
+        }
+        return regionsCoordinates
+    }
+}
+
+fun hexToBinary(hexString: String): String =
+    hexString
+        .map { ch -> BigInteger("$ch", 16).toString(2).padStart(4, '0') }
+        .joinToString("")

src/test/kotlin/de/ronny_h/aoc/year2017/day10/KnotHashTest.kt

@@ -8,7 +8,7 @@ import io.kotest.matchers.shouldBe
 class KnotHashTest : StringSpec({
 
     "the knot hash of a small example" {
-        knotHash(5, listOf(3, 4, 1, 5)) shouldBe 12
+        sparseHashProduct(5, listOf(3, 4, 1, 5)) shouldBe 12
     }
 
     "part 1: the knot hash of a small example" {
@@ -34,4 +34,15 @@ class KnotHashTest : StringSpec({
             KnotHash().part2(input) shouldBe hash
         }
     }
+
+    "the extracted knot hash function" {
+        forAll(
+            row("", "a2582a3a0e66e6e86e3812dcb672a272"),
+            row("AoC 2017", "33efeb34ea91902bb2f59c9920caa6cd"),
+            row("1,2,3", "3efbe78a8d82f29979031a4aa0b16a9d"),
+            row("1,2,4", "63960835bcdc130f0b66d7ff4f6a5a8e"),
+        ) { input, hash ->
+            input.knotHash() shouldBe hash
+        }
+    }
 })

src/test/kotlin/de/ronny_h/aoc/year2017/day14/DiskDefragmentationTest.kt

@@ -0,0 +1,19 @@
+package de.ronny_h.aoc.year2017.day14
+
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+
+class DiskDefragmentationTest : StringSpec({
+
+    "hex to binary String" {
+        hexToBinary("a0c2017") shouldBe "1010000011000010000000010111"
+    }
+
+    "part 1: In the example, 8108 squares are used across the entire 128x128 grid" {
+        DiskDefragmentation().part1(listOf("flqrgnkx")) shouldBe 8108
+    }
+
+    "part 2: The number of regions present in the given key String" {
+        DiskDefragmentation().part2(listOf("flqrgnkx")) shouldBe 1242
+    }
+})