Add 5 solutions

Author: martwz

src/leetcode/mod.rs

@@ -1,4 +1,5 @@
 mod challenge;
 mod problem;
+mod top_interview;
 #[cfg_attr(test, macro_use)]
 mod util;

src/leetcode/top_interview/array_and_string/can_jump.rs

@@ -0,0 +1,50 @@
+use std::collections::VecDeque;
+
+// 55. Jump Game, Medium
+// https://leetcode.com/problems/jump-game/
+impl Solution {
+    pub fn can_jump(nums: Vec<i32>) -> bool {
+        let mut pos: VecDeque<usize> = VecDeque::new();
+        pos.push_back(0);
+        let mut jumps = nums.clone();
+
+        while pos.len() > 0 && *pos.back().unwrap() < nums.len() - 1 {
+            let mut p = *pos.back().unwrap();
+            if jumps[p] == 0 && pos.len() > 1 {
+                pos.pop_back();
+                p = *pos.back().unwrap();
+                jumps[p] -= 1;
+            } else if jumps[p] == 0 && pos.len() <= 1 {
+                return false;
+            } else {
+                p += jumps[p] as usize;
+                pos.push_back(p);
+            }
+        }
+
+        return pos.len() > 0 && *pos.back().unwrap() >= nums.len() - 1;
+    }
+}
+
+struct Solution {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{vec_string, vec_vec_i32, vec_vec_string};
+
+    #[test]
+    fn test_can_jump() {
+        assert_eq!(Solution::can_jump(vec![2, 3, 1, 1, 4]), true);
+    }
+
+    #[test]
+    fn test_can_jump2() {
+        assert_eq!(Solution::can_jump(vec![3, 2, 1, 0, 4]), false);
+    }
+
+    #[test]
+    fn test_can_jump3() {
+        assert_eq!(Solution::can_jump(vec![3, 0, 8, 2, 0, 0, 1]), true);
+    }
+}

src/leetcode/top_interview/array_and_string/group_anagrams.rs

@@ -0,0 +1,49 @@
+use std::collections::HashMap;
+
+// 49. Group Anagrams, Medium
+// https://leetcode.com/problems/group-anagrams/
+impl Solution {
+    pub fn group_anagrams(strs: Vec<String>) -> Vec<Vec<String>> {
+        let mut ans: Vec<Vec<String>> = Vec::new();
+        let mut map: HashMap<String, Vec<String>> = HashMap::new();
+
+        for str in strs {
+            let mut chars = str.chars().collect::<Vec<char>>();
+            chars.sort();
+            let key: String = chars.into_iter().collect();
+            if let Some(v) = map.get_mut(&key) {
+                v.push(str);
+            } else {
+                map.insert(key, vec![str]);
+            }
+        }
+
+        for (_, v) in map {
+            ans.push(v);
+        }
+        return ans;
+    }
+}
+
+struct Solution {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{vec_string, vec_vec_i32, vec_vec_string};
+
+    #[test]
+    fn test_group_anagrams() {
+        assert_eq!(Solution::group_anagrams(vec_string!["eat", "tea", "tan", "ate", "nat", "bat"]).len(), 3);
+    }
+
+    #[test]
+    fn test_group_anagrams2() {
+        assert_eq!(Solution::group_anagrams(vec_string![""]), vec_vec_string![[""]]);
+    }
+
+    #[test]
+    fn test_group_anagrams3() {
+        assert_eq!(Solution::group_anagrams(vec_string!["a"]), vec_vec_string![["a"]]);
+    }
+}

src/leetcode/top_interview/array_and_string/increasing_triplet.rs

@@ -0,0 +1,49 @@
+use std::collections::VecDeque;
+
+// 334. Increasing Triplet Subsequence, Medium
+// https://leetcode.com/problems/increasing-triplet-subsequence/
+impl Solution {
+    pub fn increasing_triplet(nums: Vec<i32>) -> bool {
+        let [mut small, mut big] = [std::i32::MAX, std::i32::MAX];
+
+        for num in nums {
+            if num <= small {
+                small = num;
+            } else if num <= big {
+                big = num;
+            } else {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
+
+struct Solution {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{vec_string, vec_vec_i32, vec_vec_string};
+
+    #[test]
+    fn test_increasing_triplet() {
+        assert_eq!(Solution::increasing_triplet(vec![1, 2, 3, 4, 5]), true);
+    }
+
+    #[test]
+    fn test_increasing_triplet2() {
+        assert_eq!(Solution::increasing_triplet(vec![5, 4, 3, 2, 1]), false);
+    }
+
+    #[test]
+    fn test_increasing_triplet3() {
+        assert_eq!(Solution::increasing_triplet(vec![2, 1, 5, 0, 4, 6]), true);
+    }
+
+    #[test]
+    fn test_increasing_triplet4() {
+        assert_eq!(Solution::increasing_triplet(vec![20, 100, 10, 12, 5, 13]), true);
+    }
+}

src/leetcode/top_interview/array_and_string/length_of_longest_substring.rs

@@ -0,0 +1,46 @@
+// 3. Longest Substring Without Repeating Characters, Medium
+// https://leetcode.com/problems/longest-substring-without-repeating-characters/
+impl Solution {
+    pub fn length_of_longest_substring(s: String) -> i32 {
+        let mut max = 0;
+
+        let mut q = Vec::new();
+        for ch in s.chars() {
+            while q.contains(&ch) {
+                q.remove(0);
+            }
+            q.push(ch);
+            max = max.max(q.len() as i32);
+        }
+
+        max
+    }
+}
+
+struct Solution {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::vec_vec_i32;
+
+    #[test]
+    fn test_length_of_longest_substring() {
+        assert_eq!(Solution::length_of_longest_substring("abcabcbb".to_string()), 3);
+    }
+
+    #[test]
+    fn test_length_of_longest_substring2() {
+        assert_eq!(Solution::length_of_longest_substring("bbbbb".to_string()), 1);
+    }
+
+    #[test]
+    fn test_length_of_longest_substring3() {
+        assert_eq!(Solution::length_of_longest_substring("pwwkew".to_string()), 3);
+    }
+
+    #[test]
+    fn test_length_of_longest_substring4() {
+        assert_eq!(Solution::length_of_longest_substring("".to_string()), 0);
+    }
+}

src/leetcode/top_interview/array_and_string/mod.rs

@@ -0,0 +1,5 @@
+mod can_jump;
+mod group_anagrams;
+mod increasing_triplet;
+mod length_of_longest_substring;
+mod set_zeroes;

src/leetcode/top_interview/array_and_string/set_zeroes.rs

@@ -0,0 +1,47 @@
+// 73. Set Matrix Zeroes, Medium
+// https://leetcode.com/problems/set-matrix-zeroes/submissions/
+impl Solution {
+    pub fn set_zeroes(matrix: &mut Vec<Vec<i32>>) {
+        let [n, m] = [matrix.len(), matrix[0].len()];
+        let mut zeros: Vec<(usize, usize)> = Vec::new();
+
+        for i in 0..n {
+            for j in 0..m {
+                if matrix[i][j] == 0 {
+                    zeros.push((i, j));
+                }
+            }
+        }
+
+        for (zi, zj) in zeros {
+            for i in 0..n {
+                matrix[i][zj] = 0;
+            }
+            for j in 0..m {
+                matrix[zi][j] = 0;
+            }
+        }
+    }
+}
+
+struct Solution {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::vec_vec_i32;
+
+    #[test]
+    fn test_set_zeroes() {
+        let mut matrix = vec_vec_i32![[1, 1, 1], [1, 0, 1], [1, 1, 1]];
+        Solution::set_zeroes(&mut matrix);
+        assert_eq!(matrix, vec_vec_i32![[1, 0, 1], [0, 0, 0], [1, 0, 1]]);
+    }
+
+    #[test]
+    fn test_set_zeroes2() {
+        let mut matrix = vec_vec_i32![[0, 1, 2, 0], [3, 4, 5, 2], [1, 3, 1, 5]];
+        Solution::set_zeroes(&mut matrix);
+        assert_eq!(matrix, vec_vec_i32![[0, 0, 0, 0], [0, 4, 5, 0], [0, 3, 1, 0]]);
+    }
+}

src/leetcode/top_interview/mod.rs

@@ -0,0 +1 @@
+mod array_and_string;

src/leetcode/util/vec_vec.rs

@@ -5,6 +5,13 @@ macro_rules! vec_vec_i32 {
     };
 }
 
+#[macro_export]
+macro_rules! vec_string {
+    ($($tail:tt),*) => {
+        vec![$($tail.to_string()),*] as Vec<String>
+    };
+}
+
 #[macro_export]
 macro_rules! vec_vec_string {
     ($($tail:tt),*) => {
@@ -17,4 +24,4 @@ macro_rules! vec_vec_char {
     ($($tail:tt),*) => {
         vec![$(vec!$tail),*] as Vec<Vec<char>>
     };
-}
+}