feat(08/2025): solve first part

Author: manhunto

readme.md

@@ -18,7 +18,7 @@
 | [Day 5: Cafeteria](src/solutions/year2025/day05.rs)           |   ⭐⭐   |            0.275 |            0.469 |
 | [Day 6: Trash Compactor](src/solutions/year2025/day06.rs)     |   ⭐⭐   |            0.117 |            2.577 |
 | [Day 7: Laboratories](src/solutions/year2025/day07.rs)        |   ⭐⭐   |            6.711 |            5.789 |
-| [Day 8: Playground](src/solutions/year2025/day08.rs)          |        |                - |                - |
+| [Day 8: Playground](src/solutions/year2025/day08.rs)          |   ⭐    |           46.993 |                - |
 
 # 2024
 

src/solutions/mod.rs

@@ -22,7 +22,7 @@ pub fn solution(puzzle_day: PuzzleDay) -> Box<dyn Solution> {
             5 => Box::new(year2025::day05::Day05),
             6 => Box::new(year2025::day06::Day06),
             7 => Box::new(year2025::day07::Day07),
-            8 => Box::new(year2025::day08::Day08),
+            8 => Box::new(year2025::day08::Day08::default()),
             _ => panic!("Day not exist"),
         },
         Year::Year2024 => match i {

src/solutions/year2025/day08.rs

@@ -1,31 +1,135 @@
 use crate::solutions::Solution;
+use crate::utils::point3d::Point3D;
+use itertools::Itertools;
 
-pub struct Day08;
+const INPUT_CONNECTIONS: u64 = 1_000;
+
+type Pair = (Point3D, Point3D);
+
+pub struct Day08 {
+    connections: u64,
+}
 
 impl Solution for Day08 {
-    fn part_one(&self, _input: &str) -> String {
-        String::from("0")
+    fn part_one(&self, input: &str) -> String {
+        let junction_boxes = self.parse(input);
+        let closest = self.closest(junction_boxes);
+
+        let mut circuits: Vec<Vec<Point3D>> = Vec::new();
+
+        for pair in closest {
+            let left_circuit = circuits
+                .iter()
+                .position(|circuit| circuit.contains(&pair.0));
+
+            let right_circuit = circuits
+                .iter()
+                .position(|circuit| circuit.contains(&pair.1));
+
+            match (left_circuit, right_circuit) {
+                (Some(left), Some(right)) => {
+                    if left == right {
+                        continue;
+                    }
+
+                    for in_circuit in circuits[right].clone() {
+                        circuits[left].push(in_circuit);
+                    }
+                    circuits.remove(right);
+                }
+                (None, Some(right)) => circuits[right].push(pair.0),
+                (Some(left), None) => circuits[left].push(pair.1),
+                (None, None) => {
+                    let new_circuit = vec![pair.0, pair.1];
+
+                    circuits.push(new_circuit);
+                }
+            }
+        }
+
+        circuits
+            .iter()
+            .map(|circuit| circuit.len())
+            .sorted()
+            .rev()
+            .take(3)
+            .product::<usize>()
+            .to_string()
     }
 
     fn part_two(&self, _input: &str) -> String {
         String::from("0")
     }
 }
 
+impl Day08 {
+    fn parse(&self, input: &str) -> Vec<Point3D> {
+        input.lines().map(|line| line.parse().unwrap()).collect()
+    }
+
+    fn closest(&self, boxes: Vec<Point3D>) -> Vec<Pair> {
+        let mut calculated: Vec<(f64, Pair)> = Vec::new();
+        for i in 0..boxes.len() {
+            for j in i + 1..boxes.len() {
+                calculated.push((boxes[i].distance(&boxes[j]), (boxes[i], boxes[j])));
+            }
+        }
+
+        calculated.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
+
+        calculated
+            .iter()
+            .take(self.connections as usize)
+            .map(|x| x.1)
+            .collect()
+    }
+}
+
+impl Default for Day08 {
+    fn default() -> Self {
+        Self {
+            connections: INPUT_CONNECTIONS,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::solutions::year2025::day08::Day08;
     use crate::solutions::Solution;
+    const TEST_CONNECTIONS: u64 = 10;
 
-    const EXAMPLE: &str = r#""#;
-
-    #[test]
-    fn part_one_example_test() {
-        assert_eq!("0", Day08.part_one(EXAMPLE));
+    impl Day08 {
+        fn new_for_tests() -> Self {
+            Self {
+                connections: TEST_CONNECTIONS,
+            }
+        }
     }
 
+    const EXAMPLE: &str = r#"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 part_two_example_test() {
-        assert_eq!("0", Day08.part_two(EXAMPLE));
+    fn part_one_example_test() {
+        assert_eq!("40", Day08::new_for_tests().part_one(EXAMPLE));
     }
 }

src/utils/point3d.rs

@@ -1,6 +1,7 @@
 use itertools::Itertools;
 use std::fmt::{Display, Formatter};
-use std::ops::{Add, Mul};
+use std::ops::{Add, Mul, Sub};
+use std::str::FromStr;
 
 #[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
 pub struct Point3D {
@@ -29,6 +30,12 @@ impl Point3D {
             z: self.z + 1,
         }
     }
+
+    pub fn distance(&self, other: &Self) -> f64 {
+        let diff = *self - *other;
+
+        ((diff.x.abs().pow(2) + diff.y.abs().pow(2) + diff.z.abs().pow(2)) as f64).sqrt()
+    }
 }
 
 impl From<&str> for Point3D {
@@ -43,6 +50,14 @@ impl From<&str> for Point3D {
     }
 }
 
+impl FromStr for Point3D {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self::from(s))
+    }
+}
+
 impl Add<Point3D> for Point3D {
     type Output = Self;
 
@@ -59,8 +74,52 @@ impl Mul<isize> for Point3D {
     }
 }
 
+impl Sub<Point3D> for Point3D {
+    type Output = Self;
+
+    fn sub(self, rhs: Point3D) -> Self::Output {
+        Self::new(self.x - rhs.x, self.y - rhs.y, self.z - rhs.z)
+    }
+}
+
 impl Display for Point3D {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "({},{},{})", self.x, self.y, self.z)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_distance() {
+        let p1 = Point3D::new(1, 2, 3);
+        let p2 = Point3D::new(4, 5, 6);
+
+        assert_eq!(p1.distance(&p2), 5.196152422706632);
+    }
+
+    #[test]
+    fn test_distance_to_self() {
+        let p1 = Point3D::new(1, 2, 3);
+
+        assert_eq!(p1.distance(&p1), 0.0);
+    }
+
+    #[test]
+    fn test_distance_along_single_axis() {
+        let p1 = Point3D::new(1, 2, 3);
+        let p2 = Point3D::new(1, 2, 8);
+
+        assert_eq!(5.0, p1.distance(&p2));
+    }
+
+    #[test]
+    fn test_distance_from_origin() {
+        let p1 = Point3D::new(3, 4, 0);
+        let origin = Point3D::new(0, 0, 0);
+
+        assert_eq!(5.0, p1.distance(&origin));
+    }
+}