Add day 23, 24, 25, 2018

Author: snhansen

2018/day23/solution.py

@@ -0,0 +1,33 @@
+import re
+from z3 import *
+
+with open("input") as f:
+    inp = f.read().strip().split("\n")
+
+bots = []
+for line in inp:
+    x, y, z, r = map(int, re.findall("-?\d+", line))
+    bots.append(((x, y, z), r))
+
+# Part 1
+def dist(p1, p2):
+    return sum(abs(c1 - c2) for c1, c2 in zip(p1, p2))
+
+
+p, r = sorted(bots, key = lambda x: x[1])[-1]
+print(sum(1 for p2, _ in bots if dist(p, p2) <= r))
+
+# Part 2
+opt = Optimize()
+x, y, z = Int("x"), Int("y"), Int("z")
+
+in_range = []
+for (bx, by, bz), br in bots:
+    in_range.append(If(Abs(x - bx) + Abs(y - by) + Abs(z - bz) <= br, 1, 0))
+
+opt.maximize(Sum(in_range))
+opt.minimize(x + y + z)
+opt.check()
+model = opt.model()
+
+print(sum(abs(model[c].as_long()) for c in model))

2018/day24/solution.py

@@ -0,0 +1,122 @@
+import re
+from itertools import count
+
+with open("input") as f:
+    inp = f.read().strip()
+
+first, second = inp.split("\n\n")
+
+
+class Group:
+    def __init__(self, type_, n, hp, dmg, atype, init, weaks, immunes):
+        self.type_ = type_
+        self.n = n
+        self.hp = hp
+        self.dmg = dmg
+        self.atype = atype
+        self.init = init 
+        self.weaks = weaks
+        self.immunes = immunes
+
+    def epower(self):
+        return self.n * self.dmg
+
+
+def parse(d, text, type_):
+    for i, line in enumerate(text.split("\n")[1:]):
+        n, hp, dmg, init = map(int, re.findall("\d+", line))
+        temp = re.findall("weak to (.*?)(?=[);]|$)", line)
+        weaks = temp[0].split(", ") if temp else []
+        temp = re.findall("immune to (.*?)(?=[);]|$)", line)
+        immunes = temp[0].split(", ") if temp else []
+        atype = re.findall("(\w+)\s+damage", line)[0]
+        d[next(c)] = Group(type_, n, hp, dmg, atype, init, weaks, immunes)
+    return d
+
+
+def calc_dmg(grp1, grp2):
+    if grp1.atype in grp2.immunes:
+        return 0
+    elif grp1.atype in grp2.weaks:
+        return grp1.epower() * 2
+    else:
+        return grp1.epower()
+
+
+def get_targets(groups):
+    targets = []
+    attackers = sorted([(i, grp.epower(), grp.init) for i, grp in groups.items()], key = lambda x: (-x[1], -x[2]))
+    used = set()
+    for i, _, _ in attackers:
+        attacker = groups[i]
+        dmgs = [(j, calc_dmg(attacker, target), target.epower(), target.init) for j, target in groups.items() if j not in used and target.type_ != attacker.type_]
+        dmgs = sorted(dmgs, key = lambda x: (-x[1], -x[2], -x[3]))
+        if dmgs:
+            j, dmg, _, _ = dmgs[0]
+            if dmg > 0:
+                targets.append((i, j, attacker.init))
+                used.add(j)
+    return targets
+
+
+def attack(targets, groups):
+    res = 0
+    targets = sorted(targets, key = lambda x: -x[2])
+    dead = set()
+    for i, j, _ in targets:
+        if i in dead:
+            continue
+        attacker = groups[i]
+        target = groups[j]
+        dmg = calc_dmg(attacker, target)
+        d_units = dmg // target.hp 
+        res += d_units
+        groups[j].n -= d_units
+        if groups[j].n <= 0:
+            dead.add(j)
+            groups.pop(j)
+    return res
+
+
+def get_types(groups):
+    res = set()
+    for grp in groups.values():
+        res.add(grp.type_)
+    return res
+
+
+def get_winner(boost = 0):
+    global c 
+    c = count()
+    groups = parse({}, first, "immune")
+    groups = parse(groups, second, "infected")
+    for i, grp in groups.items():
+        if grp.type_ == "immune":
+            grp.dmg += boost
+    while True:
+        targets = get_targets(groups)
+        res = attack(targets, groups)
+        if res == 0:
+            break
+    return get_types(groups), sum(grp.n for grp in groups.values())
+
+# Part 1
+_, units = get_winner()
+print(units)
+
+# Part 2
+low, high = 0, 10000
+while (low < high):
+    mid = low + (high - low) // 2
+    remaining, units = get_winner(boost = mid)
+    if len(remaining) > 1:
+        low = mid + 1
+    else:
+        winner = remaining.pop()
+        if winner == "immune":
+            high = mid
+        else:
+            low = mid + 1
+
+_, units = get_winner(boost = low)
+print(units)

2018/day25/solution.py

@@ -0,0 +1,23 @@
+import networkx as nx
+import re
+from itertools import combinations
+
+with open("input") as f:
+    inp = f.read().strip().split("\n")
+
+
+def dist(p1, p2):
+    return sum(abs(c1 - c2) for c1, c2 in zip(p1, p2))
+
+
+points = [tuple(map(int, re.findall("-?\d+", line))) for line in inp]
+g = nx.Graph()
+
+for p1, p2 in combinations(points, 2):
+    g.add_node(p1)
+    g.add_node(p2)
+    if dist(p1, p2) <= 3:
+        g.add_edge(p1, p2)
+
+# Part 1
+print(len(list(nx.connected_components(g))))