Add 2017

Author: snhansen

2017/day01/solution.py

@@ -0,0 +1,13 @@
+with open("input") as f:
+    inp = f.read().strip()
+
+# Part 1
+print(sum(int(x) for x, y in zip(inp, inp[1:] + inp[0]) if x == y))
+
+# Part 2
+ans = 0
+for i in range(len(inp)):
+    if inp[i] == inp[(i + len(inp)//2) % len(inp)]:
+        ans += int(inp[i])
+
+print(ans)

2017/day02/solution.py

@@ -0,0 +1,19 @@
+from itertools import permutations
+import re
+
+with open("input") as f:
+    inp = f.read().strip().split("\n")
+
+rows = [list(map(int, re.findall("\d+", line))) for line in inp]
+
+# Part 1
+print(sum(max(row) - min(row) for row in rows))
+
+# Part 2
+ans = 0
+for row in rows:
+    for x, y in permutations(row, 2):
+        if x % y == 0:
+            ans += x // y
+            break
+print(ans)

2017/day03/solution.py

@@ -0,0 +1,38 @@
+from itertools import count
+from collections import defaultdict
+
+inp = 368078
+
+# Part 1
+def solve_pt1():
+    dp = [1, -1j, -1, 1j]
+    points = {1: 0}
+    p, c = 0, 2
+    for n in count():
+        dist = int(((n + 2)/2) // 1)
+        for _ in range(dist):
+            new_p = p + dp[n % 4]
+            points[c] = new_p
+            p = new_p
+            if c == inp:
+                return int(abs(p.imag) + abs(p.real))
+            c += 1
+        
+print(solve_pt1())
+
+# Part 2
+def solve_pt2():
+    dp = [1, -1j, -1, 1j]
+    points = defaultdict(int)
+    points[0] = 1
+    p = 0
+    for n in count():
+        dist = int(((n + 2)/2) // 1)
+        for _ in range(dist):
+            new_p = p + dp[n % 4]
+            points[new_p] = sum(points[new_p + dp2] for dp2 in (1, -1, 1j, -1j, 1+1j, 1-1j, -1+1j, -1-1j))
+            if points[new_p] >= inp:
+                return points[new_p]
+            p = new_p
+
+print(solve_pt2())

2017/day04/solution.py

@@ -0,0 +1,18 @@
+from itertools import combinations
+
+with open("input") as f:
+    inp = f.read().strip().split("\n")
+
+passphrases = [line.split(" ") for line in inp]
+
+# Part 1
+print(sum(1 for passphrase in passphrases if len(passphrase) == len(set(passphrase))))
+
+# Part 2
+ans = 0
+for passphrase in passphrases:
+    if any(set(word1) == set(word2) for word1, word2 in combinations(passphrase, 2)):
+        continue
+    ans += 1
+
+print(ans)

2017/day05/solution.py

@@ -0,0 +1,23 @@
+from itertools import count
+
+with open("input") as f:
+    inp = f.read().strip().split("\n")
+
+
+def solve(part2 = False):
+    jumps = list(map(int, inp))
+    p = 0
+    for c in count():
+        if p >= len(jumps):
+            return c
+        jump = jumps[p]
+        jumps[p] += 1
+        if part2 and jump >= 3:
+            jumps[p] -= 2
+        p += jump
+
+# Part 1
+print(solve())
+
+# Part 2
+print(solve(True))

2017/day06/solution.py

@@ -0,0 +1,27 @@
+from itertools import count
+
+with open("input") as f:
+    inp = f.read().strip()
+
+banks = tuple(map(int, inp.split("	")))
+
+
+def redestribute(banks):
+    banks = list(banks)
+    n = len(banks)
+    i = min(i for i, x in enumerate(banks) if x == max(banks))
+    blocks = banks[i]
+    banks[i] = 0
+    for j in range(blocks):
+        banks[(i + 1 + j) % n] += 1
+    return tuple(banks)
+
+
+seen = {banks: 0}
+for c in count():
+    banks = redestribute(banks)
+    if banks in seen:
+        print(c + 1)
+        print(c + 1 - seen[banks])
+        break
+    seen[banks] = c + 1

2017/day07/solution.py

@@ -0,0 +1,39 @@
+with open("input") as f:
+    inp = f.read().strip().split("\n")
+
+lookup = {}
+weight = {}
+for line in inp:
+    first, *rest = line.split(" -> ")
+    if rest:
+        rest = rest[0].split(", ")
+    first, w = first.split(" ")
+    lookup[first] = rest
+    weight[first] = int(w.strip("(").strip(")"))
+
+# Part 1
+subtowers = {x for u in lookup.values() for x in u}
+print((set(lookup.keys()) - subtowers).pop())
+
+# Part 2
+def total_weight(node):
+    if not lookup[node]:
+        return weight[node]
+    return sum(total_weight(subnode) for subnode in lookup[node]) + weight[node]
+
+
+bottom = (set(lookup.keys()) - subtowers).pop()
+q = [bottom]
+while q:
+    node = q.pop(0)    
+    weights = {subnode: total_weight(subnode) for subnode in lookup[node]}
+    for subnode, w in weights.items():
+        if list(weights.values()).count(w) == 1:
+            unbl_node = subnode
+            q.append(subnode)
+
+for node, subnodes in lookup.items():
+    if unbl_node in subnodes:
+        target_weight = [total_weight(subnode) for subnode in subnodes if subnode !=  unbl_node][0]
+
+print(weight[unbl_node] - (total_weight(unbl_node) - target_weight))

2017/day08/solution.py

@@ -0,0 +1,21 @@
+from collections import defaultdict
+
+with open("input") as f:
+    inp = f.read().strip()
+
+reg = defaultdict(int)
+reg_max = 0
+for instr in inp.split("\n"):
+    first, last = instr.split(" if ")
+    target, op, val = first.split(" ")
+    op = "+=" if op == "inc" else "-="
+    rel_reg, rel_op, rel_val  = last.split(" ")
+    string = f"if reg[\"{rel_reg}\"] {rel_op} {rel_val}: reg[\"{target}\"] {op} {val}"
+    exec(string)
+    reg_max= max(max(reg.values()), reg_max)
+
+# Part 1
+print(max(reg.values()))
+
+# Part 2
+print(reg_max)

2017/day09/solution.py

@@ -0,0 +1,32 @@
+with open("input") as f:
+    inp = f.read().strip()
+
+i = 0
+group_score = 0
+garbage = False
+groups = []
+c_garbage = 0
+while i < len(inp):
+    c = inp[i]
+    if c == "<" and not garbage:
+        garbage = True
+        c_garbage -= 1
+    elif c == ">" and garbage:
+        garbage = False
+    elif c == "!" and garbage:
+        i += 2
+        continue
+    elif c == "{" and not garbage:
+        group_score += 1
+    elif c == "}" and not garbage:
+        groups.append(group_score)
+        group_score -= 1
+    if garbage:
+        c_garbage += 1
+    i += 1
+
+# Part 1
+print(sum(groups))
+
+# Part 2
+print(c_garbage)

2017/day10/solution.py

@@ -0,0 +1,59 @@
+from functools import reduce
+
+with open("input") as f:
+    inp = f.read().strip()
+
+lengths = list(map(int, inp.split(",")))
+
+# Part 1
+ls = list(range(256))
+n = len(ls)
+p = 0
+skip_size = 0
+for l in lengths:
+    if p + l <= n:
+        sub_ls = ls[p:(p+l)]
+        ls = ls[:p] + sub_ls[::-1] + ls[p+l:]
+    else:
+        rev = ls[p:] + ls[:(l-(n-p))]
+        rev = rev[::-1]
+        rest = ls[(l-(n-p)):p]
+        ls = rev[(n-p):] + rest + rev[:(n-p)]
+    p += l + skip_size
+    p %= n
+    skip_size += 1
+
+
+print(ls[0]*ls[1])
+
+# Part 2
+ascii_lengths = [ord(c) for c in inp]
+ascii_lengths += [17, 31, 73, 47, 23]
+
+ls = list(range(256))
+n = len(ls)
+p = 0
+skip_size = 0
+for _ in range(64):
+    for l in ascii_lengths:
+        if p + l <= n:
+            sub_ls = ls[p:(p+l)]
+            ls = ls[:p] + sub_ls[::-1] + ls[p+l:]
+        else:
+            rev = ls[p:] + ls[:(l-(n-p))]
+            rev = rev[::-1]
+            rest = ls[(l-(n-p)):p]
+            ls = rev[(n-p):] + rest + rev[:(n-p)]
+        p += l + skip_size
+        p %= n
+        skip_size += 1
+
+res = ""
+for i in range(0, 16):
+    block = reduce(lambda x, y: x ^ y, ls[16*i:16*(i+1)])
+    h = hex(block)[2:]
+    if len(h) == 1:
+        h = "0" + h
+    res += h
+
+print(res)