8.md

Day 8: Memory Manuever - Part 1

It seems to have some kind of navigation system! Activating the navigation system produces more bad news: "Failed to start navigation system. Could not read software license file."

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).
• One or more metadata entries (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?

Solution

You have to make an N-ary tree from an array of numbers. In your recursion function, you need to return not only your child node, but also what index did it stop at, so you can get the next child after it.

const toTree = ({list}: {list: number[]}) => {
    const helper = (startIndex: number): {node: INode<number>; nextIndex: number} => {
        const node: INode<number> = {
            children: [],
            metadata: 0
        };
        const numOfChildren = list[startIndex] ?? 0;
        const numOfMeta = list[startIndex + 1] ?? 0;
        let childIndex = startIndex + 2;

        for (let i = 0; i < numOfChildren && childIndex < list.length; i++) {
            const childResult = helper(childIndex);
            childIndex = childResult.nextIndex;
            node.children.push(childResult.node);
        }

        for (let i = 0; i < numOfMeta && childIndex < list.length; i++) {
            node.metadata += list[childIndex++];
        }
        return {
            node,
            nextIndex: childIndex
        };
    };
    return helper(0);
};

Tree toString()

Here's one way of printing a tree:

toString() {
    const x = this.toStringAtNode(this.root);
    return x.join('\n');
}

/*
    work backwards. First know that the below
    1
    ├──2
    |  ├──4
    |  └──5
    └──3
    is made from this array: [ '1', '├──2', '|  ├──4', '|  └──5', '└──3' ]
    it'll DFS all the way to '['4'] and ['5'], which the parent ['2']
    sees as ['4', '5'], which then maps that to ['2', ...['├──4'], ...['└──5']],
    making it ['2', '├──4', '└──5'] and ['└──3']
    then its parent will do
    ['1', ...['2', '├──4', '└──5'].map(toPrint('├──', '|')), ...['└──3'].map(toPrint('├──', '|'))]
    which returns
    ['1', ...['├──2', '|  ├──4', '|  └──5'], ...['└──3']]
    which then
    ['1', '├──2', '|  ├──4', '|  └──5', '└──3']
*/
private toStringAtNode(node: INode<T> | null): string[] {
    if (node == null)
        return [];
    if (node.children.length === 0)
        return [node.metadata.toString()];

    const childrenLines = [node.metadata == null ? 'null' : node.metadata.toString()];
    for (let i = 0; i < node.children.length - 1; i++) // all but last children
        childrenLines.push(...this.toStringAtNode(node.children[i]).map(this.toPrint('├──', '|')));

    childrenLines.push(...this.toStringAtNode(last(node.children)).map(this.toPrint('└──', ' ')));
    return childrenLines;
}

private toPrint = (first: string, other: string) => (d: string, i: number) => {
    if (i === 0)
        return first + d;
    return other + '  ' + d;
}