chore: y2025::day_09

Author: clechasseur

.run/run_aoc.run.xml

@@ -1,7 +1,7 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="run_aoc" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
     <option name="buildProfileId" value="dev" />
-    <option name="command" value="run --package aoclp_solutions --bin aoclp_solutions -- --year 2025 --day 8" />
+    <option name="command" value="run --package aoclp_solutions --bin aoclp_solutions -- --year 2025 --day 9" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <envs />
     <option name="emulateTerminal" value="true" />

aoclp/src/positioning/pt.rs

@@ -177,6 +177,15 @@ where
     (a.x - b.x).abs() + (a.y - b.y).abs()
 }
 
+/// Returns the size of the rectangle formed between two points in 2D space,
+/// as if the points were two of the rectangle's opposing corners.
+pub fn rectangular_area<T>(a: Pt<T>, b: Pt<T>) -> T
+where
+    T: Signed,
+{
+    ((a.x - b.x).abs() + T::one()) * ((a.y - b.y).abs() + T::one())
+}
+
 /// Given a two-dimensional matrix of elements, returns a map of
 /// [`Pt`] associated with the element at that position in the matrix.
 pub fn matrix_to_map<T, M, R, PT>(matrix: M) -> HashMap<Pt<PT>, T>

aoclp_solutions/src/lib.rs

@@ -11,5 +11,5 @@ pub mod y2025;
 build_solvers! {
     { 2017, [01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25] },
     { 2024, [01, 02, 03, 04, 05, 06, 07, 08, 09, 10] },
-    { 2025, [01, 02, 03, 04, 05, 06, 07, 08] }
+    { 2025, [01, 02, 03, 04, 05, 06, 07, 08, 09] }
 }

aoclp_solutions/src/y2025/day_09.rs

@@ -0,0 +1,112 @@
+use std::cmp::{max, min};
+use std::collections::BTreeSet;
+use std::iter::successors;
+
+use aoclp::positioning::direction::four_points::Direction4;
+use aoclp::positioning::direction::{Direction, MovementDirection};
+use aoclp::positioning::pt::{rectangular_area, Pt};
+use aoclp::solvers_impl::input::safe_get_input_as_many;
+use itertools::Itertools;
+use strum::IntoEnumIterator;
+
+pub fn part_1() -> i64 {
+    input()
+        .into_iter()
+        .array_combinations()
+        .map(|[a, b]| rectangular_area(a, b))
+        .max()
+        .unwrap()
+}
+
+pub fn part_2() -> i64 {
+    let red_tiles = input();
+
+    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(min(a.x, b.x), max(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
+        .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))
+        .map(|(_, _, area)| area)
+        .unwrap()
+}
+
+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();
+
+    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() + 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 tail = if turning_left {
+                vec![]
+            } else {
+                vec![
+                    b + direction.turn_left(),
+                    b + direction + direction.turn_left(),
+                    b + direction,
+                ]
+            };
+
+            successors(Some(a), move |&p| {
+                let next = p + direction;
+                (next != b).then_some(next)
+            })
+            .skip(1)
+            .map(move |p| p + (direction.turn_left()))
+            .chain(tail)
+        })
+}
+
+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)
+}

aoclp_solutions/src/y2025/mod.rs

@@ -6,3 +6,4 @@ pub mod day_05;
 pub mod day_06;
 pub mod day_07;
 pub mod day_08;
+pub mod day_09;