Merge pull request #2099 from ys-han00/main

[ys-han00] WEEK 03 solutions

Author: ys-han00

combination-sum/ys-han00.cpp

@@ -0,0 +1,41 @@
+class Solution {
+public:
+    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
+        vector<vector<int>> ans;
+        queue<pair<int, vector<int>>> que;
+        vector<int> comb;
+        int sum, num;
+
+        sort(candidates.begin(), candidates.end());
+
+        for(int i = 0; i < candidates.size(); i++) {
+            num = candidates[i];
+            if(num > target)  
+                continue;
+            que.push({num, vector<int> ({num})});
+        }
+
+        while(!que.empty()) {
+            sum = que.front().first;
+            comb = que.front().second;
+            que.pop();
+            
+            if(sum == target) {
+                ans.push_back(comb);
+                continue;
+            }
+
+            for(int i = 0; i < candidates.size(); i++) {
+                num = candidates[i];
+                if(sum + num <= target && comb[comb.size() - 1] <= num) {
+                    comb.push_back(num);
+                    que.push({sum + num, comb});
+                    comb.pop_back();
+                }
+            }
+        }
+
+        return ans;
+    }
+};
+

decode-ways/ys-han00.cpp

@@ -0,0 +1,88 @@
+// class Solution {
+// public:
+//     int numDecodings(string s) {
+//         int n = s.size(), idx, ways, two;
+
+//         queue<int> que;
+//         vector<int> memo(n, 0);
+
+//         if(s[0] != '0') {
+//             que.push(0);
+//             memo[0] = 1;
+//         }
+
+//         if(n >= 2) {
+//             two = (s[0] - '0') * 10 + (s[1] - '0');
+//             if(10 <= two && two <= 26) {
+//                 que.push(1);
+//                 memo[1] = 1;
+//             }
+//         }
+
+//         while(!que.empty()) {
+//             idx = que.front();
+//             que.pop();
+
+//             ways = memo[idx];
+
+//             if(idx + 1 < n && s[idx + 1] != '0') {
+//                 if(memo[idx + 1] == 0) 
+//                     que.push(idx + 1);
+//                 memo[idx + 1] += ways;
+//             }
+
+//             if(idx + 2 < n) {
+//                 two = (s[idx + 1] - '0') * 10 + (s[idx + 2] - '0');
+//                 if(10 <= two && two <= 26) {
+//                     if(memo[idx + 2] == 0)
+//                         que.push(idx + 2);
+//                     memo[idx + 2] += ways;
+//                 }
+//             }
+//         }
+
+//         return memo[n - 1];
+//     }
+// };
+
+// class Solution {
+// public:
+//     int numDecodings(string s) {
+//         vector<int> dp(s.size() + 1, 1);
+
+//         for(int i = s.size() - 1; i >=0; i--) {
+//             if(s[i] == '0') {
+//                 dp[i] = 0;
+//                 continue;
+//             }
+            
+//             dp[i] = dp[i + 1];
+//             if(i + 1 < s.size() && (s[i] - '0') * 10 + (s[i + 1] - '0') < 27)
+//                 dp[i] += dp[i + 2];
+//         }
+
+//         return dp[0];
+//     }
+// };
+
+class Solution {
+public:
+    int numDecodings(string s) {
+        int cur = 1, nxt = 0, tmp;
+
+        for(int i = s.size() - 1; i >=0; i--) {
+            if(s[i] == '0') {
+                nxt = cur;
+                cur = 0;
+                continue;
+            }
+            tmp = nxt;
+            nxt = cur;
+            if(i + 1 < s.size() && (s[i] - '0') * 10 + (s[i + 1] - '0') < 27)
+                cur += tmp;   
+        }
+
+        return cur;
+    }
+};
+

maximum-subarray/ys-han00.cpp

@@ -0,0 +1,34 @@
+// class Solution {
+// public:
+//     int maxSubArray(vector<int>& nums) {
+//         vector<int> dp(nums.size(), 0x8000000);
+//         int ans = 0x80000000;
+
+//         dp[0] = nums[0];
+//         ans = max(ans, dp[0]);
+
+//         for(int i = 1; i < nums.size(); i++) {
+//             dp[i] = max(dp[i - 1] + nums[i], nums[i]);
+//             ans = max(ans, dp[i]);
+//         }
+
+//         return ans;
+//     }
+// };
+
+class Solution {
+public:
+    int maxSubArray(vector<int>& nums) {
+        int ans = 0x80000000, sum;
+
+        sum = nums[0];
+        ans = sum;
+        for(int i = 1; i < nums.size(); i++) {
+            sum = max(sum + nums[i], nums[i]);
+            ans = max(ans, sum);
+        }
+
+        return ans;
+    }
+};
+

number-of-1-bits/ys-han00.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int hammingWeight(int n) {
+        int ans = 0;
+        
+        while(n) {
+            if(n % 2 == 1)
+                ans++;
+            n /= 2;
+        }
+        
+        return ans;
+    }
+};
+

valid-palindrome/ys-han00.cpp

@@ -0,0 +1,56 @@
+// class Solution {
+// public:
+//     bool isPalindrome(string s) {
+//         string new_s;
+
+//         for(char c : s)
+//             if(isalpha(c) || isdigit(c))
+//                 new_s += tolower(c);
+        
+//         int left = 0, right = new_s.size() - 1;
+
+//         while(left < right) {
+//             if(new_s[left] != new_s[right])
+//                 return false;
+//             left++;
+//             right--;
+//         }
+
+//         return true;
+//     }
+// };
+
+class Solution {
+public:
+    bool isPalindrome(string s) {
+        int left = 0, right = s.size() - 1;
+
+        while(left < right) {
+            if(!isalnum(s[left])) {
+                left++;
+                continue;
+            }
+            if(!isalnum(s[right])) {
+                right--;
+                continue;
+            }
+
+            if(isdigit(s[left]) && isdigit(s[right])) {
+                if(s[left] != s[right]) {
+                    return false;
+                }
+            }
+            else if(isalpha(s[left]) && isalpha(s[right])) {
+                if(tolower(s[left]) != tolower(s[right]))
+                    return false;
+            }
+            else 
+                return false;
+            left++;
+            right--;
+        }
+
+        return true;
+    }
+};
+