[2025] Cleanup day 8

Author: connorslade

aoc_2025/src/day_08.rs

@@ -7,75 +7,56 @@ use common::{Answer, solution};
 use itertools::Itertools;
 use nd_vec::{Vec3, vector};
 
+type Pos = Vec3<i64>;
+type Pair = (Pos, Pos);
+
 solution!("Playground", 8);
 
 fn part_a(input: &str) -> Answer {
-    let boxes = input
-        .lines()
-        .map(|x| {
-            let mut coords = x.split(',').map(|x| x.parse::<i64>().unwrap());
-            vector!(
-                coords.next().unwrap(),
-                coords.next().unwrap(),
-                coords.next().unwrap()
-            )
-        })
-        .collect::<Vec<_>>();
-
-    let mut closest_paris = boxes
-        .iter()
-        .combinations(2)
-        .map(|x| ((*x[0] - *x[1]).magnitude_squared(), (*x[0], *x[1])))
-        .collect::<Vec<_>>();
-    closest_paris.sort_by_key(|x| x.0);
-
-    let mut connections = HashMap::new();
-    for (_dist, (a, b)) in closest_paris.iter().take(1000) {
-        println!("connecting {a:?} and {b:?}");
-
-        connections.entry(*a).or_insert(HashSet::new()).insert(*b);
-        connections.entry(*b).or_insert(HashSet::new()).insert(*a);
-    }
-
-    // get the length of every unique sub graph
-    fn subgraph_size(
-        connections: &HashMap<Vec3<i64>, HashSet<Vec3<i64>>>,
-        seen: &mut HashSet<Vec3<i64>>,
-        node: Vec3<i64>,
-    ) -> u64 {
-        if !seen.insert(node) {
-            return 0;
-        }
-
-        let children = &connections[&node];
+    let (boxes, closest_paris) = parse(input);
 
-        let mut out = 1;
-        for child in children {
-            out += subgraph_size(connections, seen, *child);
-        }
-
-        out
+    let mut connections = HashMap::<_, Vec<_>>::new();
+    let n = [1000, 10][cfg!(test) as usize];
+    for (_dist, (a, b)) in closest_paris.iter().take(n) {
+        connections.entry(*a).or_default().push(*b);
+        connections.entry(*b).or_default().push(*a);
     }
 
     let mut seen = HashSet::new();
     let mut sizes = Vec::new();
     for start in connections.keys() {
         let size = subgraph_size(&connections, &mut seen, *start);
-        if size > 0 {
-            sizes.push(size);
-            println!("{start:?} is in a {size} node circuit");
-        }
+        (size > 0).then(|| sizes.push(size));
     }
 
     let unconnected = boxes.iter().filter(|x| !seen.contains(x)).count();
     sizes.extend(repeat_n(1, unconnected));
-
     sizes.sort();
 
     sizes.iter().rev().take(3).product::<u64>().into()
 }
 
 fn part_b(input: &str) -> Answer {
+    let (boxes, closest_paris) = parse(input);
+
+    let mut connections = HashMap::<_, Vec<_>>::new();
+    for (_dist, (a, b)) in closest_paris.iter() {
+        connections.entry(*a).or_default().push(*b);
+        connections.entry(*b).or_default().push(*a);
+
+        let mut seen = HashSet::new();
+        for start in connections.keys() {
+            let size = subgraph_size(&connections, &mut seen, *start);
+            if size == boxes.len() as u64 {
+                return (a.x() * b.x()).into();
+            }
+        }
+    }
+
+    ().into()
+}
+
+fn parse(input: &str) -> (Vec<Pos>, Vec<(i64, Pair)>) {
     let boxes = input
         .lines()
         .map(|x| {
@@ -95,46 +76,24 @@ fn part_b(input: &str) -> Answer {
         .collect::<Vec<_>>();
     closest_paris.sort_by_key(|x| x.0);
 
-    let mut connections = HashMap::new();
-    for (_dist, (a, b)) in closest_paris.iter() {
-        connections.entry(*a).or_insert(HashSet::new()).insert(*b);
-        connections.entry(*b).or_insert(HashSet::new()).insert(*a);
-
-        //
-
-        let mut seen = HashSet::new();
-        for start in connections.keys() {
-            subgraph_size(&connections, &mut seen, *start);
-        }
-
-        let unconnected = boxes.iter().filter(|x| !seen.contains(x)).count();
+    (boxes, closest_paris)
+}
 
-        if unconnected == 0 {
-            return (a.x() * b.x()).into();
-        }
+fn subgraph_size(
+    connections: &HashMap<Vec3<i64>, Vec<Vec3<i64>>>,
+    seen: &mut HashSet<Vec3<i64>>,
+    node: Vec3<i64>,
+) -> u64 {
+    if !seen.insert(node) {
+        return 0;
     }
 
-    // get the length of every unique sub graph
-    fn subgraph_size(
-        connections: &HashMap<Vec3<i64>, HashSet<Vec3<i64>>>,
-        seen: &mut HashSet<Vec3<i64>>,
-        node: Vec3<i64>,
-    ) -> u64 {
-        if !seen.insert(node) {
-            return 0;
-        }
-
-        let children = &connections[&node];
-
-        let mut out = 1;
-        for child in children {
-            out += subgraph_size(connections, seen, *child);
-        }
-
-        out
+    let mut out = 1;
+    for child in &connections[&node] {
+        out += subgraph_size(connections, seen, *child);
     }
 
-    ().into()
+    out
 }
 
 #[cfg(test)]