add 44;49;67;344;345;520;557

Author: leopsidom

344.reverse-string.rs

@@ -0,0 +1,15 @@
+/*
+ * @lc app=leetcode id=344 lang=rust
+ *
+ * [344] Reverse String
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn reverse_string(s: &mut Vec<char>) {
+        let N = s.len();
+        for i in 0..N / 2 { s.swap(i, N-i-1); }
+    }
+}
+// @lc code=end
+

345.reverse-vowels-of-a-string.rs

@@ -0,0 +1,36 @@
+/*
+ * @lc app=leetcode id=345 lang=rust
+ *
+ * [345] Reverse Vowels of a String
+ */
+
+// @lc code=start
+use std::collections::HashSet;
+
+impl Solution {
+    pub fn reverse_vowels(s: String) -> String {
+
+        let mut chars: Vec<char> = s.chars().collect();
+        if chars.len() <= 1 { return s; }
+        let vowels: HashSet<char> = 
+            ['a', 'e', 'i', 'o', 'u',
+             'A', 'E', 'I', 'O', 'U'].iter().cloned().collect();
+
+        let mut lo = 0;
+        let mut hi = chars.len() - 1;
+
+        while lo < hi {
+            while lo < hi && !vowels.contains(&chars[lo]) { lo += 1; }
+            while lo < hi && !vowels.contains(&chars[hi]) { hi -= 1; }
+            if lo < hi {
+                chars.swap(lo, hi);
+                lo += 1;
+                hi -= 1;
+            }
+        }
+
+        chars.into_iter().collect()
+    }
+}
+// @lc code=end
+

44.wildcard-matching.rs

@@ -0,0 +1,45 @@
+/*
+ * @lc app=leetcode id=44 lang=rust
+ *
+ * [44] Wildcard Matching
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn is_match(s: String, p: String) -> bool {
+        let schars: Vec<char> = s.chars().collect();
+        let pchars: Vec<char> = p.chars().collect();
+
+        let s_len = schars.len();
+        let p_len = pchars.len();
+
+        let mut dp = vec![vec![false; s_len + 1]; p_len + 1];
+
+        for i in 0..p_len+1 {
+            for j in 0..s_len+1 {
+                if i == 0 {
+                    dp[i][j] = j == 0;
+                } else if j == 0 {
+                    dp[i][j] = dp[i-1][j] && pchars[i-1] == '*';
+                } else {
+                    if pchars[i-1] == '?' || pchars[i-1] == schars[j-1] {
+                        dp[i][j] = dp[i-1][j-1];
+                    } else if pchars[i-1] == '*' {
+                        for k in 0..j+1 {
+                            if dp[i-1][k] {
+                                dp[i][j] = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // println!("{:?}", dp);
+        dp[p_len][s_len]
+    }
+
+}
+// @lc code=end
+

49.group-anagrams.rs

@@ -0,0 +1,33 @@
+/*
+ * @lc app=leetcode id=49 lang=rust
+ *
+ * [49] Group Anagrams
+ */
+
+// @lc code=start
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn group_anagrams(strs: Vec<String>) -> Vec<Vec<String>> {
+        let mut map: HashMap<Vec<u32>, Vec<String>> = HashMap::new();
+
+        for s in strs {
+            let mut cnt = vec![0; 26];
+            for ch in s.chars() {
+                cnt[ch as usize - 'a' as usize] += 1;
+            }
+            let val = map.entry(cnt).or_insert(vec![]);
+            (*val).push(s);
+        }
+
+        let mut ans = vec![];
+
+        for vec in map.values() {
+            ans.push(vec.clone());
+        }
+        ans
+
+    }
+}
+// @lc code=end
+

520.detect-capital.rs

@@ -0,0 +1,33 @@
+/*
+ * @lc app=leetcode id=520 lang=rust
+ *
+ * [520] Detect Capital
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn detect_capital_use(word: String) -> bool {
+        let mut is_uppercase = true;
+
+        let chars: Vec<char> = word.chars().collect();
+        if chars.len() <= 1 { return true; }
+
+        for i in 1..chars.len() {
+            if chars[i].is_ascii_lowercase() {
+                if i == 1 {
+                    is_uppercase = false;
+                } else {
+                    if is_uppercase {
+                        return false;
+                    }
+                }
+            } else if !is_uppercase {
+                return false;
+            }
+        }
+
+        return chars[0].is_ascii_uppercase() || (chars[0].is_ascii_lowercase() && !is_uppercase);
+    }
+}
+// @lc code=end
+

557.reverse-words-in-a-string-iii.rs

@@ -0,0 +1,24 @@
+/*
+ * @lc app=leetcode id=557 lang=rust
+ *
+ * [557] Reverse Words in a String III
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn reverse_words(s: String) -> String {
+        let iter = s.split(' ');
+
+        let mut ans = String::new();
+        for word in iter {
+            if ans.len() != 0 {
+                ans.push(' ');
+            }
+            let revWord: String = word.chars().rev().collect();
+            ans.push_str(&revWord);
+        }
+        ans
+    }
+}
+// @lc code=end
+

67.add-binary.rs

@@ -0,0 +1,45 @@
+/*
+ * @lc app=leetcode id=67 lang=rust
+ *
+ * [67] Add Binary
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn add_binary(a: String, b: String) -> String {
+        let achars: Vec<char> = a.chars().collect();
+        let bchars: Vec<char> = b.chars().collect();
+
+        let mut alen = achars.len();
+        let mut blen = bchars.len();
+
+        let mut carry = 0;
+
+        let mut i = alen as i32 - 1;
+        let mut j = blen as i32 - 1;
+
+        let mut res = String::new();
+
+        while i >= 0 || j >= 0 || carry > 0 {
+            let mut achar = 0;
+            let mut bchar = 0;
+            if i >= 0 {
+                achar = achars[i as usize].to_digit(10).unwrap();
+                i -= 1;
+            }
+            if j >= 0 {
+                bchar = bchars[j as usize].to_digit(10).unwrap();
+                j -= 1;
+            }
+
+            let sum = achar + bchar + carry;
+
+            res.push_str(&(sum % 2).to_string());
+            carry = sum / 2;
+        }
+
+        res.chars().rev().collect()
+    }
+}
+// @lc code=end
+