Add problem 2948: Make Lexicographically Smallest Array by Swapping Elements

Author: EFanZh

src/lib.rs

@@ -2022,6 +2022,7 @@ pub mod problem_2938_separate_black_and_white_balls;
 pub mod problem_2942_find_words_containing_character;
 pub mod problem_2943_maximize_area_of_square_hole_in_grid;
 pub mod problem_2946_matrix_similarity_after_cyclic_shifts;
+pub mod problem_2948_make_lexicographically_smallest_array_by_swapping_elements;
 
 #[cfg(test)]
 mod test_utilities;

src/problem_2948_make_lexicographically_smallest_array_by_swapping_elements/iterative.rs

@@ -0,0 +1,59 @@
+pub struct Solution;
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl Solution {
+    fn sort_group(targets: &mut [&mut i32], buffer: &mut Vec<i32>) {
+        buffer.extend(targets.iter().map(|&&mut num| num));
+        targets.sort_unstable_by_key(|target| &raw const **target);
+
+        targets
+            .iter_mut()
+            .zip(&*buffer)
+            .for_each(|(target, &value)| **target = value);
+    }
+
+    pub fn lexicographically_smallest_array(nums: Vec<i32>, limit: i32) -> Vec<i32> {
+        let mut nums = nums;
+        let limit = limit as u32;
+        let mut nums_sorted = nums.iter_mut().collect::<Box<_>>();
+
+        nums_sorted.sort_unstable_by_key(|&&mut x| x as u32);
+
+        let mut prev = limit.wrapping_neg();
+        let mut buffer = Vec::new();
+        let mut group_start = 0;
+
+        for i in 0..nums_sorted.len() {
+            let value = *nums_sorted[i] as u32;
+
+            if value.wrapping_sub(prev) > limit {
+                Self::sort_group(&mut nums_sorted[group_start..i], &mut buffer);
+                buffer.clear();
+                group_start = i;
+            }
+
+            prev = value;
+        }
+
+        Self::sort_group(&mut nums_sorted[group_start..], &mut buffer);
+
+        nums
+    }
+}
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl super::Solution for Solution {
+    fn lexicographically_smallest_array(nums: Vec<i32>, limit: i32) -> Vec<i32> {
+        Self::lexicographically_smallest_array(nums, limit)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_solution() {
+        super::super::tests::run::<super::Solution>();
+    }
+}

src/problem_2948_make_lexicographically_smallest_array_by_swapping_elements/mod.rs

@@ -0,0 +1,22 @@
+pub mod iterative;
+
+pub trait Solution {
+    fn lexicographically_smallest_array(nums: Vec<i32>, limit: i32) -> Vec<i32>;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    pub fn run<S: Solution>() {
+        let test_cases = [
+            ((&[1, 5, 3, 9, 8] as &[_], 2), &[1, 3, 5, 8, 9] as &[_]),
+            ((&[1, 7, 6, 18, 2, 1], 3), &[1, 6, 7, 18, 1, 2]),
+            ((&[1, 7, 28, 19, 10], 3), &[1, 7, 28, 19, 10]),
+        ];
+
+        for ((nums, limit), expected) in test_cases {
+            assert_eq!(S::lexicographically_smallest_array(nums.to_vec(), limit), expected);
+        }
+    }
+}