feat: aoc 2025 day 8 solution + tests

mbrickerd · mbrickerd · commit 3fbf30152117 · 2025-12-08T12:16:21.000+01:00
diff --git a/_2025/solutions/day08.py b/_2025/solutions/day08.py
@@ -0,0 +1,203 @@
+"""Day 8: Playground
+
+This module provides the solution for Advent of Code 2025 - Day 8.
+
+It simulates connecting electrical junction boxes in 3D space by distance
+to form circuits, using union-find to track component sizes as connections
+are added in order of increasing Euclidean distance.
+
+The module contains a DSU (Disjoint Set Union) dataclass for efficient
+circuit merging and a Solution class that inherits from SolutionBase.
+"""
+
+from dataclasses import dataclass
+import math
+from typing import Self
+
+from aoc.models.base import SolutionBase
+
+
+@dataclass
+class DSU:
+    """Disjoint set union structure for tracking junction box circuits.
+
+    Maintains parent and component size arrays to efficiently perform
+    union-find operations with path compression and union by size for
+    optimal circuit merging.
+    """
+
+    parent: list[int]
+    size: list[int]
+
+    @classmethod
+    def with_n(cls, n: int) -> Self:
+        """Create DSU with n singleton junction box circuits.
+
+        Args:
+            n: Number of junction boxes
+
+        Returns
+        -------
+            DSU: New instance with each box in its own circuit
+        """
+        return cls(parent=list(range(n)), size=[1] * n)
+
+    def find(self, x: int) -> int:
+        """Find root representative of junction box x's circuit with path compression."""
+        while self.parent[x] != x:
+            self.parent[x] = self.parent[self.parent[x]]
+            x = self.parent[x]
+
+        return x
+
+    def union(self, a: int, b: int) -> bool:
+        """Merge circuits containing junction boxes a and b.
+
+        Args:
+            a: First junction box index
+            b: Second junction box index
+
+        Returns
+        -------
+            bool: True if circuits were merged, False if already connected
+        """
+        ra, rb = self.find(a), self.find(b)
+        if ra == rb:
+            return False
+
+        if self.size[ra] < self.size[rb]:
+            ra, rb = rb, ra
+
+        self.parent[rb] = ra
+        self.size[ra] += self.size[rb]
+        return True
+
+
+class Solution(SolutionBase):
+    """Connect junction boxes by shortest distance to form electrical circuits.
+
+    This solution connects junction boxes in 3D space using strings of lights,
+    always connecting the closest unconnected pair. Uses Kruskal's algorithm
+    approach with Euclidean distance sorting and DSU for cycle detection.
+
+    Part 1: After 1000 shortest connections (10 for examples), multiply sizes
+    of the three largest circuits. Part 2: Connect until single circuit, return
+    product of X-coordinates of final merge pair.
+    """
+
+    def build_edges(self, boxes: list[list[int]]) -> list[tuple[float, int, int]]:
+        """Compute all pairwise Euclidean distances between junction boxes.
+
+        Args:
+            boxes: List of 3D coordinates [x, y, z] for each junction box
+
+        Returns
+        -------
+            list[tuple[float, int, int]]: Sorted edges (distance, box_i, box_j)
+        """
+        N = len(boxes)  # noqa: N806
+        edges: list[tuple[float, int, int]] = []
+        for i in range(N):
+            for j in range(i + 1, N):
+                d = math.dist(boxes[i], boxes[j])
+                edges.append((d, i, j))
+
+        edges.sort(key=lambda e: e[0])
+        return edges
+
+    def find_largest_circuits(
+        self,
+        boxes: list[list[int]],
+        pairs_to_process: int,
+    ) -> int:
+        """Process shortest connections and return product of 3 largest circuits.
+
+        Args:
+            boxes: List of 3D junction box coordinates
+            pairs_to_process: Number of shortest connections to make (1000 for real input)
+
+        Returns
+        -------
+            int: Product of sizes of three largest circuits after specified connections
+        """
+        N = len(boxes)  # noqa: N806
+        edges = self.build_edges(boxes)
+        dsu = DSU.with_n(N)
+
+        for processed_pairs, (_, u, v) in enumerate(edges, start=1):
+            dsu.union(u, v)
+            if processed_pairs == pairs_to_process:
+                break
+
+        comp_sizes: dict[int, int] = {}
+        for i in range(N):
+            root = dsu.find(i)
+            comp_sizes[root] = comp_sizes.get(root, 0) + 1
+
+        sizes = sorted(comp_sizes.values(), reverse=True)
+        a, b, c = sizes[0], sizes[1], sizes[2]
+        return a * b * c
+
+    def last_merge_x_product(self, boxes: list[list[int]]) -> int:
+        """Return X-coordinate product of final pair forming single circuit.
+
+        Args:
+            boxes: List of 3D junction box coordinates
+
+        Returns
+        -------
+            int: Product of X coordinates of last two boxes connected
+
+        Raises
+        ------
+            ValueError: If boxes don't form a single connected circuit
+        """
+        N = len(boxes)  # noqa: N806
+        edges = self.build_edges(boxes)
+        dsu = DSU.with_n(N)
+
+        components = N
+        last_u: int | None = None
+        last_v: int | None = None
+
+        for _, u, v in edges:
+            if dsu.union(u, v):
+                components -= 1
+                last_u, last_v = u, v
+                if components == 1:
+                    x1, x2 = boxes[last_u][0], boxes[last_v][0]
+                    return x1 * x2
+
+        err_msg = "Did not reach a single circuit"
+        raise ValueError(err_msg)
+
+    def part1(self, data: list[str]) -> int:
+        """Multiply sizes of 3 largest circuits after 1000 shortest connections.
+
+        Uses small input (10 connections) for examples, full input (1000 connections).
+
+        Args:
+            data: List of 'X,Y,Z' coordinate strings
+
+        Returns
+        -------
+            int: Product of sizes of three largest circuits after cutoff
+        """
+        boxes = [list(map(int, line.split(","))) for line in data]
+        pairs = 10 if len(boxes) <= 20 else 1000
+        return self.find_largest_circuits(boxes, pairs_to_process=pairs)
+
+    def part2(self, data: list[str]) -> int:
+        """X-coordinate product of final pair connecting all junction boxes.
+
+        Continues connecting closest pairs until single circuit formed.
+
+        Args:
+            data: List of 'X,Y,Z' coordinate strings
+
+        Returns
+        -------
+            int: Product of X coordinates from final successful connection
+        """
+        boxes = [list(map(int, line.split(","))) for line in data]
+        return self.last_merge_x_product(boxes)
diff --git a/_2025/tests/data/day08/test_01_input.txt b/_2025/tests/data/day08/test_01_input.txt
@@ -0,0 +1,20 @@
+162,817,812
+57,618,57
+906,360,560
+592,479,940
+352,342,300
+466,668,158
+542,29,236
+431,825,988
+739,650,466
+52,470,668
+216,146,977
+819,987,18
+117,168,530
+805,96,715
+346,949,466
+970,615,88
+941,993,340
+862,61,35
+984,92,344
+425,690,689
diff --git a/_2025/tests/data/day08/test_02_input.txt b/_2025/tests/data/day08/test_02_input.txt
@@ -0,0 +1,20 @@
+162,817,812
+57,618,57
+906,360,560
+592,479,940
+352,342,300
+466,668,158
+542,29,236
+431,825,988
+739,650,466
+52,470,668
+216,146,977
+819,987,18
+117,168,530
+805,96,715
+346,949,466
+970,615,88
+941,993,340
+862,61,35
+984,92,344
+425,690,689
diff --git a/_2025/tests/test_08.py b/_2025/tests/test_08.py
@@ -0,0 +1,41 @@
+"""Test suite for Day 8: Playground
+
+This module contains tests for the Day 8 solution, which connects junction
+boxes in 3D space by shortest distance to form electrical circuits. The tests
+verify:
+
+1. Part 1: Product of sizes of three largest circuits after 1000 shortest connections
+2. Part 2: X-coordinate product of final pair forming single circuit
+"""
+
+from aoc.models.tester import TestSolutionUtility
+
+
+def test_day08_part1() -> None:
+    """Test product of three largest circuits after fixed connections.
+
+    This test runs the solution for Part 1 of the puzzle against the
+    provided test input and compares the result with the expected output.
+    """
+    TestSolutionUtility.run_test(
+        year=2025,
+        day=8,
+        is_raw=False,
+        part_num=1,
+        expected=40,
+    )
+
+
+def test_day08_part2() -> None:
+    """Test X-coordinate product of final merge into single circuit.
+
+    This test runs the solution for Part 2 of the puzzle against the
+    provided test input and compares the result with the expected output.
+    """
+    TestSolutionUtility.run_test(
+        year=2025,
+        day=8,
+        is_raw=False,
+        part_num=2,
+        expected=25272,
+    )
