fix(07/2025): remove finished beams from vector and solve part one for example

Author: manhunto

src/solutions/year2025/day07.rs

@@ -3,6 +3,7 @@ use crate::utils::grid::{Grid, PrintableOnGrid};
 use crate::utils::line::Line;
 use crate::utils::point::Point;
 use std::collections::{HashSet, VecDeque};
+use std::fmt::{Debug, Display, Formatter};
 
 const START: char = 'S';
 const SPLITTER: char = '^';
@@ -27,30 +28,28 @@ impl Solution for Day07 {
             if splitters.contains(&down.current()) {
                 result_beams.push(current_beam);
 
-                for other in down.split() {
-                    if result_beams.iter().any(|beam| beam.is_on(&other)) {
+                for split in down.split() {
+                    if result_beams.iter().any(|beam| beam.collides(&split)) {
                         continue;
                     }
 
-                    current_beams.push_back(other);
+                    if current_beams.iter().any(|beam| beam.collides(&split)) {
+                        continue;
+                    }
+
+                    current_beams.push_back(split);
                 }
 
                 continue;
             }
 
             if down.current().y > max_height + 1 {
-                result_beams.push(current_beam);
                 continue;
             }
 
             current_beams.push_front(down);
         }
 
-        let mut new = grid.clone();
-        new.print(&result_beams[..]);
-
-        println!("{}", new);
-
         result_beams.len().to_string()
     }
 
@@ -59,18 +58,36 @@ impl Solution for Day07 {
     }
 }
 
-#[derive(Copy, Clone)]
+#[allow(dead_code)]
+fn print(grid: &Grid<char>, beams: &[Beam]) {
+    let mut new = grid.clone();
+    new.print(beams);
+
+    println!("{}", new);
+    println!("{} beams", beams.len());
+    println!();
+}
+
+#[derive(Copy, Clone, Debug)]
 struct Beam {
     line: Line,
 }
 
 impl Beam {
-    fn is_on(&self, other: &Self) -> bool {
-        if other.line.start() != other.line.end() {
+    fn collides(&self, other: &Self) -> bool {
+        let other_start = other.line.start();
+        if other_start != other.line.end() {
             panic!("We only support beam that just started");
         }
 
-        self.line.is_on(&other.line.start())
+        let start = self.line.start();
+        let end = self.line.end();
+
+        if start.x != other_start.x {
+            return false;
+        }
+
+        start.y <= other_start.y && end.y >= other_start.y
     }
 
     fn down(&self) -> Self {
@@ -96,26 +113,41 @@ impl From<Point> for Beam {
     }
 }
 
+impl From<(Point, Point)> for Beam {
+    fn from(value: (Point, Point)) -> Self {
+        Self {
+            line: Line::new(value.0, value.1),
+        }
+    }
+}
+
+impl Display for Beam {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "({}) - ({})", self.line.start(), self.line.end())
+    }
+}
+
 impl PrintableOnGrid for Beam {
     type Cell = char;
 
     fn print_on_grid(&self, grid: &mut Grid<char>) {
-        let mut moved = self.line.start();
+        let mut current = self.line.start();
 
         loop {
-            grid.modify(moved, BEAM);
-            if moved == self.line.end() {
+            grid.modify(current, BEAM);
+            if current == self.line.end() {
                 break;
             }
-            moved = moved.south();
+            current = current.south();
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::solutions::year2025::day07::Day07;
+    use crate::solutions::year2025::day07::{Beam, Day07};
     use crate::solutions::Solution;
+    use crate::utils::point::Point;
 
     const EXAMPLE: &str = r#".......S.......
 ...............
@@ -138,4 +170,28 @@ mod tests {
     fn part_one_example_test() {
         assert_eq!("21", Day07.part_one(EXAMPLE));
     }
+
+    #[test]
+    fn beam_collides() {
+        let beam: Beam = (Point::new(3, 0), Point::new(3, 3)).into();
+
+        assert!(!beam.collides(&Beam::from(Point::new(3, -1))));
+        assert!(beam.collides(&Beam::from(Point::new(3, 0))));
+        assert!(beam.collides(&Beam::from(Point::new(3, 1))));
+        assert!(beam.collides(&Beam::from(Point::new(3, 2))));
+        assert!(beam.collides(&Beam::from(Point::new(3, 3))));
+        assert!(!beam.collides(&Beam::from(Point::new(3, 4))));
+
+        assert!(!beam.collides(&Beam::from(Point::new(2, 0))));
+        assert!(!beam.collides(&Beam::from(Point::new(2, 1))));
+        assert!(!beam.collides(&Beam::from(Point::new(2, 2))));
+        assert!(!beam.collides(&Beam::from(Point::new(2, 3))));
+        assert!(!beam.collides(&Beam::from(Point::new(2, 4))));
+
+        assert!(!beam.collides(&Beam::from(Point::new(4, 0))));
+        assert!(!beam.collides(&Beam::from(Point::new(4, 1))));
+        assert!(!beam.collides(&Beam::from(Point::new(4, 2))));
+        assert!(!beam.collides(&Beam::from(Point::new(4, 3))));
+        assert!(!beam.collides(&Beam::from(Point::new(4, 4))));
+    }
 }

src/utils/line.rs

@@ -46,6 +46,7 @@ impl Line {
         Some(Point::new(x as isize, y as isize))
     }
 
+    #[allow(dead_code)]
     pub fn is_on(&self, point: &Point) -> bool {
         let a = self.start;
         let b = self.end;