Add problem 2966: Divide Array Into Arrays With Max Difference

Author: EFanZh

src/lib.rs

@@ -2032,6 +2032,7 @@ pub mod problem_2960_count_tested_devices_after_test_operations;
 pub mod problem_2961_double_modular_exponentiation;
 pub mod problem_2962_count_subarrays_where_max_element_appears_at_least_k_times;
 pub mod problem_2965_find_missing_and_repeated_values;
+pub mod problem_2966_divide_array_into_arrays_with_max_difference;
 
 #[cfg(test)]
 mod test_utilities;

src/problem_2966_divide_array_into_arrays_with_max_difference/greedy.rs

@@ -0,0 +1,41 @@
+pub struct Solution;
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl Solution {
+    pub fn divide_array(nums: Vec<i32>, k: i32) -> Vec<Vec<i32>> {
+        let mut nums = nums;
+        let k = k.cast_unsigned();
+
+        nums.sort_unstable_by_key(|num| num.cast_unsigned());
+
+        nums.chunks_exact(3)
+            .map(|window| {
+                let window @ [min, _, max] = window.try_into().ok().unwrap();
+
+                if (max - min).cast_unsigned() <= k {
+                    Ok(window.to_vec())
+                } else {
+                    Err(())
+                }
+            })
+            .collect::<Result<_, _>>()
+            .unwrap_or_default()
+    }
+}
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl super::Solution for Solution {
+    fn divide_array(nums: Vec<i32>, k: i32) -> Vec<Vec<i32>> {
+        Self::divide_array(nums, k)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_solution() {
+        super::super::tests::run::<super::Solution>();
+    }
+}

src/problem_2966_divide_array_into_arrays_with_max_difference/mod.rs

@@ -0,0 +1,40 @@
+pub mod greedy;
+
+pub trait Solution {
+    fn divide_array(nums: Vec<i32>, k: i32) -> Vec<Vec<i32>>;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+    use crate::test_utilities;
+
+    pub fn run<S: Solution>() {
+        let test_cases = [
+            ((&[1, 3, 4, 8, 7, 9, 3, 5, 1] as &[_], 2), true),
+            ((&[2, 4, 2, 2, 5, 2], 2), false),
+            ((&[4, 2, 9, 8, 2, 12, 7, 12, 10, 5, 8, 5, 5, 7, 9, 2, 5, 11], 14), true),
+        ];
+
+        for ((nums, k), expected) in test_cases {
+            let result = S::divide_array(nums.to_vec(), k);
+
+            if expected {
+                assert_eq!(
+                    test_utilities::unstable_sorted(nums.iter().copied()),
+                    test_utilities::unstable_sorted(result.iter().flatten().copied()),
+                );
+
+                for item in result {
+                    let mut item: [_; 3] = item.try_into().ok().unwrap();
+
+                    item.sort_unstable();
+
+                    assert!(item[2] - item[0] <= k);
+                }
+            } else {
+                assert!(result.is_empty());
+            }
+        }
+    }
+}