chore: add y2024::day_08

Author: clechasseur

aoclp/src/positioning/pt.rs

@@ -1,7 +1,8 @@
 use std::collections::HashMap;
+use std::convert::Infallible;
 use std::fmt::{Debug, Display, Formatter};
 use std::hash::Hash;
-use std::ops::{Add, AddAssign, Sub, SubAssign};
+use std::ops::{Add, AddAssign, RangeBounds, Sub, SubAssign};
 use std::str::FromStr;
 use std::sync::OnceLock;
 
@@ -47,6 +48,19 @@ where
     }
 }
 
+impl<T> Pt<T>
+where
+    T: PartialOrd,
+{
+    pub fn within<XR, YR>(&self, x_bounds: XR, y_bounds: YR) -> bool
+    where
+        XR: RangeBounds<T>,
+        YR: RangeBounds<T>,
+    {
+        x_bounds.contains(&self.x) && y_bounds.contains(&self.y)
+    }
+}
+
 impl<T, U, V> From<(U, V)> for Pt<T>
 where
     U: Into<T>,
@@ -72,7 +86,7 @@ impl<T> FromStr for Pt<T>
 where
     T: FromStr,
 {
-    type Err = ();
+    type Err = Infallible;
 
     /// Parses a [`Pt`] from a string in the form `(x, y)`.
     /// Parentheses and whitespace are optional.

aoclp/src/positioning/pt_3d.rs

@@ -1,5 +1,6 @@
+use std::convert::Infallible;
 use std::fmt::{Display, Formatter};
-use std::ops::{Add, AddAssign, Sub, SubAssign};
+use std::ops::{Add, AddAssign, RangeBounds, Sub, SubAssign};
 use std::str::FromStr;
 use std::sync::OnceLock;
 
@@ -21,6 +22,20 @@ impl<T> Pt3d<T> {
     }
 }
 
+impl<T> Pt3d<T>
+where
+    T: PartialOrd,
+{
+    pub fn within<XR, YR, ZR>(&self, x_bounds: XR, y_bounds: YR, z_bounds: ZR) -> bool
+    where
+        XR: RangeBounds<T>,
+        YR: RangeBounds<T>,
+        ZR: RangeBounds<T>,
+    {
+        x_bounds.contains(&self.x) && y_bounds.contains(&self.y) && z_bounds.contains(&self.z)
+    }
+}
+
 impl<T, U, V, W> From<(U, V, W)> for Pt3d<T>
 where
     U: Into<T>,
@@ -47,7 +62,7 @@ impl<T> FromStr for Pt3d<T>
 where
     T: FromStr,
 {
-    type Err = ();
+    type Err = Infallible;
 
     /// Parses a [`Pt3d`] from a string in the form `(x, y, z)`.
     /// Parentheses and whitespace are optional.

aoclp_solutions/src/lib.rs

@@ -10,6 +10,6 @@ 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] },
+    { 2024, [01, 02, 03, 04, 05, 06, 07, 08] },
     { 2025, [01, 02, 03] }
 }

aoclp_solutions/src/y2024/day_08.rs

@@ -0,0 +1,94 @@
+use std::collections::HashMap;
+use std::iter::successors;
+use std::ops::Range;
+
+use aoclp::positioning::pt::{matrix_to_map, Pt};
+use aoclp::solvers_impl::input::safe_get_input_as_terrain;
+use itertools::Itertools;
+
+pub fn part_1() -> usize {
+    Map::default().antinodes(false).count()
+}
+
+pub fn part_2() -> usize {
+    Map::default().antinodes(true).count()
+}
+
+#[derive(Debug)]
+struct Map {
+    x_bounds: Range<i64>,
+    y_bounds: Range<i64>,
+    antennas: HashMap<Pt, char>,
+}
+
+impl Map {
+    fn antinodes(&self, resonating: bool) -> impl Iterator<Item = Pt> {
+        let antinodes = self
+            .antennas
+            .iter()
+            .sorted_by_key(|&(_, &freq)| freq)
+            .chunk_by(|&(_, &freq)| freq)
+            .into_iter()
+            .flat_map(|(_, antennas)| {
+                let antennas = antennas.map(|(&pt, _)| pt).collect_vec();
+                let antinodes = antennas
+                    .iter()
+                    .cartesian_product(antennas.iter())
+                    .filter(|(p1, p2)| p1 != p2)
+                    .flat_map(|(&p1, &p2)| {
+                        let antinodes = match resonating {
+                            true => self.resonating_antinodes_for(p1, p2).collect_vec(),
+                            false => self.dull_antinodes_for(p1, p2).collect_vec(),
+                        };
+                        antinodes.into_iter()
+                    })
+                    .collect_vec();
+                antinodes.into_iter()
+            })
+            .unique()
+            .filter(|pt| pt.within(self.x_bounds.clone(), self.y_bounds.clone()))
+            .collect_vec();
+        antinodes.into_iter()
+    }
+
+    fn dull_antinodes_for(&self, p1: Pt, p2: Pt) -> impl Iterator<Item = Pt> {
+        let diff = p1 - p2;
+        let anti1 = p1 + diff;
+        let anti2 = p2 - diff;
+        [anti1, anti2].into_iter()
+    }
+
+    fn resonating_antinodes_for(&self, p1: Pt, p2: Pt) -> impl Iterator<Item = Pt> + use<'_> {
+        let diff = p1 - p2;
+        let from_p1 = successors(Some(p1), move |&pt| {
+            let next = pt + diff;
+            next.within(self.x_bounds.clone(), self.y_bounds.clone())
+                .then_some(next)
+        });
+        let from_p2 = successors(Some(p2), move |&pt| {
+            let next = pt - diff;
+            next.within(self.x_bounds.clone(), self.y_bounds.clone())
+                .then_some(next)
+        });
+        from_p1.chain(from_p2)
+    }
+}
+
+impl Default for Map {
+    fn default() -> Self {
+        let antennas_matrix = input();
+
+        let y_bounds = 0..antennas_matrix.len() as i64;
+        let x_bounds = 0..antennas_matrix[0].len() as i64;
+        let antennas = matrix_to_map(antennas_matrix)
+            .into_iter()
+            .filter(|&(_, c)| c != '.')
+            .collect();
+
+        Self { x_bounds, y_bounds, antennas }
+    }
+}
+
+fn input() -> Vec<Vec<char>> {
+    safe_get_input_as_terrain(2024, 8)
+}

aoclp_solutions/src/y2024/mod.rs

@@ -5,3 +5,4 @@ pub mod day_04;
 pub mod day_05;
 pub mod day_06;
 pub mod day_07;
+pub mod day_08;