Add days 1-13, 2018

Author: snhansen

2018/day01/solution.py

@@ -0,0 +1,19 @@
+import re 
+from itertools import count
+
+with open("input") as f:
+    inp = f.read().strip()
+
+# Part 1
+nums = list(map(int, re.findall("-?\d+", inp)))
+print(sum(nums))
+
+# Part 2
+seen = set()
+freq = 0
+for i in count():
+    freq += nums[i%len(nums)]
+    if freq in seen:
+        print(freq)
+        break
+    seen.add(freq)

2018/day02/solution.py

@@ -0,0 +1,21 @@
+from collections import Counter
+from itertools import combinations
+
+with open("input") as f:
+    inp = f.read().strip().split("\n")
+
+
+# Part 1
+twos, threes = 0, 0
+for id_ in inp:
+    counts = Counter(id_).values()
+    twos += (2 in counts)
+    threes += (3 in counts)
+
+print(twos*threes)
+
+# Part 2
+for id1, id2 in combinations(inp, 2):
+    if sum(l1 != l2 for l1, l2 in zip(id1, id2)) == 1:
+        print("".join(c for i, c in enumerate(id1) if c == id2[i]))
+        break

2018/day03/solution.py

@@ -0,0 +1,34 @@
+import re
+from itertools import combinations
+
+with open("input") as f:
+    inp = f.read().strip().split("\n")
+
+claims = {}
+for line in inp:
+    id_, ox, oy, w, h = list(map(int, re.findall("\d+", line)))
+    claims[id_] = {
+        x + y*1j
+        for x in range(ox, ox + w)
+        for y in range(oy, oy + h)
+    }
+
+# Part 1
+res = set()
+for cl1, cl2 in combinations(claims.values(), 2):
+    res |= cl1 & cl2
+
+print(len(res))
+
+# Part 2
+for i, claim in claims.items():
+    no_overlap = True
+    for j, other_claim in claims.items():
+        if i == j:
+            continue
+        if len(claim & other_claim) > 0:
+            no_overlap = False
+            break
+    if no_overlap:
+        print(i)
+        break   

2018/day04/solution.py

@@ -0,0 +1,64 @@
+import re
+from collections import defaultdict
+
+with open("input") as f:
+    inp = f.read().strip().split("\n")
+
+records = []
+for line in inp :
+    year, month, day, hour, minute, *rest = list(map(int, re.findall("\d+", line)))
+    if "shift" in line:
+        event = rest[0]
+    elif "asleep" in line:
+        event = -1
+    elif "wakes" in line:
+        event = 0
+    records.append((month, day, hour, minute, event))
+
+records = sorted(records)
+
+sleep = defaultdict(list)
+for record in records:
+    month, day, hour, minute, event = record
+    if event > 0:
+        cur_id = event
+    elif event == -1:
+        start_minute = minute
+    elif event == 0:
+        sleep[cur_id].append((month, day, start_minute, minute - 1))
+
+# Part 1
+def days_asleep(id_, n):
+    res = 0
+    for _, _, start, end in sleep[id_]:
+        res += (start <= n <= end)
+    return res
+
+
+max_ = 0
+for id_, ranges in sleep.items():
+    minutes = sum(end - start + 1 for (_, _, start, end) in ranges)
+    if minutes > max_:
+        max_ = minutes
+        max_id = id_
+
+max_ = 0
+for n in range(60):
+    val = days_asleep(max_id, n)
+    if val > max_:
+        max_ = val
+        max_minute = n
+        
+print(max_id*max_minute)
+        
+# Part 2
+max_ = 0
+for id_, ranges in sleep.items():
+    for n in range(60):
+        val = days_asleep(id_, n)
+        if val > max_:
+            max_ = val
+            max_id = id_
+            max_minute = n
+            
+print(max_id*max_minute)

2018/day05/solution.py

@@ -0,0 +1,36 @@
+with open("input") as f:
+    s = f.read().strip()
+
+
+def react(s):
+    for i in range(len(s) - 1):
+        if s[i].lower() == s[i+1].lower() and s[i] != s[i+1]:
+            return False, s[:i] + s[i+2:]
+    return True, s
+
+
+def reduce(s):
+    while True:
+        done, s = react(s)
+        if done:
+            return s
+
+
+# Part 1
+s = reduce(s)
+print(len(s))
+
+# Part 2
+letters = (chr(97 + i) for i in range(26))
+print(
+    min(
+        map(
+            len,
+            (
+                reduce(
+                    s.replace(letter, "").replace(letter.upper(), ""))
+                    for letter in letters
+            )
+        )
+    )
+)

2018/day06/solution.py

@@ -0,0 +1,39 @@
+from collections import defaultdict
+
+with open("input") as f:
+    inp = f.read().strip().split("\n")
+
+coords = [tuple(map(int, line.split(","))) for line in inp]
+
+# Part 1
+minx = min(x for x, _ in coords)
+maxx = max(x for x, _ in coords)
+miny = min(y for _, y in coords)
+maxy = max(y for _, y in coords)
+
+regions = defaultdict(set)
+for x in range(minx, maxx + 1):
+    for y in range(miny, maxy + 1):
+        dists = [(abs(x - cx) + abs(y - cy), (cx, cy)) for (cx, cy) in coords]
+        dists = sorted(dists)
+        (d1, (c1x, c1y)), (d2, (c2x, c2y)) = dists[0], dists[1]
+        if d1 != d2:
+            regions[(c1x, c1y)].add((x, y))
+
+corners = []
+left = sorted([(cx, cy) for cx, cy in regions.keys() if cx == minx])
+right = sorted([(cx, cy) for cx, cy in regions.keys() if cx == maxx])
+corners = [left[0], left[-1], right[0], right[-1]]
+
+print(max(len(region) for c, region in regions.items() if c not in corners))
+
+# Part 2
+total_dist = 10000
+
+region = set()
+for x in range(minx - total_dist // len(coords), maxx + total_dist // len(coords)):
+    for y in range(miny - total_dist // len(coords), maxy + total_dist // len(coords)):
+        if sum(abs(x - cx) + abs(y - cy) for cx, cy in coords) < total_dist:
+            region.add((x, y))
+
+print(len(region))

2018/day07/solution.py

@@ -0,0 +1,64 @@
+import re
+from collections import defaultdict
+
+with open("input") as f:
+    inp = f.read().strip().split("\n")
+
+reqs = defaultdict(set)
+reqs_inv = defaultdict(set)
+for line in inp:
+    first, second = list(re.findall("(?<=\s)[A-Z](?=\s)", line))
+    reqs[second].add(first)
+    reqs_inv[first].add(second)
+
+
+# Part 1
+temp = [item for ls in reqs.values() for item in ls]
+avail = set()
+for item in temp:
+    if item not in reqs.keys():
+        avail.add(item)
+
+order = []
+while avail:
+    new_avail = sorted(list(avail))
+    order.append(new_avail.pop(0))
+    new_avail = set(new_avail)
+    for candidate in reqs_inv[order[-1]]:
+        if reqs[candidate] <= set(order):
+            new_avail.add(candidate)
+    avail = new_avail
+
+print("".join(order))
+
+# Part 2
+letters = set(order)
+
+steps = 0
+done = []
+workers = [(0, None)]*5
+q = []
+
+while len(done) < len(order):
+    for letter in list(letters):
+        if reqs[letter] <= set(done):
+            q.append(letter)
+            letters.remove(letter)
+
+    # Update workers and take in new orders.
+    for i, (time, item) in enumerate(workers):        
+        if item is not None:
+            workers[i] = (time - 1, item)
+        else:
+            if q:
+                item = q.pop(0)
+                workers[i] = (ord(item) - 4 - 1, item)
+    
+    # Check if workers are done.
+    for i, (time, item) in enumerate(workers):
+        if time == 0 and item is not None:
+            done.append(item)
+            workers[i] = (0, None)
+    steps += 1
+
+print(steps)

2018/day08/solution.py

@@ -0,0 +1,41 @@
+from collections import defaultdict
+
+with open("input") as f:
+    inp = f.read().strip()
+
+
+inp = list(map(int, inp.split(" ")))
+metadata = defaultdict(list)
+children = defaultdict(list)
+descendants = defaultdict(set)
+p = 0
+route = []
+while p < len(inp):
+    jump = 2 + sum(len(metadata[desc]) + 2 for desc in descendants[p]) + len(metadata[p])
+    if len(children[p]) < inp[p]:
+        route.append(p)
+        p += jump 
+    else:
+        metadata[p] = inp[p + jump: p + jump + inp[p + 1]]
+        if route:
+            for q in route:
+                descendants[q].add(p)
+            children[route[-1]].append(p)
+            p = route.pop()
+        else:
+            p += 2 + jump + len(metadata[p])
+
+print(sum(val for ls in metadata.values() for val in ls))
+
+# Part 2
+def value(node):
+    if len(children[node]) == 0:
+        return sum(metadata[node])
+    res = 0
+    for entry in metadata[node]:
+        if 0 <= entry - 1 < len(children[node]):
+            res += value(children[node][entry - 1])
+    return res
+
+
+print(value(0))

2018/day09/solution.py

@@ -0,0 +1,48 @@
+from itertools import cycle
+from collections import defaultdict
+
+
+class Marble:
+    def __init__(self, value):
+        self.value = value
+        self.next = None
+        self.prev = None
+
+
+def solve(max_value):
+    scores = defaultdict(int)
+    players = cycle(range(418))
+    circle = [Marble(0)]
+    circle[0].next = circle[0]
+    circle[0].prev = circle[0]
+    player = next(players)
+    cur_marble = circle[0]
+    for value in range(1, max_value + 1):
+        player = next(players)
+        if value % 23 == 0:
+            scores[player] += value
+            for _ in range(7):
+                cur_marble = cur_marble.prev
+            scores[player] += cur_marble.value
+            cur_marble.prev.next = cur_marble.next
+            cur_marble.next.prev = cur_marble.prev
+            cur_marble = cur_marble.next
+        else:
+            marble = Marble(value)
+            right = cur_marble.next.next
+            left = cur_marble.next
+            right.prev = marble
+            marble.next = right
+            left.next = marble
+            marble.prev = left
+            cur_marble = marble
+            circle.append(marble)
+    
+    return max(scores.values())
+
+
+# Part 1
+print(solve(71339))
+
+# Part 2
+print(solve(71339*100))