# Advent of Code 2018 - Day 8, in Kotlin

Kotlin solutions to parts 1 and 2 of Advent of Code 2018, Day 8: 'Memory Maneuver'

Posted on

Day 8 brings us a tree, and a recursive function to create it.

If you’d rather just view code, the GitHub Repository is here.

Problem Input

Our input is a single `String` of space-separated integers. Since the input is turned into a tree structure, and we need to read the problem first, there’s nothing to be done here. We’ll consume the input in Part 1 below.

#### Day 8, Part 1

The sleigh is much easier to pull than you’d expect for something its weight. Unfortunately, neither you nor the Elves know which way the North Pole is from here.

The navigation system’s license file consists of a list of numbers (your puzzle input). The numbers define a data structure which, when processed, produces some kind of tree that can be used to calculate the license number.

The tree is made up of nodes; a single, outermost node forms the tree’s root, and it contains all other nodes in the tree (or contains nodes that contain nodes, and so on).

Specifically, a node consists of:

• A header, which is always exactly two numbers:
• The quantity of child nodes.
• The quantity of metadata entries.
• Zero or more child nodes (as specified in the header).

Each child node is itself a node that has its own header, child nodes, and metadata. For example:

``````2 3 0 3 10 11 12 1 1 0 1 99 2 1 1 2
A----------------------------------
B----------- C-----------
D-----``````

In this example, each node of the tree is also marked with an underline starting with a letter for easier identification. In it, there are four nodes:

• A, which has 2 child nodes (B, C) and 3 metadata entries (1, 1, 2).
• B, which has 0 child nodes and 3 metadata entries (10, 11, 12).
• C, which has 1 child node (D) and 1 metadata entry (2).
• D, which has 0 child nodes and 1 metadata entry (99).

The first check done on the license file is to simply add up all of the metadata entries. In this example, that sum is `1+1+2+10+11+12+2+99=138`.

What is the sum of all metadata entries?

It seems that most of the work in this is going to be turning the input into a structure we can use. For this, let’s define a class to represent a `Node`. Nodes have child nodes (also of type `Node`), and some metadata. We’ll make this a regular `class`, because we don’t need any of the extra things that come along with a `data class`.

``class Node(children: List<Node>, metadata: List<Int>)``

We are not making the arguments `children` and `metadata` vals because we don’t actually need them for anything yet. You’ll see in a minute how we’ll consume that data, and return useful results. But first, we need to parse our input into a `Node` and its children. Thankfully, the problem states there is only one top level node, meaning this is definitely a Tree and not a more complicated version of a directed graph.

The way we’re going to parse this is to write a recursive function. Recursive functions are functions that call themselves. Recursive functions work well with tree structures because it’s easy to picture how to break the problem into smaller and smaller steps. First, let’s outline how it will work, and then code it up:

1. To start, receive an `Iterator<Int>`. This lets us consume `Ints` off the `Iterator`, and pass the remaining unconsumed down the call stack.
2. Get the number of children from the iterator.
3. Get the amount of metadata from the iterator.
4. For each child we are supposed to have, call ourselves with what’s left in the iterator (Go back to step 1) to generate children.
5. When that returns, consume the number of metadata entries from the Iterator
6. Package that all up into a `Node` and return.

This should give us the tree structure we’re looking for. We’ll implement this on the companion object of `Node`:

``````private class Node(children: List<Node>, metadata: List<Int>) {

companion object {

fun of(values: Iterator<Int>): Node {
val numChildren: Int = values.next()
val children = (0 until numChildren).map { Node.of(values) }
}

}

}``````

One thing to watch out for with recursive functions is that at some point you’ll run out of stack space and the call will fail. Thankfully, our call depth here isn’t so bad that we have to worry about it. Otherwise, we would have to find a different way to solve the problem.

Now that we have a node, we can implement a function on it to calculate the metadata’s total. But hold on. Do we really need a function for that? Not really, because the answer itself never changes. And in this case (because it’s a puzzle) I know we’ll always need to know the answer. So let’s just define a new `val` on `Node` to calculate this for us:

``````val metadataTotal: Int =

What that says is “sum the metadata of the current node, and add that to the sum of the metadata of all the child nodes we have (if any)”.

Now to create our root node and inspect this value:

``````class Day08(rawInput: String) {
private val tree: Node = Node.of(rawInput.split(" ").map { it.toInt() }.iterator())

fun solvePart1(): Int =
}``````

To turn our `String` input into an `Iterator`, we split it apart every time we have a space. This gives us a `List<String>`, and then we map each `String` into an `Int`, and then get the `Iterator` off of the `List<Int>`.

Star earned! Onward!

#### Day 8, Part 2

The second check is slightly more complicated: you need to find the value of the root node (A in the example above).

The value of a node depends on whether it has child nodes.

If a node has no child nodes, its value is the sum of its metadata entries. So, the value of node B is 10+11+12=33, and the value of node D is 99.

However, if a node does have child nodes, the metadata entries become indexes which refer to those child nodes. A metadata entry of 1 refers to the first child node, 2 to the second, 3 to the third, and so on. The value of this node is the sum of the values of the child nodes referenced by the metadata entries. If a referenced child node does not exist, that reference is skipped. A child node can be referenced multiple time and counts each time it is referenced. A metadata entry of 0 does not refer to any child node.

For example, again using the above nodes:

• Node C has one metadata entry, 2. Because node C has only one child node, 2 references a child node which does not exist, and so the value of node C is 0.
• Node A has three metadata entries: 1, 1, and 2. The 1 references node A’s first child node, B, and the 2 references node A’s second child node, C. Because node B has a value of 33 and node C has a value of 0, the value of node A is 33+33+0=66.

So, in this example, the value of the root node is 66.

What is the value of the root node?

Thankfully, we have almost everything we need already. The only real work we have is to add another `val` to `Node` to calculate its value.

``````val value: Int =
else metadata.sumBy { children.getOrNull(it - 1)?.value ?: 0 }``````

In the case where the `Node` doesn’t have any children, we just sum the metadata. In the case where it does have children, sum their values. The trick here is with indexing into our `children` list. If you read the problem statement, it is one-indexed (starts at 1!), not zero-indexed like we’re used to. And because we can ask for any child number, even if it doesn’t exist, we’ll need to account for that as well. For this we use `getOrNull` (Thanks Karel!), which accounts for this. If we get a null, we just assume the value is zero. Summing all this gives us our answer!

``````fun solvePart2(): Int =
tree.value``````

Star 2 earned! I think this was a nice gentle introduction to recursive functions.