LC 1502. Can Make Arithmetic Progression From Sequence (Rust)

Author: raul-sauco

README.md

@@ -434,6 +434,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [1480. Running Sum of 1d Array][lc1480]                                                       | 🟢 Easy    | [![python](res/py.png)][lc1480py]                                                                     |
 | [1491. Average Salary Excluding the Minimum and Maximum Salary][lc1491]                       | 🟢 Easy    | [![rust](res/rs.png)][lc1491rs]                                                                       |
 | [1498. Number of Subsequences That Satisfy the Given Sum Condition][lc1498]                   | 🟠 Medium  | [![python](res/py.png)][lc1498py]                                                                     |
+| [1502. Can Make Arithmetic Progression From Sequence][lc1502]                                 | 🟢 Easy    | [![rust](res/rs.png)][lc1502rs]                                                                       |
 | [1519. Number of Nodes in the Sub-Tree With the Same Label][lc1519]                           | 🟠 Medium  | [![python](res/py.png)][lc1519py]                                                                     |
 | [1523. Count Odd Numbers in an Interval Range][lc1523]                                        | 🟢 Easy    | [![python](res/py.png)][lc1523py] [![rust](res/rs.png)][lc1523rs]                                     |
 | [1539. Kth Missing Positive Number][lc1539]                                                   | 🟢 Easy    | [![python](res/py.png)][lc1539py] [![rust](res/rs.png)][lc1539rs]                                     |
@@ -1475,6 +1476,8 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc1491rs]: leetcode/average-salary-excluding-the-minimum-and-maximum-salary.rs
 [lc1498]: https://leetcode.com/problems/number-of-subsequences-that-satisfy-the-given-sum-condition/
 [lc1498py]: leetcode/number-of-subsequences-that-satisfy-the-given-sum-condition.py
+[lc1502]: https://leetcode.com/problems/can-make-arithmetic-progression-from-sequence/
+[lc1502rs]: leetcode/can-make-arithmetic-progression-from-sequence.rs
 [lc1519]: https://leetcode.com/problems/number-of-nodes-in-the-sub-tree-with-the-same-label/
 [lc1519py]: leetcode/number-of-nodes-in-the-sub-tree-with-the-same-label.py
 [lc1523]: https://leetcode.com/problems/count-odd-numbers-in-an-interval-range/

leetcode/can-make-arithmetic-progression-from-sequence.rs

@@ -0,0 +1,100 @@
+// 1502. Can Make Arithmetic Progression From Sequence
+// 🟢 Easy
+//
+// https://leetcode.com/problems/can-make-arithmetic-progression-from-sequence/
+//
+// Tags: Array - Sorting
+
+use std::collections::HashSet;
+
+struct Solution;
+impl Solution {
+    /// Create a duplicate of the input array and sort it, check the difference
+    /// between any two contiguous items and make sure the difference is the
+    /// same between any two items in the sorted array.
+    ///
+    /// Time complexity: O(n*log(n)) - Sorting has the highest time complexity.
+    /// Space complexity: O(n) - We make a copy of the input array. Besides that
+    /// sorting the array also takes extra memory, O(log(n))
+    ///
+    /// Runtime 0 ms Beats 100%
+    /// Memory 2.1 MB Beats 40%
+    pub fn can_make_arithmetic_progression(arr: Vec<i32>) -> bool {
+        if arr.len() < 3 {
+            return true;
+        }
+        let mut nums = arr.clone();
+        nums.sort();
+        let diff = nums[1] - nums[0];
+        for i in 2..nums.len() {
+            if nums[i] - nums[i - 1] != diff {
+                return false;
+            }
+        }
+        true
+    }
+
+    /// Find the minimum and maximum values in the input, compute the difference
+    /// as (max-min) / num elements-1 Then create an array of flags that
+    /// represents whether we have already seen the element that needs to go at
+    /// any given position in the sequence. Start iterating over the input
+    /// elements matching their values to the indexes along the sequence at
+    /// which they should be found, if that value has been seen before, or the
+    /// element does not match an index, return false, otherwise mark that
+    /// index as seen.
+    ///
+    /// Time complexity: O(n) - We iterate two times over all the elements in
+    /// the input array, for each we do O(1) work.
+    /// Space complexity: O(n) - The array of flags uses extra memory.
+    ///
+    /// Runtime 0 ms Beats 100%
+    /// Memory 2 MB Beats 40%
+    pub fn can_make_arithmetic_progression_2(arr: Vec<i32>) -> bool {
+        let n = arr.len() as i32;
+        let (mut min, mut max) = (i32::MAX, i32::MIN);
+        for num in arr.iter() {
+            if *num > max {
+                max = *num;
+            }
+            if *num < min {
+                min = *num;
+            }
+        }
+        if (max - min) % (n - 1) != 0 {
+            return false;
+        }
+        let diff = (max - min) / (n - 1);
+        if diff == 0 {
+            return arr.into_iter().collect::<HashSet<i32>>().len() == 1;
+        }
+        let mut seen = vec![false; arr.len()];
+        for num in arr {
+            if (num - min) % diff != 0 {
+                return false;
+            }
+            let idx = ((num - min) / diff) as usize;
+            if seen[idx] {
+                return false;
+            }
+            seen[idx] = true;
+        }
+        true
+    }
+}
+
+// Tests.
+fn main() {
+    let tests = [
+        (vec![3, 1, 5], true),
+        (vec![1, 2, 4], false),
+        (vec![0, 0, 0, 0], true),
+    ];
+    for t in tests {
+        assert_eq!(Solution::can_make_arithmetic_progression(t.0.clone()), t.1);
+        assert_eq!(
+            Solution::can_make_arithmetic_progression_2(t.0.clone()),
+            t.1
+        );
+    }
+    println!("\x1b[92m» All tests passed!\x1b[0m")
+}