Add more solutions

Author: martwz

Cargo.toml

@@ -4,5 +4,6 @@ version = "0.1.0"
 edition = "2018"
 
 [dependencies]
+automod = "1.0.2"
 regex = "1.5.4"
 walkdir = "2.3.2"

README.md

@@ -6,17 +6,20 @@
 
 LeetCode is a website that has programming-related questions that are designed to be solved in a limited amount of time. This repository is a collection of some of my solutions written in [Rust](https://www.rust-lang.org/).
 
-## Solutions (62) 
+## Solutions (67) 
 | No. | Title | Solution | Problem | Difficulty |
 |:---:|:------|:--------:|:-------:|:----------:|
 | 1 | Two Sum | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/two_sum.rs) | [Leetcode](https://leetcode.com/problems/two-sum/) | Easy |
 | 2 | Add Two Numbers | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/top_interview/linked_list/add_two_numbers.rs) | [Leetcode](https://leetcode.com/problems/add-two-numbers/) | Medium |
 | 3 | Longest Substring Without Repeating Characters | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/top_interview/array_and_string/length_of_longest_substring.rs) | [Leetcode](https://leetcode.com/problems/longest-substring-without-repeating-characters/) | Medium |
 | 5 | Longest Palindromic Substring | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/top_interview/array_and_string/longest_palindrome.rs) | [Leetcode](https://leetcode.com/problems/longest-palindromic-substring/) | Medium |
+| 31 | Next Permutation | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/next_permutation.rs) | [Leetcode](https://leetcode.com/problems/next-permutation/) | Medium |
+| 37 | Sudoku Solver | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/solve_sudoku.rs) | [Leetcode](https://leetcode.com/problems/sudoku-solver/) | Hard |
 | 49 | Group Anagrams | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/top_interview/array_and_string/group_anagrams.rs) | [Leetcode](https://leetcode.com/problems/group-anagrams/) | Medium |
 | 54 | Spiral Matrix | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/spiral_order.rs) | [Leetcode](https://leetcode.com/problems/spiral-matrix/) | Medium |
 | 55 | Jump Game | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/top_interview/dynamic_programming/can_jump.rs) | [Leetcode](https://leetcode.com/problems/jump-game/) | Medium |
 | 62 | Unique Paths | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/unique_paths.rs) | [Leetcode](https://leetcode.com/problems/unique-paths/) | Medium |
+| 70 | Climbing Stairs | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/climb_stairs.rs) | [Leetcode](https://leetcode.com/problems/climbing-stairs/) | Easy |
 | 72 | Edit Distance | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/min_distance.rs) | [Leetcode](https://leetcode.com/problems/edit-distance/) | Hard |
 | 73 | Set Matrix Zeroes | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/top_interview/array_and_string/set_zeroes.rs) | [Leetcode](https://leetcode.com/problems/set-matrix-zeroes/submissions/) | Medium |
 | 75 | Sort Colors | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/top_interview/sorting/sort_colors.rs) | [Leetcode](https://leetcode.com/problems/sort-colors/) | Medium |
@@ -38,6 +41,7 @@ LeetCode is a website that has programming-related questions that are designed t
 | 350 | Intersection of Two Arrays II | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/intersect.rs) | [Leetcode](https://leetcode.com/problems/intersection-of-two-arrays-ii/) | Easy |
 | 368 | Largest Divisible Subset | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/largest_divisible_subset.rs) | [Leetcode](https://leetcode.com/problems/largest-divisible-subset/) | Medium |
 | 435 | Non-overlapping Intervals | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/erase_overlap_intervals.rs) | [Leetcode](https://leetcode.com/problems/non-overlapping-intervals/) | Medium |
+| 442 | Find All Duplicates in an Array | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/find_duplicates.rs) | [Leetcode](https://leetcode.com/problems/find-all-duplicates-in-an-array/) | Medium |
 | 452 | Minimum Number of Arrows to Burst Balloons | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/find_min_arrow_shots.rs) | [Leetcode](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/) | Medium |
 | 463 | Island Perimeter | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/island_perimeter.rs) | [Leetcode](https://leetcode.com/problems/island-perimeter/) | Easy |
 | 485 | Max Consecutive Ones | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/find_max_consecutive_ones.rs) | [Leetcode](https://leetcode.com/problems/max-consecutive-ones/) | Easy |
@@ -62,6 +66,7 @@ LeetCode is a website that has programming-related questions that are designed t
 | 1293 | Shortest Path in a Grid with Obstacles Elimination | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/shortest_path.rs) | [Leetcode](https://leetcode.com/problems/shortest-path-in-a-grid-with-obstacles-elimination/) | Hard |
 | 1315 | Sum of Nodes with Even-Valued Grandparent | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/sum_even_grandparent.rs) | [Leetcode](https://leetcode.com/problems/sum-of-nodes-with-even-valued-grandparent/) | Medium |
 | 1328 | Break a Palindrome | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/break_palindrome.rs) | [Leetcode](https://leetcode.com/problems/break-a-palindrome/) | Medium |
+| 1428 | Leftmost Column with at Least a One | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/left_most_column_with_one.rs) | [Leetcode](https://leetcode.com/problems/leftmost-column-with-at-least-a-one/) | Medium |
 | 1457 | Pseudo-Palindromic Paths in a Binary Tree | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/pseudo_palindromic_paths.rs) | [Leetcode](https://leetcode.com/problems/pseudo-palindromic-paths-in-a-binary-tree/) | Easy |
 | 1801 | Number of Orders in the Backlog | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/get_number_of_backlog_orders.rs) | [Leetcode](https://leetcode.com/problems/number-of-orders-in-the-backlog/) | Medium |
 | 1962 | Remove Stones to Minimize the Total | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/min_stone_sum.rs) | [Leetcode](https://leetcode.com/problems/remove-stones-to-minimize-the-total/) | Medium |
@@ -70,4 +75,4 @@ LeetCode is a website that has programming-related questions that are designed t
 | 2024 | Maximize the Confusion of an Exam | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/biweekly_62.rs) | [Leetcode](https://leetcode.com/problems/maximize-the-confusion-of-an-exam/) | Medium |
 | 2025 | Maximum Number of Ways to Partition an Array | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/biweekly_62.rs) | [Leetcode](https://leetcode.com/problems/maximum-number-of-ways-to-partition-an-array/) | Hard |
 | 2027 | Minimum Moves to Convert String | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/weekly_261.rs) | [Leetcode](https://leetcode.com/problems/minimum-moves-to-convert-string/) | Easy |
-| 2028 | Find Missing Observations | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/weekly_261.rs) | [Leetcode](https://leetcode.com/problems/find-missing-observations/) | Medium |
+| 2028 | Find Missing Observations | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/weekly_261.rs) | [Leetcode](https://leetcode.com/problems/find-missing-observations/) | Medium |

src/leetcode/problem/climb_stairs.rs

@@ -0,0 +1,38 @@
+// 70. Climbing Stairs, Easy
+// https://leetcode.com/problems/climbing-stairs/
+impl Solution {
+    pub fn climb_stairs(n: i32) -> i32 {
+        let mut dp = vec![0; n.max(4) as usize + 1];
+            dp[0] = 0;
+            dp[1] = 1;
+            dp[2] = 2;
+            dp[3] = 3;
+            for i in 4..=n as usize {
+                dp[i] = dp[i - 1] + dp[i - 2];
+            }
+            return dp[n as usize];
+        }
+}
+
+struct Solution {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_climb_stairs() {
+        assert_eq!(Solution::climb_stairs(2), 2);
+    }
+
+    #[test]
+    fn test_climb_stairs2() {
+        assert_eq!(Solution::climb_stairs(3), 3);
+    }
+
+    #[test]
+    fn test_climb_stairs3() {
+        assert_eq!(Solution::climb_stairs(4), 5);
+    }
+}
+

src/leetcode/problem/find_duplicates.rs

@@ -0,0 +1,46 @@
+// 442. Find All Duplicates in an Array, Medium
+// https://leetcode.com/problems/find-all-duplicates-in-an-array/
+impl Solution {
+    pub fn find_duplicates(mut nums: Vec<i32>) -> Vec<i32> {
+        nums.sort_unstable();
+
+        let mut ans = vec![];
+        let n = nums.len();
+        if n == 0 {
+            return ans;
+        }
+
+        let mut prev = nums[0];
+
+        for i in 1..n {
+            if nums[i] == prev {
+                ans.push(nums[i]);
+            }
+            prev = nums[i];
+        }
+
+        ans
+    }
+}
+
+struct Solution {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_find_duplicates() {
+        assert_eq!(Solution::find_duplicates(vec![4, 3, 2, 7, 8, 2, 3, 1]), vec![2, 3]);
+    }
+
+    #[test]
+    fn test_find_duplicates2() {
+        assert_eq!(Solution::find_duplicates(vec![1, 1, 2]), vec![1]);
+    }
+
+    #[test]
+    fn test_find_duplicates3() {
+        assert_eq!(Solution::find_duplicates(vec![1]), vec![]);
+    }
+}

src/leetcode/problem/left_most_column_with_one.rs

@@ -0,0 +1,39 @@
+#[derive(Copy, Clone)]
+struct BinaryMatrix;
+
+#[allow(unused_variables)]
+impl BinaryMatrix {
+    fn get(self, row: i32, col: i32) -> i32 {
+        1
+    }
+
+    fn dimensions(self) -> Vec<i32> {
+        vec![]
+    }
+}
+
+// 1428. Leftmost Column with at Least a One, Medium
+// https://leetcode.com/problems/leftmost-column-with-at-least-a-one/
+impl Solution {
+    pub fn left_most_column_with_one(binary_matrix: &BinaryMatrix) -> i32 {
+        let dim: Vec<_> = binary_matrix.dimensions();
+
+        let mut row = dim[0] - 1;
+        let mut col = dim[1] - 1;
+
+        let mut candidate: Option<i32> = None;
+
+        while row >= 0 && col >= 0 {
+            if binary_matrix.get(row, col) == 1 {
+                candidate = Some(col);
+                col -= 1;
+            } else {
+                row -= 1;
+            }
+        }
+
+        candidate.unwrap_or(-1)
+    }
+}
+
+struct Solution {}

src/leetcode/problem/mod.rs

@@ -1,28 +1 @@
-mod add_operators;
-mod broken_calc;
-mod can_complete_circuit;
-mod coin_change;
-mod contain_virus;
-mod erase_overlap_intervals;
-mod find_min_arrow_shots;
-mod find_poisoned_duration;
-mod get_number_of_backlog_orders;
-mod inorder_traversal;
-mod is_anagram;
-mod is_good_array;
-mod is_same_tree;
-mod island_perimeter;
-mod kth_smallest;
-mod largest_divisible_subset;
-mod max_level_sum;
-mod max_uncrossed_lines;
-mod min_distance;
-mod min_eating_speed;
-mod min_stone_sum;
-mod num_islands;
-mod num_subarray_product_less_than_k;
-mod pseudo_palindromic_paths;
-mod sum_even_grandparent;
-mod two_sum;
-mod unique_paths;
-mod zigzag_level_order;
+automod::dir!("src/leetcode/problem");

src/leetcode/problem/next_permutation.rs

@@ -0,0 +1,82 @@
+// 31. Next Permutation, Medium
+// https://leetcode.com/problems/next-permutation/
+impl Solution {
+    pub fn next_permutation(nums: &mut Vec<i32>) {
+        let n = nums.len();
+
+        if n <= 1 {
+            return;
+        }
+
+        let mut swapped_at = 0;
+        'outer: for l in (0..n).rev() {
+            for r in (0..n).rev() {
+                if r > l && nums[r] > nums[l] {
+                    nums.swap(l, r);
+                    swapped_at = l + 1;
+                    break 'outer;
+                }
+            }
+        }
+
+        let mut i = swapped_at;
+        while i < n - 1 {
+            if nums[i] > nums[i + 1] {
+                nums.swap(i, i + 1);
+                i = swapped_at;
+                continue;
+            }
+            i += 1;
+        }
+    }
+}
+
+struct Solution {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::vec_vec_i32;
+
+    #[test]
+    fn test_next_permutation() {
+        let mut nums = vec![1, 2, 3];
+        Solution::next_permutation(&mut nums);
+        assert_eq!(nums, vec![1, 3, 2]);
+    }
+
+    #[test]
+    fn test_next_permutation2() {
+        let mut nums = vec![3, 2, 1];
+        Solution::next_permutation(&mut nums);
+        assert_eq!(nums, vec![1, 2, 3]);
+    }
+
+    #[test]
+    fn test_next_permutation3() {
+        let mut nums = vec![1, 1, 5];
+        Solution::next_permutation(&mut nums);
+        assert_eq!(nums, vec![1, 5, 1]);
+    }
+
+    #[test]
+    fn test_next_permutation4() {
+        let mut nums = vec![1];
+        Solution::next_permutation(&mut nums);
+        assert_eq!(nums, vec![1]);
+    }
+
+    #[test]
+    fn test_next_permutation5() {
+        let mut nums = vec![1, 3, 2];
+        Solution::next_permutation(&mut nums);
+        assert_eq!(nums, vec![2, 1, 3]);
+    }
+
+    #[test]
+    fn test_next_permutation6() {
+        let mut nums = vec![4, 2, 0, 2, 3, 2, 0];
+        Solution::next_permutation(&mut nums);
+        assert_eq!(nums, vec![4, 2, 0, 3, 0, 2, 2]);
+    }
+}

src/leetcode/problem/num_of_subarrays.rs

@@ -0,0 +1,86 @@
+// @leetup=custom
+// @leetup=info id=1524 lang=rust slug=number-of-sub-arrays-with-odd-sum
+
+/*
+* Given an array of integers `arr`, return *the number of subarrays with an
+* odd sum*.
+*
+* Since the answer can be very large, return it modulo `109 + 7`.
+*
+*
+* Example 1:
+*
+* Input: arr = [1,3,5]
+* Output: 4
+* Explanation: All subarrays are [[1],[1,3],[1,3,5],[3],[3,5],[5]]
+* All sub-arrays sum are [1,4,9,3,8,5].
+* Odd sums are [1,9,3,5] so the answer is 4.
+*
+* Example 2:
+*
+* Input: arr = [2,4,6]
+* Output: 0
+* Explanation: All subarrays are [[2],[2,4],[2,4,6],[4],[4,6],[6]]
+* All sub-arrays sum are [2,6,12,4,10,6].
+* All sub-arrays have even sum and the answer is 0.
+*
+* Example 3:
+*
+* Input: arr = [1,2,3,4,5,6,7]
+* Output: 16
+*
+*
+* Constraints:
+*
+* * `1 <= arr.length <= 105`
+* * `1 <= arr[i] <= 100`
+*
+*/
+// @leetup=custom
+// @leetup=code
+
+impl Solution {
+    pub fn num_of_subarrays(arr: Vec<i32>) -> i32 {
+        const MOD: i32 = 1_000_000_007;
+
+        let [mut even, mut odd] = [1, 0];
+        let mut sum = 0;
+        let mut ans = 0;
+        for num in arr.iter() {
+            sum += num;
+
+            if sum % 2 == 0 {
+                even += 1;
+                ans += odd % MOD
+            } else {
+                odd += 1;
+                ans += even % MOD
+            }
+        }
+
+        ans
+    }
+}
+
+struct Solution {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{vec_string, vec_vec_char};
+
+    #[test]
+    fn test_num_of_subarrays() {
+        assert_eq!(Solution::num_of_subarrays(vec![1, 3, 5]), 4);
+    }
+
+    #[test]
+    fn test_num_of_subarrays2() {
+        assert_eq!(Solution::num_of_subarrays(vec![2, 4, 6]), 0);
+    }
+
+    #[test]
+    fn test_num_of_subarrays3() {
+        assert_eq!(Solution::num_of_subarrays(vec![1, 2, 3, 4, 5, 6, 7]), 16);
+    }
+}