[2025] Cleanup day 4

Author: connorslade

aoc_2025/src/day_04.rs

@@ -1,32 +1,21 @@
-use aoc_lib::matrix::Grid;
+use aoc_lib::{direction::ordinal, matrix::Grid};
 use common::{Answer, solution};
-use nd_vec::Vec2;
 
 solution!("Printing Department", 4);
 
-#[derive(Clone)]
+#[derive(Clone, PartialEq, Eq)]
 enum Tile {
     Empty,
     Roll,
 }
 
 fn part_a(input: &str) -> Answer {
-    let grid = Grid::parse(input, |chr| match chr {
-        '.' => Tile::Empty,
-        '@' => Tile::Roll,
-        _ => panic!(),
-    });
-
-    count(&grid).0.into()
+    let (count, _) = count(&parse(input));
+    count.into()
 }
 
 fn part_b(input: &str) -> Answer {
-    let mut grid = Grid::parse(input, |chr| match chr {
-        '.' => Tile::Empty,
-        '@' => Tile::Roll,
-        _ => panic!(),
-    });
-
+    let mut grid = parse(input);
     let mut out = 0;
 
     loop {
@@ -41,47 +30,32 @@ fn part_b(input: &str) -> Answer {
     out.into()
 }
 
-fn count(grid: &Grid<Tile>) -> (u32, Grid<Tile>) {
-    let mut out = 0;
+fn parse(input: &str) -> Grid<Tile> {
+    Grid::parse(input, |chr| match chr {
+        '.' => Tile::Empty,
+        '@' => Tile::Roll,
+        _ => panic!(),
+    })
+}
 
+fn count(grid: &Grid<Tile>) -> (u32, Grid<Tile>) {
     let mut next = grid.clone();
+    let mut count = 0;
 
-    for y in 0..grid.size.y() {
-        for x in 0..grid.size().x() {
-            let pos = Vec2::new([x, y]).num_cast::<i32>().unwrap();
-            if matches!(grid.get(pos.num_cast().unwrap()).unwrap(), Tile::Empty) {
-                continue;
-            }
-
-            let mut neighbors = 0;
-            for dy in -1..=1 {
-                for dx in -1..=1 {
-                    let delta = Vec2::new([dx, dy]);
-                    let check = pos + delta;
-
-                    if delta == Vec2::zero()
-                        || check.x() < 0
-                        || check.y() < 0
-                        || check.x() >= grid.size.x() as i32
-                        || check.y() >= grid.size.y() as i32
-                    {
-                        continue;
-                    }
-
-                    if matches!(grid.get(check.num_cast().unwrap()).unwrap(), Tile::Roll) {
-                        neighbors += 1;
-                    }
-                }
-            }
+    for (pos, _tile) in grid.iter().filter(|x| *x.1 == Tile::Roll) {
+        let mut neighbors = 0;
+        for dir in ordinal::Direction::ALL {
+            let tile = dir.try_advance(pos).and_then(|pos| grid.get(pos));
+            neighbors += (tile == Some(&Tile::Roll)) as u32;
+        }
 
-            if neighbors < 4 {
-                out += 1;
-                next.set(pos, Tile::Empty);
-            }
+        if neighbors < 4 {
+            count += 1;
+            next.set(pos, Tile::Empty);
         }
     }
 
-    (out, next)
+    (count, next)
 }
 
 #[cfg(test)]