chore: y2025::day_04

Author: clechasseur

aoclp/src/positioning/pt.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::convert::Infallible;
 use std::fmt::{Debug, Display, Formatter};
 use std::hash::Hash;
@@ -197,3 +197,30 @@ where
         })
         .collect()
 }
+
+/// Given a two-dimensional matrix of elements, returns a map of
+/// [`Pt`] associated with the element at that position in the matrix,
+/// ignoring any element that are in `skips`.
+pub fn filtered_matrix_to_map<M, R, T, PT, S>(matrix: M, skips: S) -> HashMap<Pt<PT>, T>
+where
+    M: IntoIterator<Item = R>,
+    R: IntoIterator<Item = T>,
+    PT: TryFrom<usize>,
+    <PT as TryFrom<usize>>::Error: Debug,
+    Pt<PT>: Hash + Eq,
+    S: IntoIterator<Item = T>,
+    T: Hash + Eq,
+{
+    let skips: HashSet<_> = skips.into_iter().collect();
+
+    matrix
+        .into_iter()
+        .enumerate()
+        .flat_map(|(y, row)| {
+            row.into_iter()
+                .enumerate()
+                .filter(|(_, t)| !skips.contains(t))
+                .map(move |(x, t)| (Pt::new(x.try_into().unwrap(), y.try_into().unwrap()), t))
+        })
+        .collect()
+}

aoclp_solutions/src/y2025/day_04.rs

@@ -1,7 +1,38 @@
+use std::collections::{BTreeSet, HashSet};
+
+use aoclp::positioning::pt::{filtered_matrix_to_map, Pt};
+use aoclp::solvers_impl::input::safe_get_input_as_terrain;
+
 pub fn part_1() -> usize {
-    0
+    let rolls: HashSet<Pt> = filtered_matrix_to_map(input(), ['.']).into_keys().collect();
+
+    rolls
+        .iter()
+        .filter(|p| p.eight_neighbours().filter(|n| rolls.contains(n)).count() < 4)
+        .count()
 }
 
 pub fn part_2() -> usize {
-    0
+    let mut rolls: BTreeSet<Pt> = filtered_matrix_to_map(input(), ['.']).into_keys().collect();
+
+    let mut removed = 0;
+    loop {
+        let removables: BTreeSet<_> = rolls
+            .iter()
+            .filter(|p| p.eight_neighbours().filter(|n| rolls.contains(n)).count() < 4)
+            .copied()
+            .collect();
+        if removables.is_empty() {
+            break;
+        }
+
+        removed += removables.len();
+        rolls = rolls.difference(&removables).copied().collect();
+    }
+
+    removed
+}
+
+fn input() -> Vec<Vec<char>> {
+    safe_get_input_as_terrain(2025, 4)
 }