feat: 🎸 git add leetcode solution 1. 49. 128. 217. 238

Author: dirk122119

leet code/1. Two sum/solution.rs

@@ -0,0 +1,41 @@
+use std::collections::HashMap;
+
+struct Solution;
+
+impl Solution {
+    pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
+        let mut map = HashMap::new();
+        for (index, num) in nums.iter().enumerate() {
+            if let Some(pair) = map.get(&(target - num)) {
+                return vec![*pair as i32, index as i32];
+            }
+            map.insert(num, index as i32);
+        }
+        unreachable!();
+    }
+}
+
+fn main() {
+    let nums = vec![2, 7, 11, 15];
+    let target = 9;
+    let result = Solution::two_sum(nums, target);
+    println!("{:?}", result);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_two_sum() {
+        assert_eq!(Solution::two_sum(vec![2, 7, 11, 15], 9), vec![0, 1]);
+        assert_eq!(Solution::two_sum(vec![3, 2, 4], 6), vec![1, 2]);
+        assert_eq!(Solution::two_sum(vec![3, 3], 6), vec![0, 1]);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_no_solution() {
+        Solution::two_sum(vec![1, 2, 3], 7);
+    }
+}

leet code/128. Longest Consecutive Sequence/solution

@@ -0,0 +1,50 @@
+use std::collections::HashSet;
+use std::cmp;
+
+struct Solution;
+
+impl Solution {
+    pub fn longest_consecutive(nums: Vec<i32>) -> i32 {
+        //1. use HashSet remove duplicate value O(n)
+        let mut set = HashSet::new();
+        let mut max_len = 0;
+        for i in nums {
+            set.insert(i);
+        }
+        //2. calculate consecutive num length
+        for &val in set.iter() {
+            // 如果当前值是序列的起始值
+            if !set.contains(&(val - 1)) {
+                let mut n = val;
+                let mut len = 1;
+                while set.contains(&(n + 1)) {
+                    len += 1;
+                    n += 1;
+                }
+                max_len = cmp::max(max_len, len);
+            }
+        }
+         //3. return max length
+        max_len
+    }
+}
+
+fn main() {
+    let nums = vec![100, 4, 200, 1, 3, 2];
+    let result = Solution::longest_consecutive(nums);
+    println!("Longest consecutive sequence length: {}", result);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_longest_consecutive() {
+        assert_eq!(Solution::longest_consecutive(vec![100, 4, 200, 1, 3, 2]), 4);
+        assert_eq!(Solution::longest_consecutive(vec![0, -1, 1, 2, -2, -3]), 6);
+        assert_eq!(Solution::longest_consecutive(vec![]), 0);
+        assert_eq!(Solution::longest_consecutive(vec![1, 2, 0, 1]), 3);
+        assert_eq!(Solution::longest_consecutive(vec![1]), 1);
+    }
+}

leet code/128. Longest Consecutive Sequence/solution.rs

@@ -0,0 +1,41 @@
+use std::collections::HashSet;
+
+struct Solution;
+
+impl Solution {
+    pub fn contains_duplicate(nums: Vec<i32>) -> bool {
+        // HashSet time: O(n) space: O(n)
+        let mut set = HashSet::new();
+        for i in 0..nums.len() {
+            match set.contains(&nums[i]){
+                true => return true,
+                false => set.insert(nums[i]),
+            };
+        }
+        false
+    }
+}
+
+fn main() {
+    let nums = vec![1, 2, 3, 1];
+    let result = Solution::contains_duplicate(nums);
+    println!("Contains duplicate: {}", result);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_contains_duplicate() {
+        assert_eq!(Solution::contains_duplicate(vec![1, 2, 3, 1]), true);
+        assert_eq!(Solution::contains_duplicate(vec![1, 2, 3, 4]), false);
+        assert_eq!(Solution::contains_duplicate(vec![1, 1, 1, 3, 3, 4, 3, 2, 4, 2]), true);
+        assert_eq!(Solution::contains_duplicate(vec![]), false);
+    }
+
+    #[test]
+    fn test_contains_duplicate_single_element() {
+        assert_eq!(Solution::contains_duplicate(vec![1]), false);
+    }
+}

leet code/128. Longest Consecutive Sequence/solution_test

@@ -0,0 +1,38 @@
+struct Solution;
+
+impl Solution {
+    pub fn is_anagram(s: String, t: String) -> bool {
+        // 1. compare two strings after sorting，O(nlogn)
+        let mut vec_s: Vec<char> = s.chars().collect();
+        let mut vec_t: Vec<char> = t.chars().collect();
+        vec_s.sort();
+        vec_t.sort();
+        return vec_s==vec_t
+    }
+}
+
+fn main() {
+    let s = String::from("anagram");
+    let t = String::from("nagaram");
+    let result = Solution::is_anagram(s, t);
+    println!("Is anagram: {}", result);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_is_anagram() {
+        assert_eq!(Solution::is_anagram(String::from("anagram"), String::from("nagaram")), true);
+        assert_eq!(Solution::is_anagram(String::from("rat"), String::from("car")), false);
+        assert_eq!(Solution::is_anagram(String::from(""), String::from("")), true);
+        assert_eq!(Solution::is_anagram(String::from("a"), String::from("a")), true);
+        assert_eq!(Solution::is_anagram(String::from("a"), String::from("b")), false);
+    }
+
+    #[test]
+    fn test_is_anagram_case_sensitive() {
+        assert_eq!(Solution::is_anagram(String::from("Hello"), String::from("hello")), false);
+    }
+}

leet code/217. Contains Duplicate/solution.rs

@@ -0,0 +1,45 @@
+use std::collections::HashMap;
+
+struct Solution;
+
+impl Solution {
+    pub fn is_anagram(s: String, t: String) -> bool {
+        // create two HashMap and compare O(n)
+        let mut map_s = HashMap::new();
+        let mut map_t = HashMap::new();
+
+        for i in s.chars() {
+            map_s.entry(i).and_modify(|v| *v += 1).or_insert(1);
+        }
+        for i in t.chars() {
+            map_t.entry(i).and_modify(|v| *v += 1).or_insert(1);
+        }
+        map_s == map_t
+    }
+}
+
+fn main() {
+    let s = String::from("anagram");
+    let t = String::from("nagaram");
+    let result = Solution::is_anagram(s, t);
+    println!("Is anagram: {}", result);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_is_anagram() {
+        assert_eq!(Solution::is_anagram(String::from("anagram"), String::from("nagaram")), true);
+        assert_eq!(Solution::is_anagram(String::from("rat"), String::from("car")), false);
+        assert_eq!(Solution::is_anagram(String::from(""), String::from("")), true);
+        assert_eq!(Solution::is_anagram(String::from("a"), String::from("a")), true);
+        assert_eq!(Solution::is_anagram(String::from("a"), String::from("b")), false);
+    }
+
+    #[test]
+    fn test_is_anagram_case_sensitive() {
+        assert_eq!(Solution::is_anagram(String::from("Hello"), String::from("hello")), false);
+    }
+}

leet code/242. Valid Anagram/solution1

@@ -0,0 +1,67 @@
+use std::collections::HashMap;
+
+struct Solution;
+
+impl Solution {
+    pub fn group_anagrams(strs: Vec<String>) -> Vec<Vec<String>> {
+        // HashMap key=[1,0,0,0,0,1,.....]:Vec[26] value vec!["eat","ate","tea"]
+        // O(KN)
+        let mut map: HashMap<Vec<i32>, Vec<String>> = HashMap::new();
+        for i in 0..strs.len() {
+            // create key 1,0,0,0,0,1,.....]
+            let mut list = vec![0; 26];
+            for &c_ascii in strs[i].as_bytes() {
+                list[c_ascii as usize - b'a' as usize] += 1;
+            }
+            map.entry(list).or_insert_with(Vec::new).push(strs[i].clone());
+        }
+        map.into_values().collect()
+    }
+}
+
+fn main() {
+    let strs = vec![
+        "eat".to_string(),
+        "tea".to_string(),
+        "tan".to_string(),
+        "ate".to_string(),
+        "nat".to_string(),
+        "bat".to_string(),
+    ];
+    let result = Solution::group_anagrams(strs);
+    for group in result {
+        println!("{:?}", group);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_group_anagrams() {
+        let input = vec![
+            "eat".to_string(),
+            "tea".to_string(),
+            "tan".to_string(),
+            "ate".to_string(),
+            "nat".to_string(),
+            "bat".to_string(),
+        ];
+        let mut result = Solution::group_anagrams(input);
+        for group in result.iter_mut() {
+            group.sort();  // Sort to ensure the order does not affect the test
+        }
+        result.sort();  // Sort the outer vector for the same reason
+        let mut expected = vec![
+            vec!["bat".to_string()],
+            vec!["nat".to_string(), "tan".to_string()],
+            vec!["ate".to_string(), "eat".to_string(), "tea".to_string()],
+        ];
+        for group in expected.iter_mut() {
+            group.sort();
+        }
+        expected.sort();
+        assert_eq!(result, expected);
+    }
+}