Day 4 Rust solutions

Author: creideiki

day-04/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "day-04"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+nalgebra = "*"
+
+[[bin]]
+name = "04-1"
+path = "src/04-1.rs"
+
+[[bin]]
+name = "04-2"
+path = "src/04-2.rs"

day-04/src/04-1.rs

@@ -0,0 +1,62 @@
+use std::fs;
+
+fn find_dir(
+    haystack: &Vec<Vec<u32>>,
+    needle: &[u32],
+    x: i32,
+    y: i32,
+    dx: i32,
+    dy: i32,
+) -> bool {
+    if needle.len() == 0 { return true; }
+
+    if x < 0 ||
+        x >= haystack[0].len() as i32 ||
+        y < 0 ||
+        y >= haystack.len() as i32 {
+            return false;
+        }
+
+    if haystack[y as usize][x as usize] != needle[0] { return false; }
+
+    find_dir(&haystack, &needle[1..], x + dx, y + dy, dx, dy)
+}
+
+fn find(
+    haystack: &Vec<Vec<u32>>,
+    x: usize,
+    y: usize,
+) -> usize {
+    let needle = ['X', 'M', 'A', 'S'].map(|c| c as u32);
+
+    let mut count = 0;
+    for dx in -1..=1 {
+        for dy in -1..=1 {
+            if dx == 0 && dy == 0 { continue; }
+
+            if find_dir(&haystack, &needle, x as i32, y as i32, dx, dy) {
+                count += 1
+            }
+        }
+    }
+
+    count
+}
+
+fn main() {
+    let haystack: Vec<Vec<u32>> = fs::read_to_string("../04.input")
+        .unwrap()
+        .lines()
+        .map(|l| l.chars().map(|c| c as u32).collect())
+        .collect();
+
+    let mut count: usize = 0;
+
+    for y in 0..haystack.len() {
+        for x in 0..haystack[0].len() {
+            count += find(&haystack, x, y);
+        }
+    }
+
+    println!("{}", count);
+}

day-04/src/04-2.rs

@@ -0,0 +1,93 @@
+extern crate nalgebra as na;
+use na::{DMatrix, Matrix3, matrix};
+
+use std::fs;
+
+#[derive(Debug)]
+struct Puzzle {
+    height: usize,
+    width: usize,
+    map: DMatrix<u32>,
+    mas_height: usize,
+    mas_width: usize,
+    xmases: Vec<Matrix3<u32>>,
+}
+
+impl Puzzle {
+    fn new(data: &str) -> Puzzle {
+        let height = data.lines().count();
+        let width = data.lines().nth(0).unwrap().chars().count();
+
+        let mut map = DMatrix::zeros(height, width);
+
+        for (row, line) in data.lines().enumerate() {
+            for (col, c) in line.chars().enumerate() {
+                map[(row, col)] = c as u32;
+            }
+        }
+
+        let mas1 = matrix!['M' as u32, '.' as u32, 'S' as u32;
+                           '.' as u32, 'A' as u32, '.' as u32;
+                           'M' as u32, '.' as u32, 'S' as u32];
+        let mas2 = matrix![0, 0, 1;
+                           0, 1, 0;
+                           1, 0, 0] * mas1.transpose();
+        let mas3 = matrix![0, 0, 1;
+                           0, 1, 0;
+                           1, 0, 0] * mas2.transpose();
+        let mas4 = matrix![0, 0, 1;
+                           0, 1, 0;
+                           1, 0, 0] * mas3.transpose();
+        let xmases = vec![
+            mas1,
+            mas2,
+            mas3,
+            mas4,
+        ];
+
+        Puzzle {
+            height,
+            width,
+            map,
+            mas_height: 3,
+            mas_width: 3,
+            xmases,
+        }
+    }
+
+    fn match_p(&self, y: usize, x: usize) -> bool {
+        self.xmases.iter().any(|&xmas| {
+            let mut res = true;
+            for my in 0..self.mas_height {
+                for mx in 0..self.mas_width {
+                    if xmas[(my, mx)] == '.' as u32 { continue }
+
+                    if xmas[(my, mx)] != self.map[(y + my, x + mx)] {
+                        res = false
+                    }
+                }
+            }
+            res
+        })
+    }
+
+    fn count_matches(&self) -> i32 {
+        let mut count = 0;
+
+        for y in 0..=(self.height - self.mas_height) {
+            for x in 0..=(self.width - self.mas_width) {
+                if self.match_p(y, x) { count += 1 }
+            }
+        }
+
+        count
+    }
+}
+
+fn main() {
+    let input = fs::read_to_string("../04.input").unwrap();
+
+    let p = Puzzle::new(&input);
+
+    println!("{}", p.count_matches());
+}