chore: WIP y2025::day_09::part_2

Author: clechasseur

aoclp_solutions/src/y2025/day_09.rs

@@ -1,11 +1,12 @@
 use std::cmp::{max, min};
-use std::collections::HashMap;
+use std::collections::HashSet;
 use std::iter::{once, 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;
 
 pub fn part_1() -> i64 {
     input()
@@ -18,41 +19,14 @@ pub fn part_1() -> i64 {
 
 pub fn part_2() -> i64 {
     let red_tiles = input();
-    let path = build_path(&red_tiles);
 
-    let safe_line = red_tiles.iter().map(|p| p.y).min().unwrap() - 1;
-    let mut pt_safety = HashMap::new();
-    let mut safe_pt = |p: Pt| {
-        if let Some(&safe) = pt_safety.get(&p) {
-            return safe;
-        }
-
-        let safe = successors(Some(p), |&p| (p.y > safe_line).then_some(p + Direction4::Up))
-            .filter(|p| path.get(p).is_some_and(|&step| step == PathStep::LeftRight))
-            .count()
-            % 2
-            != 0;
-        pt_safety.insert(p, safe);
-        safe
-    };
-    let mut safe_line = |a: Pt, b: Pt| -> bool {
-        let displacement = Pt::new((b.x - a.x).signum(), (b.y - a.y).signum());
-        successors(Some(a), |&p| (p != b).then_some(p + displacement))
-            .chain(Some(b))
-            .all(&mut safe_pt)
+    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 mut safe_rectangle = |a: Pt, b: Pt| {
-        let corners = [
-            Pt::new(min(a.x, b.x), min(a.y, b.y)),
-            Pt::new(min(a.x, b.x), max(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)),
-        ];
-        corners
-            .iter()
-            .tuple_windows()
-            .all(|(&a, &b)| safe_line(a, b))
+    let safe_rectangle = |a, b| {
+        rectangle_points(a, b).all(|p| !red_zone.contains(&p))
     };
 
     red_tiles
@@ -66,38 +40,54 @@ pub fn part_2() -> i64 {
         .unwrap()
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum PathStep {
-    Corner,
-    LeftRight,
-    TopDown,
-}
-
-impl PathStep {
-    fn for_pair(a: Pt, b: Pt) -> Self {
-        if (a.x - b.x).abs().signum() != 0 {
-            Self::LeftRight
-        } else {
-            Self::TopDown
-        }
-    }
-}
-
-fn build_path(red_tiles: &[Pt]) -> HashMap<Pt, PathStep> {
-    red_tiles
+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 step = PathStep::for_pair(a, b);
             let displacement = Pt::new((b.x - a.x).signum(), (b.y - a.y).signum());
-            successors(Some((a, PathStep::Corner)), move |&(p, _)| {
-                (p != b).then_some((p + displacement, step))
-            })
-            .chain(once((b, PathStep::Corner)))
+            successors(Some(a), move |&p| (p != b).then_some(p + displacement))
+                .chain(once(b))
         })
-        .collect()
+        .collect();
+    let path_tiles = &path_tiles;
+
+    println!("Path tiles count: {}", path_tiles.len());
+
+    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
 }
 
 fn input() -> Vec<Pt> {