* Add 2025

Author: mkopec87

src/2025/08/2025_08.py

@@ -0,0 +1,52 @@
+import math
+from itertools import combinations
+from operator import itemgetter
+from typing import NamedTuple
+
+from scipy._lib._disjoint_set import DisjointSet
+
+from src.utils.data import load_data
+from src.utils.submission import submit_or_print
+
+
+class Box(NamedTuple):
+    x: int
+    y: int
+    z: int
+
+    def distance(self, other):
+        return math.dist([self.x, self.y, self.z], [other.x, other.y, other.z])
+
+
+def main(debug: bool) -> None:
+    input_data = load_data(debug)
+
+    boxes = [Box(*map(int, line.split(","))) for line in input_data.splitlines()]
+    print(len(boxes), "boxes")
+
+    pair_to_distance = {}
+    for box1, box2 in combinations(boxes, 2):
+        pair_to_distance[(box1, box2)] = box1.distance(box2)
+    circuits = DisjointSet(elements=boxes)
+    for (box1, box2), distance in sorted(pair_to_distance.items(), key=itemgetter(1))[
+        :1000
+    ]:
+        circuits.merge(box1, box2)
+    result_part1 = math.prod(
+        sorted([len(s) for s in circuits.subsets()], reverse=True)[:3]
+    )
+
+    circuits = DisjointSet(elements=boxes)
+    for (box1, box2), distance in sorted(pair_to_distance.items(), key=itemgetter(1)):
+        circuits.merge(box1, box2)
+        if circuits.n_subsets == 1:
+            result_part2 = box1.x * box2.x
+            break
+
+    submit_or_print(result_part1, result_part2, debug)
+
+
+if __name__ == "__main__":
+    debug_mode = True
+    # debug_mode = False
+    main(debug_mode)

src/2025/09/2025_09.py

@@ -0,0 +1,110 @@
+from collections import namedtuple
+from itertools import combinations, product
+from matplotlib.path import Path
+from src.utils.data import load_data
+from src.utils.submission import submit_or_print
+
+Point = namedtuple("Point", ["x", "y"])
+Segment = namedtuple("Segment", ["start", "end"])
+
+
+def area(point1: Point, point2: Point) -> int:
+    return (abs(point1.x - point2.x) + 1) * (abs(point1.y - point2.y) + 1)
+
+
+def no_points_inside(point1, point2, points):
+    x1, x2 = point1.x, point2.x
+    if x1 > x2:
+        x1, x2 = x2, x1
+    y1, y2 = point1.y, point2.y
+    if y1 > y2:
+        y1, y2 = y2, y1
+
+    for point in points:
+        if x1 < point.x < x2 and y1 < point.y < y2:
+            return False
+    return True
+
+
+def polygon(points):
+    return [
+        Segment(point_from, point_to)
+        for point_from, point_to in zip(points, points[1:] + points[0:1])
+    ]
+
+
+def ccw(A, B, C):
+    return (C.y - A.y) * (B.x - A.x) > (B.y - A.y) * (C.x - A.x)
+
+
+def intersect(A, B, C, D):
+    return ccw(A, C, D) != ccw(B, C, D) and ccw(A, B, C) != ccw(A, B, D)
+
+
+def intersects(lines1, lines2):
+    print("checking...")
+    print(lines1)
+    print(lines2)
+
+    for line1, line2 in product(lines1, lines2):
+        if intersect(line1.start, line1.end, line2.start, line2.end):
+            print("intersect!")
+            print(line1, line2)
+            return True
+    print("no intersections")
+    return False
+
+
+def rectangle(point1, point2):
+    xs = sorted([point1.x, point2.x])
+    ys = sorted([point1.y, point2.y])
+    points = [
+        Point(xs[0], ys[0]),
+        Point(xs[0], ys[1]),
+        Point(xs[1], ys[1]),
+        Point(xs[1], ys[0]),
+    ]
+    return polygon(points)
+
+
+def main(debug: bool) -> None:
+    input_data = load_data(debug)
+
+    points = [Point(*map(int, line.split(","))) for line in input_data.splitlines()]
+    print(len(points), "points")
+
+    result_part1 = max(
+        area(point1, point2) for point1, point2 in combinations(points, 2)
+    )
+
+    polygon = Path(points)
+    print(polygon)
+    result_part2 = max(
+        area(point1, point2)
+        for point1, point2 in combinations(points, 2)
+        if not polygon.intersects_path(Path(rectangle(point1, point2)))
+    )
+
+    print(polygon.contains_point((5, 5)))
+
+    result_part2 = None
+    xs = sorted({p.x for p in points})
+    ys = sorted({p.y for p in points})
+
+    print("Xs:", min(xs), max(xs), "all", xs)
+    print("Ys:", min(ys), max(ys), "all", ys)
+
+    x_map = {x: i for i, x in enumerate(xs)}
+    y_map = {y: i for i, y in enumerate(ys)}
+
+    mapped_points = [Point(x_map[p.x], y_map[p.y]) for p in points]
+    print(points)
+    print(mapped_points)
+
+    submit_or_print(result_part1, result_part2, debug)
+
+
+if __name__ == "__main__":
+    debug_mode = True
+    # debug_mode = False
+    main(debug_mode)

src/2025/10/2025_10.py

@@ -0,0 +1,120 @@
+import re
+from collections import deque
+from functools import reduce
+from itertools import repeat
+from operator import add
+from typing import NamedTuple
+from z3 import Solver, Int, IntVal
+from tqdm import tqdm
+
+from src.utils.data import load_data
+from src.utils.submission import submit_or_print
+
+
+class State(NamedTuple):
+    status: tuple[int, ...]
+    buttons: set[set[int]]
+
+
+class Node(NamedTuple):
+    state: State
+    depth: int
+
+
+def main(debug: bool) -> None:
+    input_data = load_data(debug)
+
+    result_part1 = 0
+    for line in tqdm(input_data.splitlines()):
+        m = re.match(r"\[(?P<target>[.#]+)\] (?P<buttons>(\([0-9,]+\) )+)", line)
+        target = tuple(c == "#" for c in m.group("target"))
+        buttons = frozenset(
+            [
+                frozenset(map(int, s[1:-1].split(",")))
+                for s in m.group("buttons").strip().split(" ")
+            ]
+        )
+        result_part1 += solve(target, buttons)
+
+    result_part2 = 0
+    for line in tqdm(input_data.splitlines()):
+        m = re.match(
+            r"\[(?P<target>[.#]+)\] (?P<buttons>(\([0-9,]+\) )+){(?P<joltage>[0-9,]+)}",
+            line,
+        )
+        target = tuple(map(int, m.group("joltage").split(",")))
+        buttons = list(
+            [
+                frozenset(map(int, s[1:-1].split(",")))
+                for s in m.group("buttons").strip().split(" ")
+            ]
+        )
+        result_part2 += solve_part2(target, buttons)
+
+    submit_or_print(result_part1, result_part2, debug)
+
+
+def solve(target: tuple[bool, ...], buttons: set[set[int]]):
+    queue: deque[Node] = deque(
+        [
+            Node(
+                state=State(status=tuple(repeat(0, len(target))), buttons=buttons),
+                depth=0,
+            )
+        ]
+    )
+
+    visited_states = set()
+    while queue:
+        node = queue.popleft()
+        state = node.state
+        if state in visited_states:
+            continue
+        visited_states.add(state)
+        if state.status == target:
+            return node.depth
+
+        for button in state.buttons:
+            new_state = State(
+                status=tuple(
+                    int(not s) if i in button else s for i, s in enumerate(state.status)
+                ),
+                buttons=frozenset(b for b in state.buttons if b != button),
+            )
+            queue.append(
+                Node(
+                    new_state,
+                    depth=node.depth + 1,
+                )
+            )
+    return -1
+
+
+def solve_part2(target, buttons):
+    presses = max(target)
+
+    while True:
+        s = Solver()
+        button_vars = [Int(i) for i in range(len(buttons))]
+        for light_nr, target_joltage in enumerate(target):
+            target_joltage_constant = IntVal(target_joltage)
+            parts = [
+                button_vars[button_index]
+                for button_index, button in enumerate(buttons)
+                if light_nr in button
+            ]
+            s.add(target_joltage_constant == reduce(add, parts))
+        for i in range(len(buttons)):
+            s.add(button_vars[i] >= 0)
+        total_button_pushes = IntVal(presses)
+        s.add(total_button_pushes == reduce(add, button_vars))
+        if str(s.check()) == "sat":
+            return presses
+        else:
+            presses += 1
+
+
+if __name__ == "__main__":
+    debug_mode = True
+    debug_mode = False
+    main(debug_mode)

src/2025/11/2025_11.py

@@ -0,0 +1,73 @@
+from collections import deque
+
+import networkx as nx
+from tqdm import tqdm
+
+from src.utils.data import load_data
+from src.utils.submission import submit_or_print
+
+
+def main(debug: bool) -> None:
+    input_data = load_data(debug)
+
+    source_to_targets = {}
+    for line in input_data.splitlines():
+        s = line.split(":")
+        source = s[0].strip()
+        targets = set(s[1].strip().split(" "))
+        source_to_targets[source] = targets
+
+    graph = nx.DiGraph()
+    for source, targets in source_to_targets.items():
+        for target in targets:
+            graph.add_edge(source, target)
+
+    # result_part1 = paths_count(graph, "you", "out")
+
+    source = "svr"
+    target = "out"
+
+    graphs = deque([graph])
+    while graphs:
+        g = graphs.pop()
+        cut_nodes = nx.minimum_node_cut(g, source, target)
+        print(g, len(cut_nodes), cut_nodes)
+        if len(cut_nodes) < 10:
+            g.remove_nodes_from(cut_nodes)
+            graphs.extend(
+                [
+                    g.subgraph(c).copy()
+                    for c in nx.connected_components(g.to_undirected())
+                ]
+            )
+
+    #
+    # inter_fft = paths_count(graph, "fft", "dac")
+    # inter_dac = paths_count(graph, "dac", "fft")
+    # print(inter_fft, inter_dac)
+    #
+    # fft = paths_count(graph, "svr", "fft")
+    # dac = paths_count(graph, "svr", "dac")
+    # print(fft, dac)
+    #
+    # fft_out = paths_count(graph, "fft", "out")
+    # dac_out = paths_count(graph, "dac", "out")
+    # print(fft_out, dac_out)
+
+    result_part1 = None
+    result_part2 = None
+
+    # nx.draw_networkx(graph)
+    # plt.show()
+
+    submit_or_print(result_part1, result_part2, debug)
+
+
+def paths_count(graph, start, end) -> int:
+    return sum(tqdm(1 for _ in nx.all_simple_paths(graph, start, end)))
+
+
+if __name__ == "__main__":
+    debug_mode = True
+    debug_mode = False
+    main(debug_mode)

src/2025/12/2025_12.py

@@ -0,0 +1,40 @@
+import re
+from itertools import chain
+
+
+from src.utils.data import load_data
+from src.utils.submission import submit_or_print
+
+
+def main(debug: bool) -> None:
+    input_data = load_data(debug)
+
+    shape_nr_to_size = {}
+    result_part1 = 0
+    for block in input_data.split("\n\n"):
+        if m := re.match(r"([0-9]+):", block):
+            shape_nr = int(m.group(1))
+            shape = [list(l) for l in block.splitlines()[1:]]
+            size = sum(1 for c in chain.from_iterable(shape) if c == "#")
+            shape_nr_to_size[shape_nr] = size
+        else:
+            for line in block.splitlines():
+                m = re.match(r"([0-9]+)x([0-9]+):([0-9 ]+)", line)
+                area = int(m.group(1)) * int(m.group(2))
+                counts = tuple(map(int, m.group(3).strip().split(" ")))
+                required_area = sum(
+                    shape_nr_to_size[i] * c for i, c in enumerate(counts)
+                )
+                print(area, required_area, counts)
+                result_part1 += 1 if required_area <= area else 0
+    print(shape_nr_to_size)
+
+    result_part2 = None
+
+    submit_or_print(result_part1, result_part2, debug)
+
+
+if __name__ == "__main__":
+    debug_mode = True
+    debug_mode = False
+    main(debug_mode)