Add problem 2614: Prime In Diagonal

Author: EFanZh

src/lib.rs

@@ -1928,6 +1928,7 @@ pub mod problem_2601_prime_subtraction_operation;
 pub mod problem_2602_minimum_operations_to_make_all_array_elements_equal;
 pub mod problem_2609_find_the_longest_balanced_substring_of_a_binary_string;
 pub mod problem_2610_convert_an_array_into_a_2d_array_with_conditions;
+pub mod problem_2614_prime_in_diagonal;
 
 #[cfg(test)]
 mod test_utilities;

src/problem_2614_prime_in_diagonal/iterative.rs

@@ -0,0 +1,57 @@
+pub struct Solution;
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl Solution {
+    fn is_prime(num: u32) -> bool {
+        if num < 2 {
+            false
+        } else {
+            let sqrt = num.isqrt();
+
+            for x in 2..=sqrt {
+                if num % x == 0 {
+                    return false;
+                }
+            }
+
+            true
+        }
+    }
+
+    pub fn diagonal_prime(nums: Vec<Vec<i32>>) -> i32 {
+        let n = nums.len();
+        let mut result = 0;
+
+        for (i, row) in nums.iter().enumerate() {
+            let x = row[i] as u32;
+            let y = row[n - 1 - i] as u32;
+
+            if Self::is_prime(x) {
+                result = result.max(x);
+            }
+
+            if Self::is_prime(y) {
+                result = result.max(y);
+            }
+        }
+
+        result as _
+    }
+}
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl super::Solution for Solution {
+    fn diagonal_prime(nums: Vec<Vec<i32>>) -> i32 {
+        Self::diagonal_prime(nums)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_solution() {
+        super::super::tests::run::<super::Solution>();
+    }
+}

src/problem_2614_prime_in_diagonal/mod.rs

@@ -0,0 +1,23 @@
+pub mod iterative;
+pub mod sieve_of_eratosthenes;
+
+pub trait Solution {
+    fn diagonal_prime(nums: Vec<Vec<i32>>) -> i32;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+    use crate::test_utilities::Matrix;
+
+    pub fn run<S: Solution>() {
+        let test_cases = [
+            (&[[1, 2, 3], [5, 6, 7], [9, 10, 11]] as &dyn Matrix<_>, 11),
+            (&[[1, 2, 3], [5, 17, 7], [9, 11, 10]], 17),
+        ];
+
+        for (nums, expected) in test_cases {
+            assert_eq!(S::diagonal_prime(nums.to_vec()), expected);
+        }
+    }
+}

src/problem_2614_prime_in_diagonal/sieve_of_eratosthenes.rs

@@ -0,0 +1,52 @@
+pub struct Solution;
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl Solution {
+    pub fn diagonal_prime(nums: Vec<Vec<i32>>) -> i32 {
+        let n_minus_1 = nums.len() - 1;
+
+        let candidates = nums
+            .iter()
+            .enumerate()
+            .flat_map(|(i, row)| [row[i] as u32, row[n_minus_1 - i] as u32])
+            .collect::<Vec<_>>();
+
+        let max = candidates.iter().fold(0, |max, &x| max.max(x));
+        let mut states = vec![false; max as usize - 1].into_boxed_slice();
+
+        for i in 2..=max.isqrt() as usize {
+            if !states[i - 2] {
+                states[i * i - 2..]
+                    .iter_mut()
+                    .step_by(i)
+                    .for_each(|is_composite| *is_composite = true);
+            }
+        }
+
+        candidates
+            .iter()
+            .filter(|&&x| {
+                states
+                    .get((x as usize).wrapping_sub(2))
+                    .is_some_and(|&is_composite| !is_composite)
+            })
+            .fold(0, |max, &x| max.max(x)) as _
+    }
+}
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl super::Solution for Solution {
+    fn diagonal_prime(nums: Vec<Vec<i32>>) -> i32 {
+        Self::diagonal_prime(nums)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_solution() {
+        super::super::tests::run::<super::Solution>();
+    }
+}