🧻

Author: Tom-Willemsen

aoc2025_wasm/inputs

@@ -0,0 +1,34 @@
+use anyhow::{Context, Result};
+use ndarray::Array2;
+
+pub fn make_byte_grid(raw_inp: &str) -> Result<Array2<u8>> {
+    let columns = raw_inp
+        .trim()
+        .bytes()
+        .position(|c| c == b'\n')
+        .context("can't get column count")?;
+
+    Array2::from_shape_vec(
+        ((raw_inp.trim().len() + 1) / (columns + 1), columns),
+        raw_inp.bytes().filter(|&x| x != b'\n').collect(),
+    )
+    .context("can't make array")
+}
+
+pub fn make_bool_grid<const TRUE_CHAR: u8>(raw_inp: &str) -> Result<Array2<bool>> {
+    let columns = raw_inp
+        .trim()
+        .bytes()
+        .position(|c| c == b'\n')
+        .context("can't get column count")?;
+
+    Array2::from_shape_vec(
+        ((raw_inp.trim().len() + 1) / (columns + 1), columns),
+        raw_inp
+            .bytes()
+            .filter(|&x| x != b'\n')
+            .map(|b| b == TRUE_CHAR)
+            .collect(),
+    )
+    .context("can't make array")
+}

aoc2025_wasm/src/grid_util.rs

@@ -0,0 +1,84 @@
+use anyhow::Result;
+use ndarray::Array2;
+
+fn neighbours(grid: &Array2<bool>, y: usize, x: usize) -> usize {
+    [
+        (y.wrapping_sub(1), x.wrapping_sub(1)),
+        (y.wrapping_sub(1), x),
+        (y.wrapping_sub(1), x.wrapping_add(1)),
+        (y, x.wrapping_sub(1)),
+        (y, x.wrapping_add(1)),
+        (y.wrapping_add(1), x.wrapping_sub(1)),
+        (y.wrapping_add(1), x),
+        (y.wrapping_add(1), x.wrapping_add(1)),
+    ]
+    .into_iter()
+    .filter(|&(y, x)| *grid.get((y, x)).unwrap_or(&false))
+    .count()
+}
+
+fn calculate_p1(grid: &Array2<bool>) -> usize {
+    grid.indexed_iter()
+        .filter(|&((y, x), itm)| *itm && neighbours(grid, y, x) < 4)
+        .count()
+}
+
+fn calculate_p2(mut grid: Array2<bool>) -> u32 {
+    let mut p2 = 0;
+    let mut changed = true;
+
+    while changed {
+        changed = false;
+
+        for y in 0..grid.dim().0 {
+            for x in 0..grid.dim().1 {
+                if *grid.get((y, x)).expect("indexes are valid") && neighbours(&grid, y, x) < 4 {
+                    *grid.get_mut((y, x)).expect("indexes are valid") = false;
+                    p2 += 1;
+                    changed = true;
+                }
+            }
+        }
+    }
+
+    p2
+}
+
+pub fn run_2025_04(inp: &str) -> Result<String> {
+    let grid = crate::grid_util::make_bool_grid::<b'@'>(inp)?;
+    let p1 = calculate_p1(&grid);
+    let p2 = calculate_p2(grid);
+    Ok(format!("{p1}\n{p2}"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const EXAMPLE_DATA: &str = include_str!("../inputs/examples/2025_04");
+    const REAL_DATA: &str = include_str!("../inputs/real/2025_04");
+
+    #[test]
+    fn test_example_p1() {
+        let grid = crate::grid_util::make_bool_grid::<b'@'>(EXAMPLE_DATA).unwrap();
+        assert_eq!(calculate_p1(&grid), 13);
+    }
+
+    #[test]
+    fn test_example_p2() {
+        let grid = crate::grid_util::make_bool_grid::<b'@'>(EXAMPLE_DATA).unwrap();
+        assert_eq!(calculate_p2(grid), 43);
+    }
+
+    #[test]
+    fn test_real_p1() {
+        let grid = crate::grid_util::make_bool_grid::<b'@'>(REAL_DATA).unwrap();
+        assert_eq!(calculate_p1(&grid), 1349);
+    }
+
+    #[test]
+    fn test_real_p2() {
+        let grid = crate::grid_util::make_bool_grid::<b'@'>(REAL_DATA).unwrap();
+        assert_eq!(calculate_p2(grid), 8277);
+    }
+}

aoc2025_wasm/src/impl_2025_04.rs

@@ -1,6 +1,8 @@
+pub mod grid_util;
 mod impl_2025_01;
 mod impl_2025_02;
 mod impl_2025_03;
+mod impl_2025_04;
 
 pub use wasm_bindgen_rayon::init_thread_pool;
 
@@ -13,6 +15,7 @@ pub fn run_day(day: u32, input: &str) -> String {
         1 => impl_2025_01::run_2025_01(input),
         2 => impl_2025_02::run_2025_02(input),
         3 => impl_2025_03::run_2025_03(input),
+        4 => impl_2025_04::run_2025_04(input),
         _ => Err(anyhow!("No solution for that day yet")),
     };