chore: y2025::day_09::part_2

Author: clechasseur

aoclp_solutions/src/y2025/day_09.rs

@@ -6,7 +6,8 @@ use aoclp::positioning::direction::four_points::Direction4;
 use aoclp::positioning::pt::{rectangular_area, Pt};
 use aoclp::solvers_impl::input::safe_get_input_as_many;
 use itertools::{chain, Either, Itertools};
-use aoclp::positioning::direction::Direction;
+use strum::IntoEnumIterator;
+use aoclp::positioning::direction::{Direction, MovementDirection};
 
 pub fn part_1() -> i64 {
     input()
@@ -40,57 +41,14 @@ pub fn part_2() -> i64 {
         edges.is_disjoint(&red_zone)
     };
 
-    let (a, b, area) = red_tiles
+    red_tiles
         .into_iter()
         .array_combinations()
         .map(|[a, b]| (a, b, rectangular_area(a, b)))
         .sorted_unstable_by(|(_, _, area_a), (_, _, area_b)| area_b.cmp(area_a))
         .find(|&(a, b, _)| safe_rectangle(a, b))
-        .unwrap();
-    println!("Largest rectangle is ({a}, {b}) area: {area}");
-
-    // {
-    //     let red_tiles = input();
-    //     let min_x = red_tiles.iter().map(|a| a.x).min().unwrap() - 2;
-    //     let max_x = red_tiles.iter().map(|a| a.x).max().unwrap() - 2;
-    //     let min_y = red_tiles.iter().map(|a| a.y).min().unwrap() + 2;
-    //     let max_y = red_tiles.iter().map(|a| a.y).max().unwrap() + 2;
-    //     let red_tiles: HashSet<_> = red_tiles.iter().copied().collect();
-    //     let corners = vec![
-    //         Pt::new(min(a.x, b.x), min(a.y, b.y)),
-    //         Pt::new(max(a.x, b.x), min(a.y, b.y)),
-    //         Pt::new(max(a.x, b.x), max(a.y, b.y)),
-    //         Pt::new(max(a.x, b.x), min(a.y, b.y)),
-    //         Pt::new(min(a.x, b.x), min(a.y, b.y)),
-    //     ];
-    //     let edges: BTreeSet<_> = corners
-    //         .into_iter()
-    //         .tuple_windows()
-    //         .flat_map(|(a, b)| {
-    //             let displacement = Pt::new((b.x - a.x).signum(), (b.y - a.y).signum());
-    //             successors(Some(a), move |&p| (p != b).then_some(p + displacement))
-    //         })
-    //         .collect();
-    //
-    //     for y in min_x..=max_y {
-    //         for x in min_y..=max_x {
-    //             let pt = Pt::new(x, y);
-    //             if red_tiles.contains(&pt) {
-    //                 print!("#");
-    //             } else if red_zone.contains(&pt) {
-    //                 print!("!");
-    //             } else if edges.contains(&pt) {
-    //                 print!("O");
-    //             } else {
-    //                 print!(".");
-    //             }
-    //         }
-    //         println!();
-    //     }
-    //     println!();
-    // }
-
-    area
+        .map(|(_, _, area)| area)
+        .unwrap()
 }
 
 fn build_red_zone(red_tiles: &[Pt]) -> impl Iterator<Item = Pt> + use<'_> {
@@ -101,30 +59,32 @@ fn build_red_zone(red_tiles: &[Pt]) -> impl Iterator<Item = Pt> + use<'_> {
         .next()
         .unwrap();
 
-    let get_direction = |a: Pt, b: Pt| match ((b.x - a.x).signum(), (b.y - a.y).signum()) {
-        (1, 0) => Direction4::Right,
-        (0, 1) => Direction4::Down,
-        (-1, 0) => Direction4::Left,
-        (0, -1) => Direction4::Up,
-        _ => unreachable!(),
+    let get_direction = |a: Pt, b: Pt| {
+        let displacement = Pt::new((b.x - a.x).signum(), (b.y - a.y).signum());
+        Direction4::iter().find(|&d| d.displacement() == displacement).unwrap()
     };
 
     red_tiles
         .iter()
         .copied()
         .cycle()
         .skip_while(move |&p| p != starting_point)
-        .take(red_tiles.len() + 1)
+        .take(red_tiles.len() + 2)
         .tuple_windows()
         .flat_map(move |(a, b, c)| {
             let direction = get_direction(a, b);
             let turning_left = get_direction(b, c) == direction.turn_left();
 
-            let red_zone_path = successors(Some(a), move |&p| (p != b).then_some(p + direction))
+            let red_zone_path = successors(Some(a), move |&p| {
+                let next = p + direction;
+                (next != b).then_some(next)
+            })
                 .skip(1)
-                .map(move |p| p + (direction.turn_left()));
+                .map(move |p| p + (direction.turn_left()))
+                .collect_vec();
+
             if turning_left {
-                Either::Left(red_zone_path)
+                Either::Left(red_zone_path.into_iter())
             } else {
                 Either::Right(chain(
                     red_zone_path,
@@ -138,6 +98,16 @@ fn build_red_zone(red_tiles: &[Pt]) -> impl Iterator<Item = Pt> + use<'_> {
         })
 }
 
+const EXAMPLE: &str = "\
+    7,1\n\
+    11,1\n\
+    11,7\n\
+    9,7\n\
+    9,5\n\
+    2,5\n\
+    2,3\n\
+    7,3";
+
 fn input() -> Vec<Pt> {
     safe_get_input_as_many(2025, 9)
 }