Add problem 2771: Longest Non-decreasing Subarray From Two Arrays

Author: EFanZh

src/lib.rs

@@ -1963,6 +1963,7 @@ pub mod problem_2761_prime_pairs_with_target_sum;
 pub mod problem_2765_longest_alternating_subarray;
 pub mod problem_2766_relocate_marbles;
 pub mod problem_2769_find_the_maximum_achievable_number;
+pub mod problem_2771_longest_non_decreasing_subarray_from_two_arrays;
 
 #[cfg(test)]
 mod test_utilities;

src/problem_2771_longest_non_decreasing_subarray_from_two_arrays/iterative.rs

@@ -0,0 +1,59 @@
+pub struct Solution;
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+use std::{iter, mem};
+
+impl Solution {
+    pub fn max_non_decreasing_length(nums1: Vec<i32>, nums2: Vec<i32>) -> i32 {
+        let mut prev_1 = 0;
+        let mut length_1 = 0;
+        let mut prev_2 = 0;
+        let mut length_2 = 0;
+        let mut result = 0;
+
+        iter::zip(nums1, nums2).for_each(|(num1, num2)| {
+            let (mut x, mut y) = (num1 as u32, num2 as u32);
+
+            if y < x {
+                mem::swap(&mut x, &mut y);
+            }
+
+            let new_length_1 = if x < prev_1 {
+                1
+            } else {
+                (if x < prev_2 { length_1 } else { length_2 }) + 1
+            };
+
+            let new_length_2 = if y < prev_1 {
+                1
+            } else {
+                (if y < prev_2 { length_1 } else { length_2 }) + 1
+            };
+
+            prev_1 = x;
+            length_1 = new_length_1;
+            prev_2 = y;
+            length_2 = new_length_2;
+            result = u32::max(result, length_2);
+        });
+
+        result as _
+    }
+}
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl super::Solution for Solution {
+    fn max_non_decreasing_length(nums1: Vec<i32>, nums2: Vec<i32>) -> i32 {
+        Self::max_non_decreasing_length(nums1, nums2)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_solution() {
+        super::super::tests::run::<super::Solution>();
+    }
+}

src/problem_2771_longest_non_decreasing_subarray_from_two_arrays/mod.rs

@@ -0,0 +1,24 @@
+pub mod iterative;
+
+pub trait Solution {
+    fn max_non_decreasing_length(nums1: Vec<i32>, nums2: Vec<i32>) -> i32;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    pub fn run<S: Solution>() {
+        let test_cases = [
+            ((&[2, 3, 1] as &[_], &[1, 2, 1] as &[_]), 2),
+            ((&[1, 3, 2, 1], &[2, 2, 3, 4]), 4),
+            ((&[1, 1], &[2, 2]), 2),
+            ((&[4, 2], &[10, 4]), 2),
+            ((&[3, 19, 13, 19], &[20, 18, 7, 14]), 2),
+        ];
+
+        for ((nums1, nums2), expected) in test_cases {
+            assert_eq!(S::max_non_decreasing_length(nums1.to_vec(), nums2.to_vec()), expected);
+        }
+    }
+}