chore: WIP y2025::day_09::part_2

Author: clechasseur

aoclp_solutions/src/y2025/day_09.rs

@@ -1,12 +1,12 @@
 use std::cmp::{max, min};
-use std::collections::HashSet;
-use std::iter::{once, successors};
+use std::collections::{BTreeSet, HashSet};
+use std::iter::successors;
 
 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::Itertools;
-use aoclp::positioning::turtle::Turtle;
+use aoclp::positioning::direction::Direction;
 
 pub fn part_1() -> i64 {
     input()
@@ -20,74 +20,108 @@ pub fn part_1() -> i64 {
 pub fn part_2() -> i64 {
     let red_tiles = input();
 
-    let red_zone = build_red_zone(&red_tiles);
-    let rectangle_points = |a: Pt, b: Pt| {
-        let (left, right, top, bottom) = (min(a.x, b.x), max(a.x, b.x), min(a.y, b.y), max(a.y, b.y));
-        (left..=right).flat_map(move |x| (top..=bottom).map(move |y| Pt::new(x, y)))
-    };
-    let safe_rectangle = |a, b| {
-        rectangle_points(a, b).all(|p| !red_zone.contains(&p))
+    let red_zone: BTreeSet<_> = build_red_zone(&red_tiles).collect();
+    let safe_rectangle = |a: Pt, b: Pt| {
+        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();
+        edges.is_disjoint(&red_zone)
     };
 
-    red_tiles
+    let (a, b, area) = 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))
-        .filter(|&(a, b, _)| safe_rectangle(a, b))
-        .map(|(_, _, area)| area)
-        .next()
-        .unwrap()
-}
+        .find(|&(a, b, _)| safe_rectangle(a, b))
+        .unwrap();
+    println!("Largest rectangle is ({a}, {b}) area: {area}");
 
-fn build_red_zone(red_tiles: &[Pt]) -> HashSet<Pt> {
-    let path_tiles: HashSet<_> = red_tiles
-        .iter()
-        .copied()
-        .chain(once(red_tiles[0]))
-        .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))
-                .chain(once(b))
-        })
-        .collect();
-    let path_tiles = &path_tiles;
+    {
+        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();
 
-    println!("Path tiles count: {}", path_tiles.len());
+        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
+}
+
+fn build_red_zone(red_tiles: &[Pt]) -> impl Iterator<Item = Pt> + use<'_> {
     let starting_point = red_tiles
         .iter()
         .sorted_by(|a, b| a.x.cmp(&b.x).then(a.y.cmp(&b.y)))
         .copied()
         .next()
         .unwrap();
 
-    println!("Starting point: {starting_point}");
-
-    let starting_turtle = Turtle::new(starting_point, Direction4::Right);
-    let turtle_path = successors(Some((starting_turtle, 0usize)), move |&(t, i)| {
-        if t == starting_turtle && i != 0 {
-            return None;
-        }
-        Some([t, t.turn_left(), t.turn_right()]
-            .iter()
-            .map(|next| (next.advance(), i + 1))
-            .find(|(next, _)| path_tiles.contains(&next.position))
-            .unwrap())
-    });
-
-    let red_zone: HashSet<_> = turtle_path
-        .map(|(turtle, _)| turtle.turn_left().advance())
-        .filter(|turtle| !path_tiles.contains(&turtle.position))
-        .map(|turtle| turtle.position)
-        .collect();
-
-    if !red_zone.is_empty() {
-        println!("Red zone tiles count: {}", red_zone.len());
-    }
-
-    red_zone
+    red_tiles
+        .iter()
+        .copied()
+        .cycle()
+        .skip_while(move |&p| p != starting_point)
+        .enumerate()
+        .take_while(move |&(i, p)| i == 0 || p != starting_point)
+        .map(|(_, p)| p)
+        .tuple_windows()
+        .flat_map(|(a, b)| {
+            let direction = 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!(),
+            };
+            successors(Some(a), move |&p| (p != b).then_some(p + direction))
+                .skip(1)
+                .map(move |p| p + (direction.turn_left()))
+        })
 }
 
 fn input() -> Vec<Pt> {