Merge pull request DaleStudy#1208 from PDKhan/main

[PDKhan] WEEK 02 solutions

Author: PDKhan

3sum/PDKhan.cpp

@@ -0,0 +1,36 @@
+class Solution {
+    public:
+        vector<vector<int>> threeSum(vector<int>& nums) {
+            vector<vector<int>> result;
+            sort(nums.begin(), nums.end());
+    
+            for(int i = 0; i < nums.size(); i++){
+                if(i > 0 && nums[i] == nums[i-1])
+                    continue;
+                
+                int left = i + 1;
+                int right = nums.size() - 1;
+    
+                while(left < right){
+                    int sum = nums[i] + nums[left] + nums[right];
+    
+                    if(sum == 0){
+                        result.push_back({nums[i], nums[left], nums[right]});
+                        left++;
+                        right--;
+    
+                        while(left < right && nums[left] == nums[left-1])
+                            left++;
+                    
+                        while(left < right && nums[right] == nums[right+1])
+                            right--;
+                    }else if(sum < 0)
+                        left++;
+                    else
+                        right--;
+                }
+            }
+    
+            return result;
+        }
+    };

climbing-stairs/PDKhan.cpp

@@ -0,0 +1,20 @@
+class Solution {
+    public:
+        int climbStairs(int n) {
+            if(n < 2)
+                return 1;
+    
+            int curr = 0;
+            int prev1 = 1;
+            int prev2 = 1;
+            
+            for(int i = 2; i <= n; i++){
+                curr = prev1 + prev2;
+                prev2 = prev1;
+                prev1 = curr;
+            }
+    
+            return curr;
+        }
+    };
+

product-of-array-except-self/PDKhan.cpp

@@ -0,0 +1,22 @@
+class Solution {
+    public:
+        vector<int> productExceptSelf(vector<int>& nums) {
+            int n = nums.size();
+            vector<int> result(n, 1);
+    
+            int left = 1;
+    
+            for(int i = 0; i < n; i++){
+                result[i] = left;
+                left *= nums[i];
+            }
+    
+            int right = 1;
+            for(int i = n - 1; i >= 0; i--){
+                result[i] *= right;
+                right *= nums[i];
+            }
+    
+            return result;
+        }
+    };

valid-anagram/PDKhan.cpp

@@ -0,0 +1,21 @@
+class Solution {
+    public:
+        bool isAnagram(string s, string t) {
+            unordered_map<char, int> map;
+    
+            if(s.length() != t.length())
+                return false;
+    
+            for(int i = 0; i < s.length(); i++)
+                map[s[i]]++;
+            
+            for(int i = 0; i < t.length(); i++){
+                if(map[t[i]] == 0)
+                    return false;
+    
+                map[t[i]]--;
+            }
+    
+            return true;
+        }
+    };

validate-binary-search-tree/PDKhan.cpp

@@ -0,0 +1,16 @@
+class Solution {
+    public:
+        bool search(TreeNode* root, long min, long max){
+            if(root == NULL)
+                return true;
+    
+            if(root->val <= min || root->val >= max)
+                return false;
+            
+            return search(root->left, min, root->val) && search(root->right, root->val, max);
+        }
+    
+        bool isValidBST(TreeNode* root) {
+            return search(root, (long)INT_MIN-1, (long)INT_MAX+1);
+        }
+    };