feat(08/2024): solve second part

Author: manhunto

readme.md

@@ -18,7 +18,7 @@
 | [Day 5: Print Queue](src/solutions/year2024/day05.rs)           |   ⭐⭐   |            3.151 |           11.874 |
 | [Day 6: Guard Gallivant](src/solutions/year2024/day06.rs)       |   ⭐    |            8.738 |                  |
 | [Day 7: Bridge Repair](src/solutions/year2024/day07.rs)         |   ⭐⭐   |            1.198 |          219.754 |
-| [Day 8: Resonant Collinearity](src/solutions/year2024/day08.rs) |   ⭐    |            0.883 |                  |
+| [Day 8: Resonant Collinearity](src/solutions/year2024/day08.rs) |   ⭐⭐    |            0.883 |            1.238 |
 
 # 2023
 

src/solutions/year2024/day08.rs

@@ -1,7 +1,8 @@
 use crate::solutions::Solution;
 use crate::utils::grid::Grid;
 use crate::utils::point::Point;
-use itertools::Itertools;
+use crate::utils::surface_range::SurfaceRange;
+use itertools::{concat, Itertools};
 
 pub struct Day08;
 
@@ -17,37 +18,81 @@ impl Solution for Day08 {
                 points
                     .iter()
                     .combinations(2)
-                    .flat_map(|pair| self.antinodes(*pair[0], *pair[1]))
+                    .flat_map(|pair| self.antinodes_part_one(*pair[0], *pair[1], &surface_range))
                     .collect::<Vec<Point>>()
             })
-            .filter(|p| surface_range.contains(*p))
             .unique()
             .count()
             .to_string()
     }
 
-    fn part_two(&self, _input: &str) -> String {
-        String::from('0')
+    fn part_two(&self, input: &str) -> String {
+        let grid: Grid<char> = Grid::from(input);
+        let surface_range = grid.surface_range();
+
+        grid.elements_with_points()
+            .iter()
+            .filter(|(element, _)| **element != '.')
+            .flat_map(|(_, points)| {
+                points
+                    .iter()
+                    .combinations(2)
+                    .flat_map(|pair| self.antinodes_part_two(*pair[0], *pair[1], &surface_range))
+                    .collect::<Vec<Point>>()
+            })
+            .unique()
+            .count()
+            .to_string()
     }
 }
 
 impl Day08 {
-    fn antinodes(&self, p1: Point, p2: Point) -> Vec<Point> {
+    fn antinodes_part_one(&self, p1: Point, p2: Point, surface_range: &SurfaceRange) -> Vec<Point> {
         let diff = p1 - p2;
 
         vec![p1 + diff, p1 - diff, p2 + diff, p2 - diff]
             .into_iter()
             .filter(|p| *p != p1 && *p != p2)
+            .filter(|p| surface_range.contains(*p))
             .collect()
     }
+
+    fn antinodes_part_two(&self, p1: Point, p2: Point, surface_range: &SurfaceRange) -> Vec<Point> {
+        let diff = p1 - p2;
+
+        let first = self.antipodes_in_dir(p1, diff, surface_range);
+        let second = self.antipodes_in_dir(p2, -diff, surface_range);
+
+        let vec = concat(vec![first, second]);
+
+        vec.into_iter().unique().collect()
+    }
+
+    fn antipodes_in_dir(
+        &self,
+        point: Point,
+        diff: Point,
+        surface_range: &SurfaceRange,
+    ) -> Vec<Point> {
+        let mut vec = Vec::new();
+        let mut current = point;
+
+        while surface_range.contains(current) {
+            vec.push(current);
+
+            current = current + diff;
+        }
+
+        vec
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use crate::solutions::year2024::day08::Day08;
     use crate::solutions::Solution;
     use crate::utils::grid::Grid;
-    use itertools::Itertools;
+    use itertools::{concat, Itertools};
 
     const EXAMPLE: &str = r#"............
 ........0...
@@ -68,7 +113,12 @@ mod tests {
     }
 
     #[test]
-    fn antinodes() {
+    fn part_two_example_test() {
+        assert_eq!("34", Day08.part_two(EXAMPLE));
+    }
+
+    #[test]
+    fn antinodes_part_one() {
         const GRID: &str = r#"..........
 ...#......
 ..........
@@ -85,12 +135,42 @@ mod tests {
 
         let (p1, p2) = elements.get(&'a').unwrap().iter().collect_tuple().unwrap();
 
-        let mut result = Day08.antinodes(*p1, *p2);
+        let mut result = Day08.antinodes_part_one(*p1, *p2, &grid.surface_range());
         let mut expected = elements.get(&'#').unwrap().to_vec();
 
         result.sort();
         expected.sort();
 
         assert_eq!(expected, result);
     }
+
+    #[test]
+    fn part_two_second_example() {
+        const GRID: &str = r#"T....#....
+...T......
+.T....#...
+.........#
+..#.......
+..........
+...#......
+..........
+....#.....
+.........."#;
+
+        let grid: Grid<char> = Grid::from(GRID);
+        let elements = grid.elements_with_points();
+
+        let (p1, p2, p3) = elements.get(&'T').unwrap().iter().collect_tuple().unwrap();
+
+        let result1 = Day08.antinodes_part_two(*p1, *p2, &grid.surface_range());
+        let result2 = Day08.antinodes_part_two(*p1, *p3, &grid.surface_range());
+        let result3 = Day08.antinodes_part_two(*p2, *p3, &grid.surface_range());
+
+        let result = concat(vec![result1, result2, result3])
+            .iter()
+            .unique()
+            .count();
+
+        assert_eq!(9, result);
+    }
 }