Add problem 2373: Largest Local Values in a Matrix

Author: EFanZh

src/lib.rs

@@ -1765,6 +1765,7 @@ pub mod problem_2367_number_of_arithmetic_triplets;
 pub mod problem_2368_reachable_nodes_with_restrictions;
 pub mod problem_2369_check_if_there_is_a_valid_partition_for_the_array;
 pub mod problem_2370_longest_ideal_subsequence;
+pub mod problem_2373_largest_local_values_in_a_matrix;
 
 #[cfg(test)]
 mod test_utilities;

src/problem_2373_largest_local_values_in_a_matrix/iterative.rs

@@ -0,0 +1,53 @@
+pub struct Solution;
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl Solution {
+    #[expect(single_use_lifetimes, reason = "false-positive")]
+    fn conv_1d<'a>(mut iter: impl Iterator<Item = &'a mut i32>) {
+        let mut prev_1 = iter.next().unwrap();
+        let mut prev_2 = iter.next().unwrap();
+
+        for value in iter {
+            *prev_1 = (*prev_1).max(*prev_2).max(*value);
+            prev_1 = prev_2;
+            prev_2 = value;
+        }
+    }
+
+    pub fn largest_local(grid: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
+        let mut grid = grid;
+        let result_rows = grid.len() - 2;
+        let result_columns = grid.first().map_or(0, Vec::len) - 2;
+
+        for row in &mut grid {
+            Self::conv_1d(row.iter_mut());
+
+            row.truncate(result_columns);
+        }
+
+        for column in 0..result_columns {
+            Self::conv_1d(grid.iter_mut().map(|row| &mut row[column]));
+        }
+
+        grid.truncate(result_rows);
+
+        grid
+    }
+}
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl super::Solution for Solution {
+    fn largest_local(grid: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
+        Self::largest_local(grid)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_solution() {
+        super::super::tests::run::<super::Solution>();
+    }
+}

src/problem_2373_largest_local_values_in_a_matrix/mod.rs

@@ -0,0 +1,34 @@
+pub mod iterative;
+
+pub trait Solution {
+    fn largest_local(grid: Vec<Vec<i32>>) -> Vec<Vec<i32>>;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+    use crate::test_utilities::Matrix;
+
+    pub fn run<S: Solution>() {
+        let test_cases = [
+            (
+                &[[9, 9, 8, 1], [5, 6, 2, 6], [8, 2, 6, 4], [6, 2, 2, 2]] as &dyn Matrix<_>,
+                &[[9, 9], [8, 6]] as &dyn Matrix<_>,
+            ),
+            (
+                &[
+                    [1, 1, 1, 1, 1],
+                    [1, 1, 1, 1, 1],
+                    [1, 1, 2, 1, 1],
+                    [1, 1, 1, 1, 1],
+                    [1, 1, 1, 1, 1],
+                ],
+                &[[2, 2, 2], [2, 2, 2], [2, 2, 2]],
+            ),
+        ];
+
+        for (grid, expected) in test_cases {
+            assert_eq!(S::largest_local(grid.to_vec()), expected);
+        }
+    }
+}