chore: y2025::day_08

Author: clechasseur

.run/run_aoc.run.xml

@@ -1,7 +1,7 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="run_aoc" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
     <option name="buildProfileId" value="dev" />
-    <option name="command" value="run --package aoclp_solutions --bin aoclp_solutions -- --year 2025 --day 7" />
+    <option name="command" value="run --package aoclp_solutions --bin aoclp_solutions -- --year 2025 --day 8" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <envs />
     <option name="emulateTerminal" value="true" />

aoclp/src/positioning/pt_3d.rs

@@ -4,6 +4,8 @@ use std::ops::{Add, AddAssign, RangeBounds, Sub, SubAssign};
 use std::str::FromStr;
 use std::sync::OnceLock;
 
+use num::{cast, NumCast};
+
 use crate::captures::CapturesHelper;
 use crate::num::{zero, Signed, Zero};
 use crate::regex::Regex;
@@ -26,6 +28,7 @@ impl<T> Pt3d<T>
 where
     T: PartialOrd,
 {
+    /// Checks if this [`Pt3d`] is within the given bounds.
     pub fn within<XR, YR, ZR>(&self, x_bounds: XR, y_bounds: YR, z_bounds: ZR) -> bool
     where
         XR: RangeBounds<T>,
@@ -36,6 +39,29 @@ where
     }
 }
 
+impl<T> Pt3d<T>
+where
+    T: NumCast,
+{
+    /// Casts this [`Pt3d`] to another numeric type.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use aoclp::positioning::pt_3d::Pt3d;
+    ///
+    /// let p: Pt3d<i32> = Pt3d::new(42, 23, 11);
+    /// let fp: Pt3d<f64> = p.cast();
+    /// assert_eq!(Pt3d::new(42.0, 23.0, 11.0), fp);
+    /// ```
+    pub fn cast<U>(self) -> Pt3d<U>
+    where
+        U: NumCast,
+    {
+        Pt3d::new(cast(self.x).unwrap(), cast(self.y).unwrap(), cast(self.z).unwrap())
+    }
+}
+
 impl<T, U, V, W> From<(U, V, W)> for Pt3d<T>
 where
     U: Into<T>,
@@ -157,3 +183,14 @@ where
 {
     (a.x - b.x).abs() + (a.y - b.y).abs() + (a.z - b.z).abs()
 }
+
+/// Returns the [Euclidian distance] between two points in 3D space.
+///
+/// [Euclidian distance]: https://en.wikipedia.org/wiki/Euclidean_distance
+pub fn euclidian<T>(a: Pt3d<T>, b: Pt3d<T>) -> f64
+where
+    T: NumCast,
+{
+    let (a, b) = (a.cast::<f64>(), b.cast::<f64>());
+    ((a.x - b.x).abs().powi(2) + (a.y - b.y).abs().powi(2) + (a.z - b.z).abs().powi(2)).sqrt()
+}

aoclp_solutions/src/lib.rs

@@ -11,5 +11,5 @@ pub mod y2025;
 build_solvers! {
     { 2017, [01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25] },
     { 2024, [01, 02, 03, 04, 05, 06, 07, 08, 09, 10] },
-    { 2025, [01, 02, 03, 04, 05, 06, 07] }
+    { 2025, [01, 02, 03, 04, 05, 06, 07, 08] }
 }

aoclp_solutions/src/y2025/day_08.rs

@@ -0,0 +1,71 @@
+use std::collections::HashMap;
+
+use aoclp::num::Zero;
+use aoclp::positioning::pt_3d::{euclidian, Pt3d};
+use aoclp::solvers_impl::input::safe_get_input_as_many;
+use itertools::Itertools;
+
+pub fn part_1() -> usize {
+    circuits(false)
+        .1
+        .values()
+        .sorted_unstable_by(|a, b| a.cmp(b).reverse())
+        .take(3)
+        .product()
+}
+
+pub fn part_2() -> i64 {
+    let (_, _, (a, b)) = circuits(true);
+    a.x * b.x
+}
+
+fn circuits(all: bool) -> (HashMap<Pt3d, usize>, HashMap<usize, usize>, (Pt3d, Pt3d)) {
+    let boxes = input();
+
+    let mut circuit_id = 0usize;
+    let mut circuits = HashMap::new();
+    let mut circuit_sizes = HashMap::new();
+    let mut last_pair = (Pt3d::zero(), Pt3d::zero());
+    boxes
+        .into_iter()
+        .array_combinations()
+        .filter(|&[a, b]| a != b)
+        .map(|[a, b]| (a, b, euclidian(a, b)))
+        .sorted_unstable_by(|(_, _, a), (_, _, b)| a.partial_cmp(b).unwrap())
+        .take(if all { 1_000_000 } else { 1_000 })
+        .for_each(|(a, b, _)| match (circuits.get(&a).copied(), circuits.get(&b).copied()) {
+            (Some(a_id), Some(b_id)) if a_id == b_id => (),
+            (Some(a_id), Some(b_id)) => {
+                circuits.iter_mut().for_each(|(_, id)| {
+                    if *id == b_id {
+                        *id = a_id;
+                    }
+                });
+
+                let b_size = circuit_sizes.remove(&b_id).unwrap();
+                *circuit_sizes.get_mut(&a_id).unwrap() += b_size;
+
+                last_pair = (a, b);
+            },
+            (Some(a_id), None) => {
+                circuits.insert(b, a_id);
+                *circuit_sizes.get_mut(&a_id).unwrap() += 1;
+            },
+            (None, Some(b_id)) => {
+                circuits.insert(a, b_id);
+                *circuit_sizes.get_mut(&b_id).unwrap() += 1;
+            },
+            (None, None) => {
+                circuits.insert(a, circuit_id);
+                circuits.insert(b, circuit_id);
+                circuit_sizes.insert(circuit_id, 2usize);
+                circuit_id += 1;
+            },
+        });
+
+    (circuits, circuit_sizes, last_pair)
+}
+
+fn input() -> Vec<Pt3d> {
+    safe_get_input_as_many(2025, 8)
+}

aoclp_solutions/src/y2025/mod.rs

@@ -5,3 +5,4 @@ pub mod day_04;
 pub mod day_05;
 pub mod day_06;
 pub mod day_07;
+pub mod day_08;