refactor(16/2024): remove code duplications

Author: manhunto

src/solutions/year2023/day17.rs

@@ -10,26 +10,30 @@ pub struct Day17;
 impl Solution for Day17 {
     fn part_one(&self, input: &str) -> String {
         let grid: Grid<u8> = Self::parse(input);
+        let grid_clone = grid.clone();
+        let grid_clone_2 = grid.clone();
 
-        let adjacency = |node: Node| -> Vec<Node> {
+        let adjacency = move |node: Node| -> Vec<Node> {
             let vec: Vec<Node> = if node.forward_count < 3 {
                 vec![node.left(), node.right(), node.forward()]
             } else {
                 vec![node.left(), node.right()]
             };
 
-            Self::filter_out_outside_grid(vec, &grid)
+            Self::filter_out_outside_grid(vec, &grid_clone)
         };
 
-        let is_end = |node: Node| -> bool { Self::is_end_node(node, &grid) };
+        let is_end = move |node: Node| -> bool { Self::is_end_node(node, &grid_clone_2) };
 
-        Self::solve(&grid, &adjacency, &is_end)
+        Self::solve(&grid, Box::new(adjacency), Box::new(is_end))
     }
 
     fn part_two(&self, input: &str) -> String {
         let grid: Grid<u8> = Self::parse(input);
+        let grid_clone = grid.clone();
+        let grid_clone_2 = grid.clone();
 
-        let adjacency = |node: Node| -> Vec<Node> {
+        let adjacency = move |node: Node| -> Vec<Node> {
             let vec: Vec<Node> = if node.forward_count < 4 {
                 vec![node.forward()]
             } else if node.forward_count >= 4 && node.forward_count < 10 {
@@ -38,13 +42,14 @@ impl Solution for Day17 {
                 vec![node.left(), node.right()]
             };
 
-            Self::filter_out_outside_grid(vec, &grid)
+            Self::filter_out_outside_grid(vec, &grid_clone)
         };
 
-        let is_end =
-            |node: Node| -> bool { node.forward_count >= 4 && Self::is_end_node(node, &grid) };
+        let is_end = move |node: Node| -> bool {
+            node.forward_count >= 4 && Self::is_end_node(node, &grid_clone_2)
+        };
 
-        Self::solve(&grid, &adjacency, &is_end)
+        Self::solve(&grid, Box::new(adjacency), Box::new(is_end))
     }
 }
 
@@ -55,12 +60,15 @@ impl Day17 {
 
     fn solve(
         grid: &Grid<u8>,
-        adjacency: &dyn Fn(Node) -> Vec<Node>,
-        is_end: &dyn Fn(Node) -> bool,
+        adjacency: Box<dyn Fn(Node) -> Vec<Node>>,
+        is_end: Box<dyn Fn(Node) -> bool>,
     ) -> String {
         let start_point = grid.surface().top_left_corner();
-        let cost = |_, next: Node| *grid.get_for_point(&next.vector.position()).unwrap() as usize;
-        let dijkstra: Dijkstra<Node> = Dijkstra::new(adjacency, &cost, is_end);
+        let grid_clone = grid.clone();
+        let cost = move |_, next: Node| {
+            *grid_clone.get_for_point(&next.vector.position()).unwrap() as usize
+        };
+        let dijkstra: Dijkstra<Node> = Dijkstra::new(adjacency, Box::new(cost), Box::new(is_end));
 
         let starts = vec![
             Node::new(start_point, Direction::East),

src/solutions/year2024/day16.rs

@@ -2,96 +2,84 @@ use crate::solutions::Solution;
 use crate::utils::direction::Direction::East;
 use crate::utils::graphs::dijkstra::Dijkstra;
 use crate::utils::grid::Grid;
+use crate::utils::point::Point;
 use crate::utils::vector::Vector;
 use itertools::Itertools;
 
 pub struct Day16;
 
 impl Solution for Day16 {
     fn part_one(&self, input: &str) -> String {
-        let grid: Grid<char> = Grid::from(input);
-        let start = grid.get_first_position(&'S').unwrap();
-        let start = Vector::new(start, East);
-        let end = grid.get_first_position(&'E').unwrap();
-
-        let adjacency = |vector: Vector| {
-            let vectors = vec![
-                vector.forward(),
-                vector.rotate_cw().forward(),
-                vector.rotate_ccw().forward(),
-            ];
-
-            let result = vectors
-                .into_iter()
-                .filter(|vec| {
-                    let element = grid.get_for_point(&vec.position());
-
-                    element == Some(&'.') || element == Some(&'E')
-                })
-                .collect_vec();
-
-            result
-        };
-
-        let cost = |current: Vector, next: Vector| {
-            if current.forward() == next {
-                return 1;
-            }
-
-            1001
-        };
-
-        let is_end = |vector: Vector| vector.position() == end;
-
-        let dijkstra: Dijkstra<Vector> = Dijkstra::new(&adjacency, &cost, &is_end);
+        let (grid, start, end) = Self::setup_grid(input);
+        let dijkstra = Self::create_dijkstra(grid, end);
 
         dijkstra.cost(vec![start]).unwrap().to_string()
     }
 
     fn part_two(&self, input: &str) -> String {
+        let (grid, start, end) = Self::setup_grid(input);
+        let dijkstra = Self::create_dijkstra(grid, end);
+
+        dijkstra
+            .all_paths(vec![start])
+            .iter()
+            .flat_map(|path| path.iter().map(|p| p.position()))
+            .unique()
+            .count()
+            .to_string()
+    }
+}
+
+impl Day16 {
+    fn setup_grid(input: &str) -> (Grid<char>, Vector, Point) {
         let grid: Grid<char> = Grid::from(input);
         let start = grid.get_first_position(&'S').unwrap();
         let start = Vector::new(start, East);
         let end = grid.get_first_position(&'E').unwrap();
 
-        let adjacency = |vector: Vector| {
+        (grid, start, end)
+    }
+
+    fn create_dijkstra(grid: Grid<char>, end: Point) -> Dijkstra<Vector> {
+        let adjacency = Self::adjacency_closure(grid);
+        let cost = Self::cost_closure();
+        let is_end = Self::is_end_closure(end);
+
+        Dijkstra::new(adjacency, cost, is_end)
+    }
+
+    fn adjacency_closure(grid: Grid<char>) -> Box<dyn Fn(Vector) -> Vec<Vector>> {
+        Box::new(move |vector: Vector| {
             let vectors = vec![
                 vector.forward(),
                 vector.rotate_cw().forward(),
                 vector.rotate_ccw().forward(),
             ];
 
-            let result = vectors
+            vectors
                 .into_iter()
                 .filter(|vec| {
                     let element = grid.get_for_point(&vec.position());
-
                     element == Some(&'.') || element == Some(&'E')
                 })
-                .collect_vec();
-
-            result
-        };
-
-        let cost = |current: Vector, next: Vector| {
-            if current.forward() == next {
-                return 1;
-            }
-
-            1001
-        };
-
-        let is_end = |vector: Vector| vector.position() == end;
-        let dijkstra: Dijkstra<Vector> = Dijkstra::new(&adjacency, &cost, &is_end);
+                .collect_vec()
+        })
+    }
 
-        let paths = dijkstra.all_paths(vec![start]);
+    fn cost_closure() -> Box<dyn Fn(Vector, Vector) -> usize> {
+        Box::new(
+            move |current: Vector, next: Vector| {
+                if current.forward() == next {
+                    1
+                } else {
+                    1001
+                }
+            },
+        )
+    }
 
-        paths
-            .iter()
-            .flat_map(|path| path.iter().map(|p| p.position()))
-            .unique()
-            .count()
-            .to_string()
+    fn is_end_closure(end: Point) -> Box<dyn Fn(Vector) -> bool> {
+        Box::new(move |vector: Vector| vector.position() == end)
     }
 }
 

src/utils/graphs/dijkstra.rs

@@ -4,17 +4,17 @@ use std::collections::{BinaryHeap, HashMap, VecDeque};
 use std::fmt::Debug;
 use std::hash::Hash;
 
-pub struct Dijkstra<'a, T> {
-    neighbours: &'a dyn Fn(T) -> Vec<T>,
-    cost: &'a dyn Fn(T, T) -> usize,
-    is_end: &'a dyn Fn(T) -> bool,
+pub struct Dijkstra<T> {
+    neighbours: Box<dyn Fn(T) -> Vec<T>>,
+    cost: Box<dyn Fn(T, T) -> usize>,
+    is_end: Box<dyn Fn(T) -> bool>,
 }
 
-impl<'a, T> Dijkstra<'a, T> {
+impl<T> Dijkstra<T> {
     pub fn new(
-        neighbours: &'a dyn Fn(T) -> Vec<T>,
-        cost: &'a dyn Fn(T, T) -> usize,
-        is_end: &'a dyn Fn(T) -> bool,
+        neighbours: Box<dyn Fn(T) -> Vec<T>>,
+        cost: Box<dyn Fn(T, T) -> usize>,
+        is_end: Box<dyn Fn(T) -> bool>,
     ) -> Self {
         Self {
             neighbours,
@@ -56,7 +56,6 @@ impl<'a, T> Dijkstra<'a, T> {
 
     /// It returns every possible visited node
     /// Even if there is a many possible ways to reach end
-    /// FIXME: is not working in valid way
     pub fn all_paths(&self, starts: Vec<T>) -> Vec<VecDeque<T>>
     where
         T: Hash + Eq + PartialEq + Ord + Debug + Copy,
@@ -135,29 +134,29 @@ impl<'a, T> Dijkstra<'a, T> {
     }
 
     fn visit(
-        from: T,
         end: T,
+        current: T,
         visited: &mut Vec<T>,
         path: &mut VecDeque<T>,
         paths: &mut Vec<VecDeque<T>>,
         come_from: &HashMap<T, Vec<T>>,
     ) where
         T: Hash + Eq + PartialEq + Ord + Debug + Copy,
     {
-        visited.push(end);
-        path.push_front(end);
+        visited.push(current);
+        path.push_front(current);
 
-        if from == end {
+        if end == current {
             paths.push(path.clone());
             path.pop_front();
             visited.pop();
 
             return;
         }
 
-        for p in come_from.get(&end).unwrap_or(&Vec::new()) {
+        for p in come_from.get(&current).unwrap_or(&Vec::new()) {
             if !visited.contains(p) {
-                Self::visit(from, *p, visited, path, paths, come_from);
+                Self::visit(end, *p, visited, path, paths, come_from);
             }
         }
 
@@ -174,16 +173,16 @@ mod test {
     #[test]
     fn all_paths() {
         let dijkstra = Dijkstra::new(
-            &|node: char| match node {
+            Box::new(|node: char| match node {
                 'A' => vec!['^', '>'],
                 '^' => vec!['A', 'v'],
                 '>' => vec!['A', 'v'],
                 'v' => vec!['^', '>', '<'],
                 '<' => vec!['v'],
                 _ => unreachable!("Invalid node"),
-            },
-            &|_: char, _: char| 1,
-            &|node: char| node == '<',
+            }),
+            Box::new(|_: char, _: char| 1),
+            Box::new(|node: char| node == '<'),
         );
 
         let paths = dijkstra.all_paths(vec!['A']);