LC 1232. Check If It Is a Straight Line (Rust Geom)

Author: raul-sauco

README.md

@@ -394,6 +394,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [1162. As Far from Land as Possible][lc1162]                                                  | 🟠 Medium  | [![python](res/py.png)][lc1162py] [![rust](res/rs.png)][lc1162rs]                                     |
 | [1207. Unique Number of Occurrences][lc1207]                                                  | 🟢 Easy    | [![python](res/py.png)][lc1207py]                                                                     |
 | [1220. Count Vowels Permutation][lc1220]                                                      | 🔴 Hard    | [![python](res/py.png)][lc1220py]                                                                     |
+| [1232. Check If It Is a Straight Line][lc1232]                                                | 🟢 Easy    | [![rust](res/rs.png)][lc1232rs]                                                                       |
 | [1235. Maximum Profit in Job Scheduling][lc1235]                                              | 🔴 Hard    | [![python](res/py.png)][lc1235py]                                                                     |
 | [1239. Maximum Length of a Concatenated String with Unique Characters][lc1239]                | 🟠 Medium  | [![python](res/py.png)][lc1239py]                                                                     |
 | [1254. Number of Closed Islands][lc1254]                                                      | 🟠 Medium  | [![rust](res/rs.png)][lc1254rs]                                                                       |
@@ -1382,6 +1383,8 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc1207py]: leetcode/unique-number-of-occurrences.py
 [lc1220]: https://leetcode.com/problems/count-vowels-permutation/
 [lc1220py]: leetcode/count-vowels-permutation.py
+[lc1232]: https://leetcode.com/problems/check-if-it-is-a-straight-line/
+[lc1232rs]: leetcode/check-if-it-is-a-straight-line.rs
 [lc1235]: https://leetcode.com/problems/maximum-profit-in-job-scheduling/
 [lc1235py]: leetcode/maximum-profit-in-job-scheduling.py
 [lc1239]: https://leetcode.com/problems/maximum-length-of-a-concatenated-string-with-unique-characters/

leetcode/check-if-it-is-a-straight-line.rs

@@ -0,0 +1,99 @@
+// 1232. Check If It Is a Straight Line
+// 🟢 Easy
+//
+// https://leetcode.com/problems/check-if-it-is-a-straight-line/
+//
+// Tags: Array - Math - Geometry
+
+struct Solution;
+impl Solution {
+    /// For all the points to be in the same line, they have to satisfy the
+    /// same linear equation y = mx+b, compute m and b using two points and
+    /// check if the rest of the points satisfy the condition.
+    ///
+    /// Time complexity: O(n) - We compute m and b in linear time, then iterate
+    /// over all the points to check if they satisfy the equation.
+    /// Space complexity: O(1) - Constant extra memory used.
+    ///
+    /// Runtime 2 ms Beats 90%
+    /// Memory 2 MB Beats 90%
+    pub fn check_straight_line(coordinates: Vec<Vec<i32>>) -> bool {
+        if coordinates.len() < 3 {
+            return true;
+        }
+        let (ax, ay) = (coordinates[0][0] as f32, coordinates[0][1] as f32);
+        let (bx, by) = (coordinates[1][0] as f32, coordinates[1][1] as f32);
+        let m = if ax == bx {
+            f32::MAX
+        } else {
+            (ay - by) / (ax - bx)
+        };
+        let b = ay - m * ax;
+        for point in coordinates {
+            let (x, y) = (point[0] as f32, point[1] as f32);
+            if m == f32::MAX {
+                if x != ax {
+                    return false;
+                }
+            } else if y != m * x + b {
+                return false;
+            }
+        }
+        true
+    }
+
+    /// The slope between any two points needs to be the same, fix one point
+    /// and make sure that the slope between that point and any other remains
+    /// constant.
+    ///
+    /// Time complexity: O(n) - We do one check per point.
+    /// Space complexity: O(1) - Constant extra memory used.
+    ///
+    /// Runtime 0 ms Beats 100%
+    /// Memory 2.1 MB Beats 90%
+    pub fn check_straight_line_2(coordinates: Vec<Vec<i32>>) -> bool {
+        let (ax, ay) = (coordinates[0][0], coordinates[0][1]);
+        let (bx, by) = (coordinates[1][0], coordinates[1][1]);
+        for point in coordinates {
+            let (x, y) = (point[0], point[1]);
+            if (bx - ax) * (y - by) != (x - bx) * (by - ay) {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+// Tests.
+fn main() {
+    let tests = [
+        (vec![vec![0, 0], vec![0, 1], vec![0, -1]], true),
+        (
+            vec![
+                vec![1, 2],
+                vec![2, 3],
+                vec![3, 4],
+                vec![4, 5],
+                vec![5, 6],
+                vec![6, 7],
+            ],
+            true,
+        ),
+        (
+            vec![
+                vec![1, 1],
+                vec![2, 2],
+                vec![3, 4],
+                vec![4, 5],
+                vec![5, 6],
+                vec![7, 7],
+            ],
+            false,
+        ),
+    ];
+    for t in tests {
+        assert_eq!(Solution::check_straight_line(t.0.clone()), t.1);
+        assert_eq!(Solution::check_straight_line_2(t.0), t.1);
+    }
+    println!("\x1b[92m» All tests passed!\x1b[0m")
+}