2024-04 Rust & Scala

Author: jurisk

ReadMe.md

@@ -6,6 +6,7 @@
 
 | Year-Day | Task                                                                           |                                  Scala                                  |                      Rust                      |                                 Others                                 |
 |----------|:-------------------------------------------------------------------------------|:-----------------------------------------------------------------------:|:----------------------------------------------:|:----------------------------------------------------------------------:|
+| 2024-04  | [Ceres Search](https://adventofcode.com/2024/day/4)                            | [Scala](scala2/src/main/scala/jurisk/adventofcode/y2024/Advent04.scala) | [Rust](rust/y2024/src/bin/solution_2024_04.rs) |                                                                        |
 | 2024-03  | [Mull It Over](https://adventofcode.com/2024/day/3)                            | [Scala](scala2/src/main/scala/jurisk/adventofcode/y2024/Advent03.scala) | [Rust](rust/y2024/src/bin/solution_2024_03.rs) |                                                                        |
 | 2024-02  | [Red-Nosed Reports](https://adventofcode.com/2024/day/2)                       | [Scala](scala2/src/main/scala/jurisk/adventofcode/y2024/Advent02.scala) | [Rust](rust/y2024/src/bin/solution_2024_02.rs) |                                                                        |
 | 2024-01  | [Historian Hysteria](https://adventofcode.com/2024/day/1)                      | [Scala](scala2/src/main/scala/jurisk/adventofcode/y2024/Advent01.scala) | [Rust](rust/y2024/src/bin/solution_2024_01.rs) |                                                                        |

rust/Cargo.lock

@@ -0,0 +1,62 @@
+use std::ops::{Add, Neg};
+
+use num_traits::Num;
+
+use crate::coords2d::Coords2D;
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub enum DirectionWithDiagonals {
+    N,
+    NE,
+    E,
+    SE,
+    S,
+    SW,
+    W,
+    NW,
+}
+
+impl DirectionWithDiagonals {
+    #[must_use]
+    pub const fn all() -> [Self; 8] {
+        [
+            Self::N,
+            Self::NE,
+            Self::E,
+            Self::SE,
+            Self::S,
+            Self::SW,
+            Self::W,
+            Self::NW,
+        ]
+    }
+}
+
+impl<N> From<DirectionWithDiagonals> for Coords2D<N>
+where
+    N: Num + Neg<Output = N> + Copy,
+{
+    fn from(value: DirectionWithDiagonals) -> Self {
+        match value {
+            DirectionWithDiagonals::N => Coords2D::new(N::zero(), N::one()),
+            DirectionWithDiagonals::NE => Coords2D::new(N::one(), N::one()),
+            DirectionWithDiagonals::E => Coords2D::new(N::one(), N::zero()),
+            DirectionWithDiagonals::SE => Coords2D::new(N::one(), -N::one()),
+            DirectionWithDiagonals::S => Coords2D::new(N::zero(), -N::one()),
+            DirectionWithDiagonals::SW => Coords2D::new(-N::one(), -N::one()),
+            DirectionWithDiagonals::W => Coords2D::new(-N::one(), N::zero()),
+            DirectionWithDiagonals::NW => Coords2D::new(-N::one(), N::one()),
+        }
+    }
+}
+
+impl<N> Add<DirectionWithDiagonals> for Coords2D<N>
+where
+    N: Num + Neg<Output = N> + Copy,
+{
+    type Output = Coords2D<N>;
+
+    fn add(self, rhs: DirectionWithDiagonals) -> Self::Output {
+        self + Coords2D::from(rhs)
+    }
+}

rust/common/src/direction_with_diagonals.rs

@@ -0,0 +1,96 @@
+#![expect(clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+
+use std::iter::Sum;
+use std::str::FromStr;
+
+use pathfinding::matrix::Matrix;
+
+use crate::coords2d::Coords2D;
+use crate::parsing::parse_matrix;
+
+pub type Coords = Coords2D<i32>;
+
+pub trait Grid2D<T> {
+    fn map_by_coords<F, U>(&self, f: F) -> MatrixGrid2D<U>
+    where
+        F: Fn(Coords) -> U;
+
+    fn count<F>(&self, f: F) -> usize
+    where
+        F: Fn(Coords, &T) -> bool;
+
+    fn get(&self, coords: Coords) -> Option<&T>;
+
+    fn get_or_else(&self, coords: Coords, default: T) -> T
+    where
+        T: Clone,
+    {
+        self.get(coords).cloned().unwrap_or(default)
+    }
+
+    fn sum(&self) -> T
+    where
+        T: Sum + Clone;
+}
+
+pub struct MatrixGrid2D<T> {
+    data: Matrix<T>,
+}
+
+impl From<(usize, usize)> for Coords {
+    fn from(value: (usize, usize)) -> Self {
+        let (x, y) = value;
+        Coords::new(x as i32, y as i32)
+    }
+}
+
+impl From<Coords> for (usize, usize) {
+    fn from(coords: Coords) -> Self {
+        (coords.x as usize, coords.y as usize)
+    }
+}
+
+impl<T> Grid2D<T> for MatrixGrid2D<T> {
+    fn map_by_coords<F, U>(&self, f: F) -> MatrixGrid2D<U>
+    where
+        F: Fn(Coords) -> U,
+    {
+        let new_data = self
+            .data
+            .keys()
+            .map(|coords| f(Coords::from(coords)))
+            .collect();
+        MatrixGrid2D {
+            data: Matrix::from_vec(self.data.rows, self.data.columns, new_data).unwrap(),
+        }
+    }
+
+    fn count<F>(&self, f: F) -> usize
+    where
+        F: Fn(Coords, &T) -> bool,
+    {
+        self.data
+            .keys()
+            .filter(|coords| f(Coords::from(*coords), &self.data[*coords]))
+            .count()
+    }
+
+    fn get(&self, coords: Coords) -> Option<&T> {
+        self.data.get(coords.into())
+    }
+
+    fn sum(&self) -> T
+    where
+        T: Sum + Clone,
+    {
+        self.data.values().cloned().sum()
+    }
+}
+
+impl FromStr for MatrixGrid2D<char> {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        parse_matrix(s, Ok).map(|data| MatrixGrid2D { data })
+    }
+}

rust/common/src/grid2d.rs

@@ -9,6 +9,8 @@ pub mod cryptography;
 pub mod cuboid;
 pub mod direction;
 pub mod direction_hex;
+pub mod direction_with_diagonals;
+pub mod grid2d;
 pub mod math;
 pub mod matrices;
 pub mod pairing;

rust/common/src/lib.rs

@@ -11,5 +11,6 @@ workspace = true
 
 [dependencies]
 advent-of-code-common = { path = "../common" }
+pathfinding.workspace = true
 itertools.workspace = true
 regex.workspace = true

rust/y2024/Cargo.toml

@@ -0,0 +1,10 @@
+MMMSXXMASM
+MSAMXMSMSA
+AMXSXMAAMM
+MSAMASMSMX
+XMASAMXAMM
+XXAMMXXAMA
+SMSMSASXSS
+SAXAMASAAA
+MAMMMXMMMM
+MXMXAXMASX