Day 18

Author: foof

15/2.py

@@ -23,7 +23,7 @@ def solve(start, end, nodes):
     def h(node):
         return abs(max_x-node[0]) + abs(max_y-node[0])
 
-    open_set = [(0, start[0], start[1])]
+    open_set = [(float(0), int(start[0]), int(start[1]))]
     heapq.heapify(open_set)
 
     came_from = {}

17/1.py

@@ -0,0 +1,39 @@
+
+import re
+
+
+def solve(x_bounds, y_bounds):
+    hits = []
+    velocities = []
+    for x in range(0, 130):
+        for y in range(min(y_bounds), 150):
+            velocities.append((x, y))
+
+    for velocity in velocities:
+        new_velocity = velocity
+        pos = (0, 0)
+        steps = []
+        while pos[1] >= min(y_bounds):
+            steps.append(pos)
+            pos = (pos[0]+new_velocity[0], pos[1]+new_velocity[1])
+
+            if pos[0] >= x_bounds[0] and pos[0] <= x_bounds[1] and pos[1] >= y_bounds[0] and pos[1] <= y_bounds[1]:
+                hits.append(velocity)
+                break
+
+            new_x_velocity = new_velocity[0]
+            if new_x_velocity > 0:
+                new_x_velocity -= 1
+            elif new_x_velocity < 0:
+                new_x_velocity += 1
+            new_velocity = (new_x_velocity, new_velocity[1]-1)
+
+    return len(hits)
+
+
+if __name__ == "__main__":
+    with open('./input', 'r') as f:
+        x1, x2, y1, y2 = map(int, re.findall('-?\d+', f.read().strip()))
+        x_bounds, y_bounds = (x1, x2), (y1, y2)
+
+        print(solve(x_bounds, y_bounds))

17/2.py

@@ -0,0 +1,9 @@
+
+def solve(lines):
+    return lines
+
+
+if __name__ == "__main__":
+    with open('./input', 'r') as f:
+        lines = f.read().splitlines()
+        print(solve(lines))

17/input

@@ -0,0 +1 @@
+target area: x=81..129, y=-150..-108

18/1_2.py

@@ -0,0 +1,212 @@
+
+import math
+from collections import deque
+
+
+class Node:
+    left = None
+    right = None
+    parent = None
+
+    def __init__(self, number=None):
+        if number:
+            self.set_left(number[0])
+            self.set_right(number[1])
+
+    def set_left(self, node):
+        if type(node) == list:
+            node = Node(node)
+
+        self.left = node
+
+        if type(node) == Node:
+            node.parent = self
+
+    def set_right(self, node):
+        if type(node) == list:
+            node = Node(node)
+
+        self.right = node
+
+        if type(node) == Node:
+            node.parent = self
+
+    def is_bottom(self):
+        return type(self.left) == int and type(self.right) == int
+
+    def find_depth(self):
+        depth = 1
+        n = self
+        while n.parent:
+            n = n.parent
+            depth += 1
+        return depth
+
+    def reduce(self):
+        node_to_explode = self.find_node_to_explode()
+        node_to_split = self.find_node_to_split()
+        while node_to_explode or node_to_split:
+            if node_to_explode:
+                node_to_explode.explode()
+            elif node_to_split:
+                node_to_split.split()
+
+            node_to_explode = self.find_node_to_explode()
+            node_to_split = self.find_node_to_split()
+
+    def split(self):
+        if type(self.left) == int and self.left > 9:
+            self.left = Node([self.left//2, math.ceil(self.left/2)])
+            self.left.parent = self
+        elif type(self.right) == int and self.right > 9:
+            self.right = Node([self.right//2, math.ceil(self.right/2)])
+            self.right.parent = self
+
+    def explode(self):
+        left_node, left_side = self.find_node_with_left_regular_number()
+        right_node, right_side = self.find_node_with_right_regular_number()
+        if left_node:
+            if left_side == 'left':
+                left_node.left += self.left
+            else:
+                left_node.right += self.left
+        if right_node:
+            if right_side == 'left':
+                right_node.left += self.right
+            else:
+                right_node.right += self.right
+
+        if self.parent.left == self:
+            self.parent.left = 0
+        else:
+            self.parent.right = 0
+
+    def magnitude(self):
+        if type(self.left) == int:
+            left_m = self.left * 3
+        else:
+            left_m = self.left.magnitude() * 3
+
+        if type(self.right) == int:
+            right_m = self.right * 2
+        else:
+            right_m = self.right.magnitude() * 2
+
+        return left_m + right_m
+
+    def find_node_to_explode(self):
+        S = deque([self])
+        while len(S):
+            n = S.popleft()
+            if n.is_bottom() and n.find_depth() > 4:
+                return n
+            if type(n.left) == Node:
+                S.append(n.left)
+            if type(n.right) == Node:
+                S.append(n.right)
+
+    def find_node_to_split(self):
+        if type(self.left) == int and self.left > 9:
+            return self
+
+        if type(self.left) == Node:
+            left = self.left.find_node_to_split()
+            if left:
+                return left
+
+        if type(self.right) == int and self.right > 9:
+            return self
+
+        if type(self.right) == Node:
+            right = self.right.find_node_to_split()
+            if right:
+                return right
+
+    def find_node_with_left_regular_number(self):
+        prev = self
+        node = self.parent
+        while node and node.left == prev:
+            prev = node
+            node = prev.parent
+        if not node:
+            return None, None
+
+        if type(node.left) == int:
+            return node, 'left'
+        node = node.left
+        while type(node.right) != int:
+            node = node.right
+
+        while type(node.right) != int:
+            node = node.right
+
+        return node, 'right'
+
+    def find_node_with_right_regular_number(self):
+        prev = self
+        node = self.parent
+        while node and node.right == prev:
+            prev = node
+            node = prev.parent
+        if not node:
+            return None, None
+
+        if type(node.right) == int:
+            return node, 'right'
+        node = node.right
+        while type(node.left) != int:
+            node = node.left
+
+        while type(node.left) != int:
+            node = node.left
+
+        return node, 'left'
+
+    def __repr__(self) -> str:
+        return f"[{self.left},{self.right}]"
+
+
+def solve1(lines):
+    node = None
+    left_node = Node(eval(lines[0]))
+    for line in lines[1:]:
+        node = Node()
+        right_node = Node(eval(line))
+
+        node.set_left(left_node)
+        node.set_right(right_node)
+        node.reduce()
+
+        left_node = node
+
+    return node.magnitude()
+
+
+def solve2(lines):
+    max_magnitude = 0
+
+    node = None
+    for line1 in lines:
+        for line2 in lines:
+            if line1 == line2:
+                continue
+
+            node1 = Node(eval(line1))
+            node2 = Node(eval(line2))
+
+            node = Node()
+            node.set_left(node1)
+            node.set_right(node2)
+
+            node.reduce()
+
+            max_magnitude = max(node.magnitude(), max_magnitude)
+
+    return max_magnitude
+
+
+if __name__ == "__main__":
+    with open('./input', 'r') as f:
+        lines = f.read().splitlines()
+        print(solve1(lines))
+        print(solve2(lines))

18/2.py

@@ -0,0 +1,9 @@
+
+def solve(lines):
+    return lines
+
+
+if __name__ == "__main__":
+    with open('./input', 'r') as f:
+        lines = f.read().splitlines()
+        print(solve(lines))

18/input

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