Add days 19-25, 2016

Author: snhansen

2016/day19/solution.py

@@ -0,0 +1,32 @@
+from collections import deque
+
+inp = 3017957
+
+# Part 1
+def one_round(start, end, inc):
+    n = (end - start + inc) // inc
+    if n % 2 == 0:
+        return (start, end - inc, 2*inc)
+    else:
+        return (start + 2*inc, end, 2*inc)
+
+start, end, inc = 1, inp, 1
+while start + inc <= end:
+    start, end, inc = one_round(start, end, inc)
+
+print(start)
+
+# Part 2
+left = deque(list(range(1, inp // 2 + 2)))
+right = deque(list(range(inp // 2 + 2, inp + 1)))
+
+while len(left) + len(right) > 1:
+    elf = left.popleft()
+    if (len(left) + len(right)) % 2 == 1:
+        right.popleft()
+    else:
+        left.pop()
+    right.append(elf)
+    left.append(right.popleft())
+ 
+print(left[0])

2016/day20/solution.py

@@ -0,0 +1,35 @@
+with open("input") as f:
+   inp = f.read().strip()
+
+ranges = [tuple(map(int, line.split("-"))) for line in inp.split("\n")]
+
+# Part 1
+candidates = [0] + [end + 1 for _, end in ranges]
+
+min_start = max(start for start, _ in ranges)
+for candidate in candidates:
+    good = True
+    for start, end in ranges:
+        if start <= candidate and candidate <= end:
+            good = False
+    if good:
+        min_start = min(min_start, candidate)
+
+print(min_start)
+
+# Part 2
+ticks = sorted([p for range in ranges for p in range])
+disj_ranges = set()
+for start, end in ranges:
+    midps = [tick for tick in ticks if start < tick and tick < end]
+    if not midps:
+        disj_ranges.add((start, end))
+    else:
+        for p1, p2 in zip([start] + midps, midps + [end]):
+            disj_ranges.add((p1, p2))
+
+# Since the endpoints can be in multiple intervals we need to subtract how many times this occur.
+blacklist_length = sum(y - x + 1 for x, y in disj_ranges)
+endpoints = [p for range in disj_ranges for p in range]
+n_blacklist = blacklist_length - (len(endpoints) - len(set(endpoints)))
+print(2**32 - n_blacklist)

2016/day21/solution.py

@@ -0,0 +1,76 @@
+from itertools import permutations
+
+with open("input") as f:
+    inp = f.read().strip().split("\n")
+
+
+def swapposition(s, index1, index2):
+    s[index1], s[index2] = s[index2], s[index1]
+    return s
+
+
+def swapletter(s, letter1, letter2):
+    return swapposition(s, s.index(letter1), s.index(letter2))
+
+
+def rotateleft(s, steps):
+    assert steps <= len(s)
+    s = s[steps:] + s[:steps]
+    return s
+
+
+def rotateright(s, steps):
+    s = rotateleft(s[::-1], steps)
+    return s[::-1]
+
+
+def rotatebased(s, letter):
+    steps = s.index(letter) + 1
+    if steps >= 5:
+        steps += 1
+    steps %= len(s)
+    return rotateright(s, steps)
+
+
+def reversepositions(s, index1, index2):
+    sub_s = s[index1:(index2 + 1)]
+    return s[:index1] + sub_s[::-1] + s[(index2 + 1):]
+
+
+def moveposition(s, index1, index2):
+    s.insert(index2, s.pop(index1))
+    return s
+
+
+def scramble(s):
+    s = list(s)
+    for line in inp:
+        parts = line.split(" ")
+        operation = parts[0] + parts[1]
+        match operation:
+            case "swapposition":
+                s = swapposition(s, int(parts[2]), int(parts[5]))
+            case "swapletter":
+                s = swapletter(s, parts[2], parts[5])
+            case "rotateleft":
+                s = rotateleft(s, int(parts[2]))
+            case "rotateright":
+                s = rotateright(s, int(parts[2]))
+            case "rotatebased":
+                s = rotatebased(s, parts[6])
+            case "reversepositions":
+                s = reversepositions(s, int(parts[2]), int(parts[4]))
+            case "moveposition":
+                s = moveposition(s, int(parts[2]), int(parts[5]))
+    return "".join(s)
+
+# Part 1
+pw = "abcdefgh"
+print(scramble(pw))
+
+# Part 2
+for s in permutations(pw, len(pw)):
+    s = "".join(s)
+    if scramble(s) == "fbgdceah":
+        print(s)
+        break

2016/day22/solution.py

@@ -0,0 +1,83 @@
+import re
+from itertools import permutations
+
+with open("input") as f:
+    inp = f.read().strip().split("\n")
+
+nodes = []
+for line in inp:
+    if line[0] != "/":
+        continue
+    nodes.append(tuple(map(int, re.findall("\d+", line))))
+
+# Part 1
+viable_pairs = 0
+for nodea, nodeb in permutations(nodes, 2):
+    _, _, _, useda, availa, _ = nodea
+    _, _, _, usedb, availb, _ = nodeb
+    if useda > 0 and useda <= availb:
+        viable_pairs += 1
+
+print(viable_pairs)
+
+# Part 2
+
+# Our grid is 38x38 so the node we have access to is at (0,0) and the node which data we want to access is at (37,0).
+# Data blocks between (12,6) and (12,37) are large (490-498), and they can never fit into smaller sized nodes, 
+# so they're stuck. This means we can only move data between smaller sized nodes (85-94). Since the smaller data blocks
+# themselves are between 64-73 these can only be moved into an empty node. We note that all small-sized data blocks can fit
+# into all nodes.
+# Since there is only one empty node, we are essentially swapping data between the empty node and its neighbors.
+#
+# Our grid looks like this:
+#
+# a . . . . . . . . . . . . d
+# . . . . . . . . . . . . . .
+# . . . . . . . . . . . . . .
+# . . . . # # # # # # # # # #
+# . . . . . . . . . . . . . .
+# . . . . . . . . . . . . . .
+# . . . . . . . . . . . 0 . .
+#
+# where 
+# - # denotes the large nodes which can't be moved (12,6), ..., (12,37)
+# - d denotes the data we want access to (37,0)
+# - a the node we have access to (0,0)
+# - 0 the empty node (16,23)
+#
+# The goal is to move d to a. This can be achieved in two steps:
+# 1. Move the empty node up next to d, so the grid looks like this:
+#
+# a . . . . . . . . . . . 0 d
+# . . . . . . . . . . . . . .
+# . . . . . . . . . . . . . .
+# . . . . # # # # # # # # # #
+# . . . . . . . . . . . . . .
+# . . . . . . . . . . . . . .
+# . . . . . . . . . . . . . .
+# 
+# This can be done via this path: (16,23) -> (5,23) -> (5,0) -> (36,0) which
+# takes (16 - 5) + (23 - 0) + (36 - 5) steps
+# 
+# 2. Then we move d to left one step and then we need to move the 0 around d so it
+# again is in front requiring 4 steps. This would look like this:
+#
+# a . . . . . . . . . . . d 0
+# . . . . . . . . . . . . . .
+# . . . . . . . . . . . . . .
+# . . . . # # # # # # # # # #
+# . . . . . . . . . . . . . .
+# . . . . . . . . . . . . . .
+# . . . . . . . . . . . . . .
+# 
+# a . . . . . . . . . . 0 d .
+# . . . . . . . . . . . . . .
+# . . . . . . . . . . . . . .
+# . . . . # # # # # # # # # #
+# . . . . . . . . . . . . . .
+# . . . . . . . . . . . . . .
+# . . . . . . . . . . . . . .
+# 
+# Each step to the left requires 5 steps and we end up with 0 in front af d. After 36*5 steps
+# d is positioned at (1,0) with 0 at (0,0). After one additional step d has been moved to (0,0).
+print((16 - 5) + (23 - 0) + (36 - 5) + 36*5 + 1)

2016/day23/solution.py

@@ -0,0 +1,84 @@
+with open("input") as f:
+    inp = f.read().strip()
+
+instr_init = []
+for line in inp.split("\n"):
+    op, *rest = line.split(" ")
+    instr_init.append((op, rest))
+
+# After inspecting the input, we note that the sequence:
+# 
+# inc a
+# dec c
+# jnz c -2
+# dec d
+# jnz d -5
+#
+# will add c*d to a and reset c and d to 0. We replace this with a
+# new operation caled mlt x y which multiplies registers x and y 
+# and adds the result to register a:
+#
+# mlt c d
+# cpy 0 c
+# cpy 0 d
+# cpy 0 c
+# cpy 0 d
+#
+# The reason we have the two cpy instructions twice is to keep the
+# instructions at the same length.
+
+instr_init[5:10] = [
+    ("mlt", ["c", "d"]),
+    ("cpy", ["0", "c"]),
+    ("cpy", ["0", "d"]),
+    ("cpy", ["0", "c"]),
+    ("cpy", ["0", "d"])
+]
+
+    
+def solve(a):
+    register = {x: 0 for x in ("a", "b", "c", "d")}
+    register["a"] = a
+    pointer = 0
+    instr = list(instr_init)
+    while pointer < len(instr):
+        op, rest = instr[pointer]
+        if op == "cpy":
+            val, target = rest
+            register[target] = int(val) if val.lstrip("-").isnumeric() else int(register[val])
+        elif op == "inc":
+            register[rest[0]] += 1
+        elif op == "dec":
+            register[rest[0]] -= 1
+        elif op == "jnz":
+            x, y = rest
+            decider = int(x) if x.isnumeric() else register[x]
+            y = int(y) if y.lstrip("-").isnumeric() else register[y]
+            if decider != 0:
+                pointer += y
+                continue
+        elif op == "tgl":
+            t_pointer = pointer + register[rest[0]]
+            if t_pointer < len(instr):
+                t_op, t_rest = instr[t_pointer]
+                if t_op == "inc":
+                    instr[t_pointer] = ("dec", t_rest)
+                elif t_op == "dec":
+                    instr[t_pointer] = ("inc", t_rest)
+                elif t_op == "tgl":
+                    instr[t_pointer] = ("inc", t_rest)
+                elif t_op == "jnz":
+                    instr[t_pointer] = ("cpy", t_rest)
+                elif t_op == "cpy":
+                    instr[t_pointer] = ("jnz", t_rest)
+        elif op == "mlt":
+            register["a"] += register[rest[0]]*register[rest[1]]
+        pointer += 1
+    return register["a"]
+
+
+# Part 1
+print(solve(7))
+
+# Part 2
+print(solve(12))

2016/day24/solution.py

@@ -0,0 +1,62 @@
+from collections import deque
+import networkx as nx
+from itertools import permutations
+
+with open("input") as f:
+    inp = f.read().strip().split("\n")
+
+nums = {j + i*1j: int(x) for i, l in enumerate(inp) for j, x in enumerate(l) if x.isdigit()}
+rev_nums = {num: p for p, num in nums.items()}
+opens = {j + i*1j for i, l in enumerate(inp) for j, x in enumerate(l) if x != "#"}
+
+
+def get_distances(num):
+    res = {}
+    seen = set()
+    q = deque([(rev_nums[num], 0)])
+    other_nums = set(p for p, num2 in nums.items() if num2 != num)
+    while q:
+        p, steps = q.popleft()
+        if p in other_nums:
+            if nums[p] not in res:
+                res[nums[p]] = steps
+            res[nums[p]] = min(steps, res[nums[p]])
+            continue
+        if p in seen:
+            continue
+        seen.add(p)
+        for dp in (1, -1, 1j, -1j):
+            new_p = p + dp
+            if new_p not in opens:
+                continue
+            q.append((new_p, steps + 1))            
+    return res
+
+
+g = nx.Graph()
+for num in range(8):
+    for other_num, steps in get_distances(num).items():
+        g.add_edge(num, other_num, weight = steps)
+
+
+def steps(route):
+    res = 0
+    for n1, n2 in zip([0] + route, route):
+        if (n1, n2) not in g.edges():
+            return None
+        res += g[n1][n2]["weight"]
+    return res
+
+
+paths = []
+for route in permutations(range(1, 8), 7):
+    route = list(route)
+    res = steps(route)
+    if res is not None:
+        paths.append((res, g[route[-1]][0]["weight"]))
+
+# Part 1
+print(min(path for path, _ in paths))
+
+# Part 2
+print(min(path + return_ for path, return_ in paths))