feat(11/2025): solve first part

Author: manhunto

readme.md

@@ -20,6 +20,8 @@
 | [Day 7: Laboratories](src/solutions/year2025/day07.rs)        |   ⭐⭐   |            6.711 |            5.789 |
 | [Day 8: Playground](src/solutions/year2025/day08.rs)          |   ⭐⭐   |           46.993 |           44.599 |
 | [Day 9: Movie Theater](src/solutions/year2025/day09.rs)       |   ⭐    |            0.387 |                - |
+| [Day 10: Factory](src/solutions/year2025/day10.rs)            |        |                - |                - |
+| [Day 11: Reactor](src/solutions/year2025/day11.rs)            |   ⭐    |            0.897 |                - |
 
 # 2024
 

src/solutions/mod.rs

@@ -24,6 +24,7 @@ pub fn solution(puzzle_day: PuzzleDay) -> Box<dyn Solution> {
             7 => Box::new(year2025::day07::Day07),
             8 => Box::new(year2025::day08::Day08::default()),
             9 => Box::new(year2025::day09::Day09),
+            11 => Box::new(year2025::day11::Day11),
             _ => panic!("Day not exist"),
         },
         Year::Year2024 => match i {

src/solutions/year2025/day11.rs

@@ -0,0 +1,60 @@
+use crate::solutions::Solution;
+use crate::utils::graphs::all_paths::AllPaths;
+use crate::utils::graphs::graph::Graph;
+
+pub struct Day11;
+
+const LABEL_YOU: &str = "you";
+const LABEL_OUT: &str = "out";
+
+impl Solution for Day11 {
+    fn part_one(&self, input: &str) -> String {
+        let graph = self.parse(input);
+        let all_paths: AllPaths<&str> = (&graph).into();
+
+        all_paths.paths(LABEL_YOU, LABEL_OUT).len().to_string()
+    }
+
+    fn part_two(&self, _input: &str) -> String {
+        String::from("0")
+    }
+}
+
+impl Day11 {
+    fn parse<'a>(&self, input: &'a str) -> Graph<&'a str> {
+        let mut graph = Graph::directed();
+
+        input.lines().for_each(|line| {
+            let (node, outputs) = line.split_once(": ").unwrap();
+            let outputs_vec = outputs.split_whitespace();
+
+            for output in outputs_vec {
+                graph.add_edge(node, output);
+            }
+        });
+
+        graph
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::solutions::year2025::day11::Day11;
+    use crate::solutions::Solution;
+
+    const EXAMPLE: &str = r#"aaa: you hhh
+you: bbb ccc
+bbb: ddd eee
+ccc: ddd eee fff
+ddd: ggg
+eee: out
+fff: out
+ggg: out
+hhh: ccc fff iii
+iii: out"#;
+
+    #[test]
+    fn part_one_example_test() {
+        assert_eq!("5", Day11.part_one(EXAMPLE));
+    }
+}

src/solutions/year2025/mod.rs

@@ -7,3 +7,4 @@ pub mod day06;
 pub mod day07;
 pub mod day08;
 pub mod day09;
+pub mod day11;

src/utils/graphs/all_paths.rs

@@ -1,45 +1,87 @@
-use std::collections::VecDeque;
+use crate::utils::graphs::graph::Graph;
+use std::collections::{HashMap, VecDeque};
+use std::hash::Hash;
 
-pub struct AllPaths<'a, T> {
-    adjacency: &'a dyn Fn(T) -> Vec<T>,
+pub trait IsEnd<T> {
+    fn is_end(&self, value: &T) -> bool;
 }
 
+impl<T: PartialEq> IsEnd<T> for T {
+    fn is_end(&self, value: &T) -> bool {
+        self == value
+    }
+}
+
+impl<T: PartialEq> IsEnd<T> for Vec<T> {
+    fn is_end(&self, value: &T) -> bool {
+        self.contains(value)
+    }
+}
+
+pub struct AllPaths<'a, T: 'a> {
+    adjacency: Box<dyn Fn(T) -> Vec<T> + 'a>,
+}
+
+impl<'a, T> From<&'a Graph<T>> for AllPaths<'a, T>
+where
+    T: Eq + Hash + Copy + PartialEq + Clone,
+{
+    fn from(graph: &'a Graph<T>) -> Self {
+        Self::new(move |p: T| graph.neighbours(&p))
+    }
+}
+
+impl<'a, T> From<&'a HashMap<T, Vec<T>>> for AllPaths<'a, T>
+where
+    T: Eq + Hash + Copy + PartialEq + Clone,
+{
+    fn from(value: &'a HashMap<T, Vec<T>>) -> Self {
+        Self::new(move |p: T| value.get(&p).unwrap().to_vec())
+    }
+}
 impl<'a, T> AllPaths<'a, T>
 where
     T: PartialEq + Clone,
 {
-    pub fn new(adjacency: &'a dyn Fn(T) -> Vec<T>) -> Self {
-        Self { adjacency }
+    pub fn new(adjacency: impl Fn(T) -> Vec<T> + 'a) -> Self {
+        Self {
+            adjacency: Box::new(adjacency),
+        }
     }
 
-    pub fn generate(&self, start: T, end: T) -> Vec<VecDeque<T>> {
+    pub fn paths<E>(&self, start: T, end: E) -> Vec<VecDeque<T>>
+    where
+        E: IsEnd<T>,
+    {
         let mut paths: Vec<VecDeque<T>> = Vec::new();
 
-        self.visit(start, end, Vec::new(), VecDeque::new(), &mut paths);
+        self.visit(start, &end, Vec::new(), VecDeque::new(), &mut paths);
 
         paths
     }
 
-    fn visit(
+    fn visit<E>(
         &self,
         from: T,
-        end: T,
+        end: &E,
         mut visited: Vec<T>,
         mut path: VecDeque<T>,
         paths: &mut Vec<VecDeque<T>>,
-    ) {
+    ) where
+        E: IsEnd<T>,
+    {
         visited.push(from.clone());
         path.push_back(from.clone());
 
-        if from == end {
+        if end.is_end(&from) {
             paths.push(path.clone());
 
             return;
         }
 
         for p in (self.adjacency)(from) {
             if !visited.contains(&p) {
-                self.visit(p, end.clone(), visited.clone(), path.clone(), paths);
+                self.visit(p, end, visited.clone(), path.clone(), paths);
             }
         }
     }
@@ -48,6 +90,7 @@ where
 #[cfg(test)]
 mod tests {
     use crate::utils::graphs::all_paths::AllPaths;
+    use crate::utils::graphs::graph::Graph;
     use crate::utils::point::Point;
     use std::collections::{HashMap, VecDeque};
 
@@ -66,13 +109,63 @@ mod tests {
         ]);
         let adjacency = |p: Point| graph.get(&p).unwrap().to_vec();
 
-        let all_paths: AllPaths<Point> = AllPaths::new(&adjacency);
+        let all_paths: AllPaths<Point> = AllPaths::new(adjacency);
 
-        let paths = all_paths.generate(p2, p3);
+        let paths = all_paths.paths(p2, p3);
 
         assert_eq!(3, paths.len());
         assert!(paths.contains(&VecDeque::from(vec![p2, p1, p3])));
         assert!(paths.contains(&VecDeque::from(vec![p2, p0, p3])));
         assert!(paths.contains(&VecDeque::from(vec![p2, p0, p1, p3])));
     }
+
+    #[test]
+    fn paths_vec_end() {
+        let p0 = Point::new(0, 0);
+        let p1 = Point::new(1, 1);
+        let p2 = Point::new(2, 2);
+        let p3 = Point::new(3, 3);
+        let p4 = Point::new(4, 4);
+
+        let graph: HashMap<Point, Vec<Point>> = HashMap::from([
+            (p0, vec![p1, p2]),
+            (p1, vec![p3]),
+            (p2, vec![p4]),
+            (p3, vec![]),
+            (p4, vec![]),
+        ]);
+        let adjacency = |p: Point| graph.get(&p).unwrap().to_vec();
+
+        let all_paths: AllPaths<Point> = AllPaths::new(adjacency);
+
+        let paths = all_paths.paths(p0, vec![p3, p4]);
+
+        assert_eq!(2, paths.len());
+        assert!(paths.contains(&VecDeque::from(vec![p0, p1, p3])));
+        assert!(paths.contains(&VecDeque::from(vec![p0, p2, p4])));
+    }
+
+    #[test]
+    fn paths_from_graph() {
+        let p0 = Point::new(0, 0);
+        let p1 = Point::new(1, 1);
+        let p2 = Point::new(2, 2);
+        let p3 = Point::new(3, 3);
+
+        let mut graph = Graph::undirected();
+        graph.add_edge(p0, p1);
+        graph.add_edge(p0, p2);
+        graph.add_edge(p0, p3);
+        graph.add_edge(p1, p3);
+        graph.add_edge(p2, p1);
+
+        let all_paths = AllPaths::from(&graph);
+        let paths = all_paths.paths(p2, p3);
+
+        assert_eq!(4, paths.len());
+        assert!(paths.contains(&VecDeque::from(vec![p2, p1, p3])));
+        assert!(paths.contains(&VecDeque::from(vec![p2, p0, p3])));
+        assert!(paths.contains(&VecDeque::from(vec![p2, p0, p1, p3])));
+        assert!(paths.contains(&VecDeque::from(vec![p2, p1, p0, p3])));
+    }
 }

src/utils/graphs/graph.rs

@@ -2,7 +2,6 @@ use std::collections::{HashMap, HashSet};
 use std::hash::Hash;
 
 enum GraphType {
-    #[allow(dead_code)]
     Directed,
     Undirected,
 }
@@ -24,6 +23,15 @@ impl<T> Graph<T> {
         }
     }
 
+    pub fn directed() -> Self {
+        Self {
+            nodes: HashSet::new(),
+            edges: HashSet::new(),
+            neighbours: HashMap::new(),
+            graph_type: GraphType::Directed,
+        }
+    }
+
     pub fn add_edge(&mut self, a: T, b: T)
     where
         T: Eq + Hash + Copy,
@@ -59,7 +67,7 @@ impl<T> Graph<T> {
         &self.edges
     }
 
-    fn neighbours(&self, node: &T) -> Vec<T>
+    pub fn neighbours(&self, node: &T) -> Vec<T>
     where
         T: Eq + Hash + Copy,
     {

src/utils/graphs/longest_path.rs

@@ -17,7 +17,7 @@ where
 
     pub fn cost(&self, start: T, end: T) -> usize {
         let all_paths: AllPaths<T> = AllPaths::new(self.adjacency);
-        let paths = all_paths.generate(start, end);
+        let paths = all_paths.paths(start, end);
 
         paths
             .into_iter()