Solution 2018-08 (Memory Maneuver)

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/year2018/day08/MemoryManeuver.kt

@@ -0,0 +1,40 @@
+package de.ronny_h.aoc.year2018.day08
+
+import de.ronny_h.aoc.AdventOfCode
+
+fun main() = MemoryManeuver().run(45618, 22306)
+
+class MemoryManeuver : AdventOfCode<Int>(2018, 8) {
+    override fun part1(input: List<String>): Int = input.parseTreeNodes().metadataSum()
+    override fun part2(input: List<String>): Int = input.parseTreeNodes().value()
+}
+
+data class Node(private val meta: List<Int>, private val children: List<Node>) {
+    fun metadataSum(): Int = meta.sum() + children.sumOf(Node::metadataSum)
+    fun value(): Int = if (children.isEmpty()) {
+        meta.sum()
+    } else {
+        meta.filter { it in 1..children.size }
+            .sumOf { children[it - 1].value() }
+    }
+}
+
+fun List<String>.parseTreeNodes(): Node {
+    val numbers = single().split(" ").map(String::toInt)
+
+    fun parseSubtree(numbers: List<Int>): Pair<Node, Int> {
+        val childCount = numbers[0]
+        val metaCount = numbers[1]
+
+        var offset = 2
+        val children = mutableListOf<Node>()
+        repeat(childCount) {
+            val (child, length) = parseSubtree(numbers.subList(offset, numbers.lastIndex))
+            offset += length
+            children += child
+        }
+        return Node(numbers.subList(offset, offset + metaCount), children) to metaCount + offset
+    }
+
+    return parseSubtree(numbers).first
+}

src/test/kotlin/de/ronny_h/aoc/year2018/day08/MemoryManeuverTest.kt

@@ -0,0 +1,30 @@
+package de.ronny_h.aoc.year2018.day08
+
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+
+class MemoryManeuverTest : StringSpec({
+
+    val input = listOf("2 3 0 3 10 11 12 1 1 0 1 99 2 1 1 2")
+
+    "tree nodes can be parsed" {
+        input.parseTreeNodes() shouldBe Node(
+            listOf(1, 1, 2), listOf(
+                Node(listOf(10, 11, 12), emptyList()),
+                Node(
+                    listOf(2), listOf(
+                        Node(listOf(99), emptyList())
+                    )
+                )
+            )
+        )
+    }
+
+    "part 1: the sum of all metadata entries" {
+        MemoryManeuver().part1(input) shouldBe 138
+    }
+
+    "part 2: the value dependent on having child nodes" {
+        MemoryManeuver().part2(input) shouldBe 66
+    }
+})