Ugly day 17+18 solutions, need cleanup

2021/17_probe.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+import sys
+import re
+from itertools import islice
+from operator import or_
+from functools import reduce
+
+def xsteps(dx, lo, hi):
+    x = steps = 0
+    while x <= hi and dx:
+        x += dx
+        steps += 1
+        dx -= 1
+        if lo <= x <= hi:
+            if dx:
+                yield steps
+            else:
+                yield from range(steps, 300)
+
+def ysteps(dy, lo, hi):
+    y = steps = 0
+    while y >= lo:
+        y += dy
+        dy -= 1
+        steps += 1
+        if lo <= y <= hi:
+            yield steps
+
+def bucketize(values, keys):
+    buckets = {}
+    for value in values:
+        for key in keys(value):
+            buckets.setdefault(key, []).append(value)
+    return buckets
+
+def sim(x1, x2, y1, y2):
+    ix = bucketize(range(1000), lambda dx: xsteps(dx, x1, x2))
+
+    for dy in range(y1, 200):
+        for steps in ysteps(dy, y1, y2):
+            for dx in set(ix.get(steps, [])):
+                yield dx, dy
+
+def maxy(vy):
+    return 0 if vy < 0 else vy * (vy + 1) // 2
+
+x1, x2, y1, y2 = map(int, re.findall(r'-?\d+', sys.stdin.readline()))
+velocities = list(sim(x1, x2, y1, y2))
+print(max(maxy(vy) for vx, vy in velocities))
+print(len(velocities))

2021/18_snailfish.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+import sys
+from ast import literal_eval
+from functools import reduce
+from itertools import permutations
+
+class Number:
+    def __init__(self, value, left, right):
+        self.prev = self.next = None
+        self.value = value
+        self.left = left
+        self.right = right
+
+    @classmethod
+    def maybe_pair(cls, maybe_list):
+        if isinstance(maybe_list, int):
+            return cls(maybe_list, None, None)
+        left, right = map(cls.maybe_pair, maybe_list)
+        return cls(None, left, right)
+
+    @classmethod
+    def fromlist(cls, list_num):
+        root = cls.maybe_pair(list_num)
+        prev = None
+        for node in root.numbers():
+            if prev:
+                prev.next = node
+            node.prev = prev
+            prev = node
+        return root
+
+    def isnum(self):
+        return self.value is not None
+
+    def numbers(self):
+        if self.isnum():
+            yield self
+        else:
+            yield from self.left.numbers()
+            yield from self.right.numbers()
+
+    def __repr__(self):
+        if self.value is not None:
+            return repr(self.value)
+        return '[%s,%s]' % (self.left, self.right)
+
+    def first(self):
+        return self if self.isnum() else self.left.first()
+
+    def last(self):
+        return self if self.isnum() else self.right.last()
+
+    def add(self, other):
+        new = self.__class__(None, self, other)
+        l = self.last()
+        r = other.first()
+        l.next = r
+        r.prev = l
+        new.reduce()
+        return new
+
+    def explode(self, depth):
+        if self.isnum():
+            return False
+
+        if self.left.isnum() and self.right.isnum() and depth >= 4:
+            self.prev = self.left.prev
+            self.next = self.right.next
+            if self.left.prev:
+                self.left.prev.value += self.left.value
+                self.left.prev.next = self
+            if self.right.next:
+                self.right.next.value += self.right.value
+                self.right.next.prev = self
+            self.left = self.right = None
+            self.value = 0
+            return True
+
+        return self.left.explode(depth + 1) or self.right.explode(depth + 1)
+
+    def split(self):
+        if not self.isnum():
+            return self.left.split() or self.right.split()
+
+        if self.value < 10:
+            return False
+
+        half, odd = divmod(self.value, 2)
+        self.left = self.__class__(half, None, None)
+        self.right = self.__class__(half + odd, None, None)
+        if self.prev:
+            self.prev.next = self.left
+        if self.next:
+            self.next.prev = self.right
+        self.left.prev = self.prev
+        self.left.next = self.right
+        self.right.prev = self.left
+        self.right.next = self.next
+        self.value = self.prev = self.next = None
+        return True
+
+    def reduce(self):
+        if not self.isnum() or self.split():
+            if self.explode(0) or self.split():
+                self.reduce()
+
+    def magnitude(self):
+        if self.isnum():
+            return self.value
+        return 3 * self.left.magnitude() + 2 * self.right.magnitude()
+
+nums = list(map(literal_eval, sys.stdin))
+print(reduce(Number.add, map(Number.fromlist, nums)).magnitude())
+print(max(Number.fromlist(x).add(Number.fromlist(y)).magnitude()
+          for x, y in permutations(nums, 2)))

2021/input/17

@@ -0,0 +1 @@
+target area: x=195..238, y=-93..-67

2021/input/18

@@ -0,0 +1,100 @@
+[[3,[8,[2,1]]],[[[0,6],[0,2]],3]]
+[[[1,[8,5]],[[3,9],0]],2]
+[5,[[5,[3,8]],[7,4]]]
+[1,[[[0,4],[8,5]],6]]
+[[[1,[0,3]],2],[2,[0,[7,9]]]]
+[[[4,[4,4]],[[7,2],[7,1]]],9]
+[5,[4,4]]
+[[0,[[2,6],[8,9]]],[[4,5],2]]
+[[[8,2],0],3]
+[[9,0],[3,3]]
+[[[[5,2],2],5],5]
+[[[1,6],[[0,4],[7,7]]],[[1,4],[[6,5],5]]]
+[[[[4,1],[4,1]],[2,[5,5]]],[1,[0,[0,6]]]]
+[[[[1,5],1],[8,4]],[9,[3,4]]]
+[[1,[3,3]],[[[7,4],[8,1]],2]]
+[3,[[[2,1],4],[5,4]]]
+[6,[[0,[1,9]],[[4,0],8]]]
+[5,[7,[7,[8,8]]]]
+[[[[6,2],[5,8]],[5,[3,1]]],[[7,9],[[2,0],6]]]
+[[[7,[7,9]],[5,7]],[[[9,3],[6,9]],[[1,2],[2,3]]]]
+[[[[4,1],2],[1,[6,6]]],[[[2,2],[8,8]],4]]
+[[[[3,7],4],8],[6,[[0,2],3]]]
+[[[[1,8],2],3],[[9,[1,7]],[[0,0],[6,8]]]]
+[[[9,[5,2]],7],[[8,6],[8,[1,2]]]]
+[[[7,[1,0]],[[6,0],[8,4]]],[[[7,8],5],[3,[1,2]]]]
+[[[[2,5],9],[[8,2],0]],0]
+[0,[[[7,5],[4,1]],[5,[6,6]]]]
+[[[[3,6],2],[[1,1],[6,6]]],0]
+[[[[0,9],[2,5]],[2,[3,2]]],[6,3]]
+[3,[[9,[1,4]],[[0,8],[4,6]]]]
+[1,[[5,[5,9]],[9,0]]]
+[[[6,8],4],[[[6,6],2],[[3,9],2]]]
+[5,[[[7,5],[4,8]],0]]
+[[9,[6,6]],[9,[[6,8],[6,4]]]]
+[[[4,8],[0,[2,8]]],[7,[[4,5],[1,6]]]]
+[[[6,[8,6]],2],[[[2,9],[2,4]],[0,2]]]
+[[[0,[5,6]],[[3,8],3]],[[3,1],7]]
+[[1,[8,1]],[1,[6,[7,1]]]]
+[[[5,[9,6]],[3,5]],2]
+[[3,7],[[[2,5],[4,1]],[3,[5,6]]]]
+[[8,7],[[9,6],3]]
+[[[[4,2],[4,8]],[7,[4,5]]],2]
+[[[[6,7],6],3],[[[6,7],4],0]]
+[[[0,1],[[9,1],[2,9]]],9]
+[[[[8,5],[5,8]],[0,7]],[0,[8,[3,2]]]]
+[[4,[[6,5],[1,9]]],[[[0,0],1],6]]
+[[[[9,5],9],[2,[6,3]]],[[2,9],[6,9]]]
+[[[7,[5,0]],1],[7,[[8,7],3]]]
+[[[2,4],2],[[[3,0],6],[[0,2],[9,2]]]]
+[[1,[[7,3],[4,3]]],[[[3,9],[1,1]],[3,6]]]
+[[[[4,7],7],[[7,1],[2,3]]],[1,[[7,6],[5,6]]]]
+[[0,[5,2]],0]
+[[[[6,6],[4,8]],8],[[0,[7,4]],8]]
+[[4,[7,2]],[[[0,8],1],[9,5]]]
+[0,0]
+[[[[3,7],6],3],[3,[[3,3],1]]]
+[[[6,5],7],[[3,5],[[6,4],[4,9]]]]
+[[4,[[7,9],9]],9]
+[5,[8,[[7,4],1]]]
+[[[[2,4],[5,7]],8],[[[7,6],[6,9]],[[3,9],[6,4]]]]
+[[[4,8],3],[[[3,9],7],0]]
+[0,[8,[[4,2],3]]]
+[[[[0,1],[5,8]],[7,2]],[2,4]]
+[[6,[8,[1,9]]],[[[6,5],[8,1]],[7,[6,4]]]]
+[[9,3],[5,[0,6]]]
+[[2,[7,[2,0]]],[[2,1],[5,5]]]
+[[[0,[7,0]],[[0,4],[4,9]]],[8,[[6,1],[6,3]]]]
+[[[[5,7],[3,2]],[0,[5,0]]],[[0,[1,6]],3]]
+[[[[6,3],[9,5]],[9,9]],[[5,[8,3]],[[0,0],[0,3]]]]
+[[6,[4,9]],[[[9,9],[8,4]],4]]
+[0,[2,5]]
+[[[[7,9],[1,2]],[3,3]],[[[7,2],7],[[1,6],0]]]
+[[[[8,0],2],8],[[[1,5],9],9]]
+[[[0,[6,9]],4],[[[4,8],5],4]]
+[[6,[[0,3],4]],[0,[[8,3],1]]]
+[[[1,2],[2,[3,3]]],[6,7]]
+[[0,[[7,4],5]],[3,[[8,2],0]]]
+[[[[0,1],[1,7]],[[2,7],[5,9]]],[[[7,0],0],[8,1]]]
+[[6,4],[3,0]]
+[[[[6,6],4],[5,1]],[7,3]]
+[[[[9,2],3],[8,[4,8]]],7]
+[[5,[[2,2],[9,2]]],[[[1,8],0],[8,[6,3]]]]
+[2,[[0,0],[0,[9,9]]]]
+[[4,4],[[6,5],[6,5]]]
+[[[[9,1],2],4],5]
+[[[[2,1],[3,1]],[[2,6],9]],5]
+[[[9,[0,6]],7],[[8,3],[[8,1],2]]]
+[[[6,[0,0]],[2,[0,0]]],[[[0,4],8],3]]
+[[[[4,1],[2,9]],[6,5]],3]
+[[9,[[9,4],8]],[[[5,5],3],[[3,4],4]]]
+[8,[9,[[0,3],1]]]
+[9,[[[6,0],4],9]]
+[[6,[2,9]],[[[2,7],[5,3]],0]]
+[[[4,1],5],[8,[[0,7],4]]]
+[[[[2,5],5],[[8,2],[8,9]]],[[9,6],[[0,3],[2,3]]]]
+[6,1]
+[[1,7],4]
+[[8,7],0]
+[[[[5,4],7],5],[[[6,1],5],[5,[5,5]]]]
+[[[6,[1,5]],[0,[7,0]]],[[[1,5],3],[5,[1,0]]]]