feat(07/2025): implement foundations; add printable on grid trait to simplify printing on grid

Author: manhunto

src/solutions/year2025/day07.rs

@@ -1,26 +1,141 @@
 use crate::solutions::Solution;
+use crate::utils::grid::{Grid, PrintableOnGrid};
+use crate::utils::line::Line;
+use crate::utils::point::Point;
+use std::collections::{HashSet, VecDeque};
+
+const START: char = 'S';
+const SPLITTER: char = '^';
+const BEAM: char = '|';
 
 pub struct Day07;
 
 impl Solution for Day07 {
-    fn part_one(&self, _input: &str) -> String {
-        String::from("0")
+    fn part_one(&self, input: &str) -> String {
+        let grid: Grid<char> = Grid::from(input);
+        let max_height = grid.columns_range().end();
+        let start = grid.get_first_position(&START).unwrap();
+
+        let splitters: HashSet<Point> = grid.get_all_positions(&SPLITTER).into_iter().collect();
+
+        let mut result_beams: Vec<Beam> = Vec::new();
+        let mut current_beams: VecDeque<Beam> = VecDeque::from(vec![start.into()]);
+
+        while let Some(current_beam) = current_beams.pop_front() {
+            let down = current_beam.down();
+
+            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)) {
+                        continue;
+                    }
+
+                    current_beams.push_back(other);
+                }
+
+                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()
     }
 
     fn part_two(&self, _input: &str) -> String {
         String::from("0")
     }
 }
 
+#[derive(Copy, Clone)]
+struct Beam {
+    line: Line,
+}
+
+impl Beam {
+    fn is_on(&self, other: &Self) -> bool {
+        if other.line.start() != other.line.end() {
+            panic!("We only support beam that just started");
+        }
+
+        self.line.is_on(&other.line.start())
+    }
+
+    fn down(&self) -> Self {
+        Self {
+            line: Line::new(self.line.start(), self.line.end().south()),
+        }
+    }
+
+    fn current(&self) -> Point {
+        self.line.end()
+    }
+
+    fn split(&self) -> Vec<Beam> {
+        vec![self.current().west().into(), self.current().east().into()]
+    }
+}
+
+impl From<Point> for Beam {
+    fn from(value: Point) -> Self {
+        Self {
+            line: Line::new(value, value),
+        }
+    }
+}
+
+impl PrintableOnGrid for Beam {
+    type Cell = char;
+
+    fn print_on_grid(&self, grid: &mut Grid<char>) {
+        let mut moved = self.line.start();
+
+        loop {
+            grid.modify(moved, BEAM);
+            if moved == self.line.end() {
+                break;
+            }
+            moved = moved.south();
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::solutions::year2025::day07::Day07;
     use crate::solutions::Solution;
 
-    const EXAMPLE: &str = r#""#;
+    const EXAMPLE: &str = r#".......S.......
+...............
+.......^.......
+...............
+......^.^......
+...............
+.....^.^.^.....
+...............
+....^.^...^....
+...............
+...^.^...^.^...
+...............
+..^...^.....^..
+...............
+.^.^.^.^.^...^.
+..............."#;
 
     #[test]
     fn part_one_example_test() {
-        assert_eq!("0", Day07.part_one(EXAMPLE));
+        assert_eq!("21", Day07.part_one(EXAMPLE));
     }
 }

src/utils/grid.rs

@@ -361,6 +361,14 @@ where
 
         self.get_for_point(&top_left)
     }
+
+    #[allow(dead_code)]
+    pub fn print<P>(&mut self, printable: &P)
+    where
+        P: PrintableOnGrid<Cell = T> + ?Sized,
+    {
+        printable.print_on_grid(self)
+    }
 }
 
 impl<T> Display for Grid<T>
@@ -403,6 +411,23 @@ where
     }
 }
 
+pub trait PrintableOnGrid {
+    type Cell;
+    fn print_on_grid(&self, grid: &mut Grid<Self::Cell>);
+}
+
+impl<U> PrintableOnGrid for [U]
+where
+    U: PrintableOnGrid,
+{
+    type Cell = U::Cell;
+    fn print_on_grid(&self, grid: &mut Grid<Self::Cell>) {
+        for item in self {
+            item.print_on_grid(grid);
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::utils::grid::Grid;

src/utils/line.rs

@@ -7,7 +7,17 @@ pub struct Line {
 }
 
 impl Line {
+    pub fn start(&self) -> Point {
+        self.start
+    }
+
+    pub fn end(&self) -> Point {
+        self.end
+    }
+
     pub fn new(start: Point, end: Point) -> Self {
+        // check if it is vertical, horizontal or diagonal only
+
         Self { start, end }
     }
 
@@ -35,4 +45,35 @@ impl Line {
 
         Some(Point::new(x as isize, y as isize))
     }
+
+    pub fn is_on(&self, point: &Point) -> bool {
+        let a = self.start;
+        let b = self.end;
+        let p = *point;
+
+        let cross_product = (p.y - a.y) * (b.x - a.x) - (p.x - a.x) * (b.y - a.y);
+
+        if cross_product != 0 {
+            return false;
+        }
+
+        p.x >= a.x.min(b.x) && p.x <= a.x.max(b.x) && p.y >= a.y.min(b.y) && p.y <= a.y.max(b.y)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::utils::line::Line;
+    use crate::utils::point::Point;
+
+    #[test]
+    fn is_on() {
+        let line = Line::new(Point::new(0, 0), Point::new(10, 10));
+
+        assert!(line.is_on(&Point::new(0, 0))); // Start point
+        assert!(line.is_on(&Point::new(5, 5))); // On the line
+        assert!(line.is_on(&Point::new(10, 10))); // End point
+        assert!(!line.is_on(&Point::new(15, 15))); // Outside the segment
+        assert!(!line.is_on(&Point::new(1, 5))); // Not on the line (not collinear)
+    }
 }