LeetCode 912. Sort an Array

Author: raul-sauco

README.md

@@ -315,6 +315,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [901. Online Stock Span][lc901]                                                               | 🟠 Medium  | [![python](res/py.png)][lc901py]                                                             |
 | [904. Fruit Into Baskets][lc904]                                                              | 🟠 Medium  | [![python](res/py.png)][lc904py] [![rust](res/rs.png)][lc904rs]                              |
 | [909. Snakes and Ladders][lc909]                                                              | 🟠 Medium  | [![python](res/py.png)][lc909py] [![rust](res/rs.png)][lc909rs]                              |
+| [912. Sort an Array][lc912]                                                                   | 🟠 Medium  | [![python](res/py.png)][lc912py] [![rust](res/rs.png)][lc912rs]                              |
 | [916. Word Subsets][lc916]                                                                    | 🟠 Medium  | [![python](res/py.png)][lc916py]                                                             |
 | [918. Maximum Sum Circular Subarray][lc918]                                                   | 🟠 Medium  | [![python](res/py.png)][lc918py] [![rust](res/rs.png)][lc918rs]                              |
 | [926. Flip String to Monotone Increasing][lc926]                                              | 🟠 Medium  | [![python](res/py.png)][lc926py] [![rust](res/rs.png)][lc926rs]                              |
@@ -1062,6 +1063,9 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc909]: https://leetcode.com/problems/snakes-and-ladders/
 [lc909py]: leetcode/snakes-and-ladders.py
 [lc909rs]: leetcode/snakes-and-ladders.rs
+[lc912]: https://leetcode.com/problems/sort-an-array/
+[lc912py]: leetcode/sort-an-array.py
+[lc912rs]: leetcode/sort-an-array.rs
 [lc916]: https://leetcode.com/problems/word-subsets/
 [lc916py]: leetcode/word-subsets.py
 [lc918]: https://leetcode.com/problems/maximum-sum-circular-subarray/

leetcode/sort-an-array.py

@@ -0,0 +1,98 @@
+# 912. Sort an Array
+# 🟠 Medium
+#
+# https://leetcode.com/problems/sort-an-array/
+#
+# Tags: Array - Divide and Conquer - Sorting - Heap (Priority Queue)
+# - Merge Sort - Bucket Sort - Radix Sort - Counting Sort
+
+import timeit
+from typing import List
+
+
+# Given the conditions of the problem description, merge sort seems to
+# be a good option, it won't use any extra memory and it guarantees
+# O(n*log(n)) time complexity.
+#
+# Time complexity: O(n*log(n))
+# Space complexity: O(n) - We use one copy of the input array to
+# alternately move elements from one to the other. The call stack will
+# be of height log(n), that is an extra O(log(n)).
+#
+# Runtime 1690 ms Beats 72.17%
+# Memory 21.4 MB Beats 90.91%
+class MergeSort:
+    def sortArray(self, nums: List[int]) -> List[int]:
+        # Define an internal function that sorts a section of the input
+        # array to avoid passing copies of the array between calls.
+        def mergeSort(a: List[int], b: List[int], l: int, r: int) -> None:
+            # Base case, the array has only one element.
+            if l == r:
+                return
+            mid = l + ((r - l) // 2)
+            # Swap the function of each array in each call level.
+            mergeSort(b, a, l, mid)
+            mergeSort(b, a, mid + 1, r)
+            merge(a, b, l, mid, r)
+
+        def merge(destination, source, l, mid, r):
+            # The halves are sorted, merge them. Define i and j, two
+            # read pointers that read the next unused element in each of
+            # the sorted halves, and one insert pointer of the index at
+            # which we want to insert the next value in the result.
+            i, j, ins = l, mid + 1, l
+            while i <= mid and j <= r:
+                if source[j] < source[i]:
+                    destination[ins] = source[j]
+                    j += 1
+                else:
+                    destination[ins] = source[i]
+                    i += 1
+                ins += 1
+            # Use up any remaining elements from either half.
+            while i <= mid:
+                destination[ins] = source[i]
+                i += 1
+                ins += 1
+            while j <= r:
+                destination[ins] = source[j]
+                j += 1
+                ins += 1
+
+        # A copy of the input array that we use to alternate between
+        # sorted and unsorted sections.
+        helper = nums[:]
+        mergeSort(nums, helper, 0, len(nums) - 1)
+        return nums
+
+
+def test():
+    executors = [
+        MergeSort,
+    ]
+    tests = [
+        [[0], [0]],
+        [[1, 0], [0, 1]],
+        [[5, 2, 1], [1, 2, 5]],
+        [[5, 2, 3, 1], [1, 2, 3, 5]],
+        [[5, 1, 1, 2, 0, 0], [0, 0, 1, 1, 2, 5]],
+    ]
+    for executor in executors:
+        start = timeit.default_timer()
+        for _ in range(1):
+            for col, t in enumerate(tests):
+                sol = executor()
+                result = sol.sortArray(t[0])
+                exp = t[1]
+                assert result == exp, (
+                    f"\033[93m» {result} <> {exp}\033[91m for"
+                    + f" test {col} using \033[1m{executor.__name__}"
+                )
+        stop = timeit.default_timer()
+        used = str(round(stop - start, 5))
+        cols = "{0:20}{1:10}{2:10}"
+        res = cols.format(executor.__name__, used, "seconds")
+        print(f"\033[92m» {res}\033[0m")
+
+
+test()

leetcode/sort-an-array.rs

@@ -0,0 +1,99 @@
+// 912. Sort an Array
+// 🟠 Medium
+//
+// https://leetcode.com/problems/sort-an-array/
+//
+// Tags: Array - Divide and Conquer - Sorting - Heap (Priority Queue)
+// - Merge Sort - Bucket Sort - Radix Sort - Counting Sort
+
+struct Solution;
+impl Solution {
+    // Given the conditions of the problem description, merge sort seems to
+    // be a good option, it won't use any extra memory and it guarantees
+    // O(n*log(n)) time complexity.
+    //
+    // Time complexity: O(n*log(n))
+    // Space complexity: O(n) - We use one copy of the input array to
+    // alternately move elements from one to the other. The call stack will
+    // be of height log(n), that is an extra O(log(n)).
+    //
+    // Runtime 46 ms Beats 90.32%
+    // Memory 2.9 MB Beats 54.84%
+    pub fn sort_array(nums: Vec<i32>) -> Vec<i32> {
+        // Define an internal function that sorts a section of the input array, this
+        // avoids passing copies of the array between calls.
+        fn merge_sort(a: &mut Vec<i32>, b: &mut Vec<i32>, l: usize, r: usize) {
+            if l == r {
+                return;
+            }
+            let mid = l + ((r - l) / 2);
+            // Swap the source and destination arrays in each call.
+            merge_sort(b, a, l, mid);
+            merge_sort(b, a, mid + 1, r);
+            merge(a, b, l, mid, r);
+        }
+
+        // A function that merges two sorted halves.
+        fn merge(dest: &mut Vec<i32>, source: &mut Vec<i32>, l: usize, mid: usize, r: usize) {
+            // The halves from l to mid and mid to r are sorted in the "source" array, we can
+            // use elements from the sorted halves to update the elements in dest and end with
+            // a completely sorted slice between l and r.
+            let mut i = l;
+            let mut j = mid + 1;
+            let mut ins = l;
+            while i <= mid && j <= r {
+                if source[j] < source[i] {
+                    dest[ins] = source[j];
+                    j += 1;
+                } else {
+                    dest[ins] = source[i];
+                    i += 1;
+                }
+                ins += 1;
+            }
+            // Use up any remaining elements from either half.
+            while i <= mid {
+                dest[ins] = source[i];
+                i += 1;
+                ins += 1;
+            }
+            while j <= r {
+                dest[ins] = source[j];
+                j += 1;
+                ins += 1;
+            }
+        }
+        // Use two mutable copies of the input array to avoid copying at each call level.
+        let mut a = nums.clone();
+        let mut b = nums.clone();
+        merge_sort(&mut b, &mut a, 0, nums.len() - 1);
+        b
+    }
+
+    // TODO add bucket sort solution. In Rust it could be more performant.
+
+    // Use the built in sort function.
+    //
+    // Runtime 28 ms Beats 100%
+    // Memory 2.8 MB Beats 67.74%
+    pub fn _sort_array_built_in(nums: Vec<i32>) -> Vec<i32> {
+        let mut n = nums.clone();
+        n.sort_unstable();
+        n
+    }
+}
+
+// Tests.
+fn main() {
+    let tests = [
+        (vec![0], vec![0]),
+        (vec![1, 0], vec![0, 1]),
+        (vec![5, 2, 1], vec![1, 2, 5]),
+        (vec![5, 2, 3, 1], vec![1, 2, 3, 5]),
+        (vec![5, 1, 1, 2, 0, 0], vec![0, 0, 1, 1, 2, 5]),
+    ];
+    for test in tests {
+        assert_eq!(Solution::sort_array(test.0), test.1);
+    }
+    println!("All tests passed!")
+}