Merge pull request #2444 from tedkimdev/tedkimdev/week3

[tedkimdev] WEEK 03 Solutions

Author: tedkimdev

combination-sum/tedkimdev.rs

@@ -0,0 +1,29 @@
+// SC: O(2^t/m)
+// TC: O(t/m)
+impl Solution {
+    pub fn combination_sum(nums: Vec<i32>, target: i32) -> Vec<Vec<i32>> {
+		let mut res: Vec<Vec<i32>> = vec![];
+
+		fn dfs(nums: &[i32], target: i32, i: usize, cur: &mut Vec<i32>, mut sum: i32, res: &mut Vec<Vec<i32>>) {
+			if sum == target {
+				res.push(cur.clone());
+				return;
+			}
+			if i >= nums.len() || sum > target {
+				return;
+			}
+
+			sum += nums[i];
+			cur.push(nums[i]);
+			dfs(nums, target, i, cur, sum, res);
+
+			sum -= nums[i];
+			cur.pop();
+			dfs(nums, target, i+1, cur, sum, res);
+		}
+
+		dfs(&nums, target, 0, &mut vec![], 0, &mut res);
+
+		res
+    }
+}

decode-ways/tedkimdev.rs

@@ -0,0 +1,34 @@
+// SC: O(t/m)   -> maximum recursion depth
+// TC: O(2^(t/m))  
+// t = target value
+// m = smallest number in nums
+// t/m = maximum number of elements in a combination
+impl Solution {
+    pub fn num_decodings(s: String) -> i32 {
+        if s.starts_with('0') {
+            return 0;
+        }
+
+        // dfs
+        fn dfs(s: &str) -> i32 {
+            if s.is_empty() {
+                return 1;
+            }
+
+            let mut output = 0;
+            if s[..1].parse::<i32>().unwrap() != 0 {
+                output += dfs(&s[1..]);
+            }
+            if s.len() >= 2 && !s[..2].starts_with('0') {
+                if s[..2].parse::<i32>().unwrap() > 26 {
+                    return output;
+                } else {
+                    output += dfs(&s[2..]);
+                }
+            }            
+            output
+        }
+        dfs(&s)
+    }
+    
+}

maximum-subarray/tedkimdev.rs

@@ -0,0 +1,16 @@
+// SC: O(1)
+// TC: O(n)
+impl Solution {
+    pub fn max_sub_array(nums: Vec<i32>) -> i32 {
+        let mut max_sub = nums[0];
+        let mut cur_sum = 0;
+        for &num in &nums {
+            if cur_sum < 0 {
+                cur_sum = 0;
+            }
+            cur_sum += num;
+            max_sub = max_sub.max(cur_sum);
+        }
+        max_sub
+    }
+}

number-of-1-bits/tedkimdev.rs

@@ -0,0 +1,13 @@
+// TC: O(1)
+// SC: O(1)
+impl Solution {
+    pub fn hamming_weight(n: u32) -> i32 {
+        let mut count: i32 = 0;
+        for i in 0..32 {
+            if n & (1u32 << i) != 0 {
+                count += 1;
+            }
+        }
+        count
+    }
+}

valid-palindrome/tedkimdev.rs

@@ -0,0 +1,23 @@
+// TC: O(n)
+// SC: O(1)
+impl Solution {
+    pub fn is_palindrome(s: String) -> bool {
+        let s = s.as_bytes();
+        let (mut l, mut r) = (0i32, s.len() as i32 - 1);
+
+        while l < r {
+            while l < r && !s[l as usize].is_ascii_alphanumeric() {
+                l += 1;
+            }
+            while r > l && !s[r as usize].is_ascii_alphanumeric() {
+                r -= 1;
+            }
+            if s[l as usize].to_ascii_lowercase() != s[r as usize].to_ascii_lowercase() {
+                return false;
+            }
+            l += 1;
+            r -= 1;
+        }
+        true
+    }
+}