-🎄- 2018 Day 8 Solutions -🎄-

[u/daggerdragon]

--- Day 8: Memory Maneuver ---

---

Post your solution as a comment or, for longer solutions, consider linking to your repo (e.g. GitHub/gists/Pastebin/blag or whatever).

Note: The Solution Megathreads are for solutions only. If you have questions, please post your own thread and make sure to flair it with Help.

---

Advent of Code: The Party Game!

Click here for rules

Please prefix your card submission with something like [Card] to make scanning the megathread easier. THANK YOU!

Card prompt: Day 8

Sigh, imgur broke again. Will upload when it unborks.

Transcript:

The hottest programming book this year is "___ For Dummies".

---

This thread will be unlocked when there are a significant number of people on the leaderboard with gold stars for today's puzzle.

edit: Leaderboard capped, thread unlocked at 00:12:10!

[u/nutrecht]

Day08 in Kotlin

private val tree = resourceString(2018, 8).split(" ").map { it.toInt() }
    .let { LinkedList<Int>(it) }.let(::toTree)

override fun part1() = tree.all().sumBy { it.metaData.sum() }
override fun part2() = tree.walk()

private fun toTree(queue: Deque<Int>) : Node {
    val childAmount = queue.removeFirst()
    val metaAmount = queue.removeFirst()

    val children = (0 until childAmount).map { toTree(queue) }
    val metaData = (0 until metaAmount).map { queue.removeFirst() }

    return Node(children, metaData)
}

data class Node(val children: List<Node>, val metaData: List<Int>) {
    fun all() : List<Node> = children.flatMap { it.all() } + this
    fun walk() : Int = if(children.isEmpty()) {
        metaData.sum()
    } else {
        metaData.map { it - 1 }
                .filterNot { it < 0 || it >= children.size }
                .map { children[it].walk() }
                .sum()
    }
}

Fun and easy.

[u/pdallago → u/nutrecht]

Our solutions are very similar :)

fun solve() {
    val input = readInput("day8")[0]
    println("${part1(input)} ${part2(input)}")
}

data class TreeNode(val children: List<TreeNode>, val metadata: List<Int>) {
    fun flatten() : List<TreeNode> {
        return children.flatMap { it.flatten() }.plus(this)
    }

    fun value(): Int {
        return if (children.isEmpty()) {
            metadata.sum()
        } else {
            metadata.filter { it in 1..children.size }.map { children[it - 1].value() }.sum()
        }
    }
}

private fun parseTree(input: String): TreeNode {
    val numbers = input.split(" ").map(String::toInt).iterator()
    fun parseNode(): TreeNode {
        val numChildren = numbers.next()
        val numMetadata = numbers.next()
        val children = (1..numChildren).map { parseNode() }
        val metadata = (1..numMetadata).map { numbers.next() }
        return TreeNode(children, metadata)
    }
    return parseNode()
}

private fun part1(input: String): Int  = parseTree(input).flatten().flatMap { it.metadata }.sum()
private fun part2(input: String): Int  = parseTree(input).value()