new structure for 2018, added license information

2018/08/README.md

@@ -0,0 +1,60 @@
+# 2018 Day 8: Memory Maneuver
+Copyright (c) Eric Wastl 
+#### [Direct Link](https://adventofcode.com/2018/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.
+
+You check your wrist device for anything that might help. 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](https://en.wikipedia.org/wiki/Tree_(data_structure)) 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?**
+
+## 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?**

2018/08/code.py

@@ -0,0 +1,66 @@
+""" https://adventofcode.com/2018/day/8 """
+
+def readFile():
+    with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f:
+        data = f.read()
+        return [int(val) for val in data.split(" ")]
+
+class Node:
+    def __init__(self, numChildren, numMeta):
+        self.numChildren = numChildren
+        self.children = []
+        self.numMeta = numMeta
+        self.meta = []
+
+def parse(vals, i):
+    nodes = []
+    size = len(vals)
+    while i < len(vals):
+        node = Node(vals[i], vals[i+1])
+        i += 2
+        if not node.numChildren:
+            for m in range(node.numMeta):
+                node.meta.append(vals[i + m])
+            nodes.append(node)
+            i += node.numMeta
+            return nodes, i
+        else:
+            for c in range(node.numChildren):
+                temp, i = parse(vals, i)
+                node.children += temp
+            for m in range(node.numMeta):
+                node.meta.append(vals[i + m])
+            nodes.append(node)
+            i += node.numMeta
+            if i >= size:
+                return nodes[0]
+            else:
+                return nodes, i
+
+def part1(node):
+    metadata = 0
+    for child in node.children:
+        metadata += part1(child)
+    for meta in node.meta:
+        metadata += meta
+    return metadata
+
+def part2(node):
+    value = 0
+    if not node.numChildren:
+        for meta in node.meta:
+            value += meta
+    else:
+        for meta in node.meta:
+            try:
+                value += part2(node.children[meta - 1])
+            except IndexError:
+                pass
+    return value
+
+if __name__ == "__main__":
+    vals = readFile()
+    #vals = [int(val) for val in "2 3 0 3 10 11 12 1 1 0 1 99 2 1 1 2".split(" ")]
+    node = parse(vals, 0)
+    print(f"Part 1: {part1(node)}")
+    print(f"Part 2: {part2(node)}")

2018/08/solution.txt

@@ -0,0 +1,2 @@
+Part 1: 42768
+Part 2: 34348