Year 2025 Day 8

Author: maneatingape

README.md

@@ -84,6 +84,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 5 | [Cafeteria](https://adventofcode.com/2025/day/5) | [Source](src/year2025/day05.rs) | 20 |
 | 6 | [Trash Compactor](https://adventofcode.com/2025/day/6) | [Source](src/year2025/day06.rs) | 20 |
 | 7 | [Laboratories](https://adventofcode.com/2025/day/7) | [Source](src/year2025/day07.rs) | 5 |
+| 8 | [Playground](https://adventofcode.com/2025/day/8) | [Source](src/year2025/day08.rs) | 12000 |
 
 ## 2024
 

benches/benchmark.rs

@@ -95,5 +95,5 @@ benchmark!(year2024
 );
 
 benchmark!(year2025
-    day01, day02, day03, day04, day05, day06, day07
+    day01, day02, day03, day04, day05, day06, day07, day08
 );

src/lib.rs

@@ -74,5 +74,5 @@ library!(year2024 "Locate the Chief Historian in time for the big Christmas slei
 );
 
 library!(year2025 "Finish the North Pole decorations in time for Christmas."
-    day01, day02, day03, day04, day05, day06, day07
+    day01, day02, day03, day04, day05, day06, day07, day08
 );

src/main.rs

@@ -141,5 +141,5 @@ run!(year2024
 );
 
 run!(year2025
-    day01, day02, day03, day04, day05, day06, day07
+    day01, day02, day03, day04, day05, day06, day07, day08
 );

src/year2025/day08.rs

@@ -0,0 +1,85 @@
+//! # Playground
+use crate::util::iter::*;
+use crate::util::parse::*;
+
+type Box = [u64; 3];
+type Pair = (usize, usize, u64);
+type Input = (Vec<Box>, Vec<Pair>);
+
+struct Node {
+    parent: usize,
+    size: usize,
+}
+
+pub fn parse(input: &str) -> Input {
+    let boxes: Vec<_> = input.iter_unsigned::<u64>().chunk::<3>().collect();
+    let mut pairs = Vec::with_capacity(boxes.len() * (boxes.len() - 1));
+
+    for (i, &v1) in boxes.iter().enumerate() {
+        for (j, &v2) in boxes.iter().enumerate().skip(i + 1) {
+            let dx = v1[0].abs_diff(v2[0]);
+            let dy = v1[1].abs_diff(v2[1]);
+            let dz = v1[2].abs_diff(v2[2]);
+            let distance = dx * dx + dy * dy + dz * dz;
+            pairs.push((i, j, distance));
+        }
+    }
+
+    pairs.sort_unstable_by_key(|&(.., distance)| distance);
+    (boxes, pairs)
+}
+
+pub fn part1(input: &Input) -> usize {
+    part1_testable(input, 1000)
+}
+
+pub fn part1_testable(input: &Input, limit: usize) -> usize {
+    let (boxes, pairs) = input;
+    let mut nodes: Vec<_> = (0..boxes.len()).map(|i| Node { parent: i, size: 1 }).collect();
+
+    for &(i, j, ..) in pairs.iter().take(limit) {
+        union(&mut nodes, i, j);
+    }
+
+    nodes.sort_unstable_by_key(|node| node.size);
+    nodes.iter().rev().take(3).map(|node| node.size).product()
+}
+
+pub fn part2(input: &Input) -> u64 {
+    let (boxes, pairs) = input;
+    let mut nodes: Vec<_> = (0..boxes.len()).map(|i| Node { parent: i, size: 1 }).collect();
+
+    for &(i, j, ..) in pairs {
+        if union(&mut nodes, i, j) == boxes.len() {
+            return boxes[i][0] * boxes[j][0];
+        }
+    }
+
+    unreachable!()
+}
+
+fn find(set: &mut [Node], mut x: usize) -> usize {
+    while set[x].parent != x {
+        let parent = set[x].parent;
+        (x, set[x].parent) = (parent, set[parent].parent);
+    }
+
+    x
+}
+
+fn union(set: &mut [Node], mut x: usize, mut y: usize) -> usize {
+    x = find(set, x);
+    y = find(set, y);
+
+    if x == y {
+        return set[x].size;
+    }
+
+    if set[x].size < set[y].size {
+        (x, y) = (y, x);
+    }
+
+    set[y].parent = x;
+    set[x].size += set[y].size;
+    set[x].size
+}

tests/test.rs

@@ -87,5 +87,5 @@ test!(year2024
 );
 
 test!(year2025
-    day01, day02, day03, day04, day05, day06, day07
+    day01, day02, day03, day04, day05, day06, day07, day08
 );

tests/year2025/day08.rs

@@ -0,0 +1,35 @@
+use aoc::year2025::day08::*;
+
+const EXAMPLE: &str = "\
+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";
+
+#[test]
+fn part1_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part1_testable(&input, 10), 40);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part2(&input), 25272);
+}