Added C++ Solution

Author: FarheenB

C++/soln-array-problems/3sum.cpp

@@ -0,0 +1,44 @@
+/**
+ @author Farheen Bano
+
+ Date 11-08-2021
+
+ References-
+ https://www.interviewbit.com/problems/3-sum-zero/
+ https://leetcode.com/problems/3sum/
+*/
+
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {   
+        int n=nums.size();
+        vector<vector<int>> triplets;
+
+        if(n<3)
+            return triplets;
+        sort(nums.begin(),nums.end());
+        
+        for (int i=0; i<n-2; i++){
+            if(i>0 && nums[i]==nums[i-1])
+                continue;
+            
+            int left=i+1;
+            int right=n-1;            
+            while(left<right){
+                int sum=nums[i]+nums[left]+nums[right];
+                if(sum==0){
+                    triplets.push_back({nums[i],nums[left],nums[right]});  
+                    
+                    left++;
+                    while(left<n && nums[left]==nums[left-1])
+                        left++;
+                }
+                else if(sum<0)
+                    left++;
+                else
+                    right--;
+            }
+        }  
+        return triplets;
+    }
+};

C++/soln-array-problems/maximum-subarray.cpp

@@ -0,0 +1,25 @@
+/**
+ @author Farheen Bano
+  
+ Date 11-08-2021
+  
+ Reference-
+ https://leetcode.com/problems/maximum-subarray/
+ Kadane's Algorithm
+*/
+
+class Solution {
+public:
+    int maxSubArray(vector<int>& a) {
+        int size=a.size();
+        int max_sum = INT_MIN;
+        int cur_sum = 0; 
+  
+        for (int i = 0; i < size; i++){ 
+            cur_sum=max(a[i],cur_sum+a[i]);  
+            max_sum=max(max_sum, cur_sum); 
+            
+        }     
+        return max_sum;    
+    }
+};

C++/soln-backtracking-problems/combinations.cpp

@@ -0,0 +1,33 @@
+/**
+ @author Farheen Bano
+
+ Date 13-08-2021
+  
+ Reference-
+ https://leetcode.com/problems/combinations/
+*/
+
+class Solution {
+public:
+    vector<vector<int>> combine(int n, int k) {
+         vector<vector<int>> result;
+        vector<int> cur;
+        possibleCombination(n,1,k,cur,result);
+        return result;
+    }    
+    
+    void possibleCombination(int n, int start, int remaining, vector<int>& cur, vector<vector<int>>& result){
+        if(remaining==0)
+            result.push_back(cur);
+        
+        else{
+            for(int i=start;i<=n-remaining+1;i++){
+                if(find(cur.begin(),cur.end(),i)!=cur.end())
+                    continue;
+                cur.push_back(i);
+                possibleCombination(n,i+1,remaining-1,cur,result);
+                cur.pop_back();
+            }
+        }
+    }    
+};

C++/soln-backtracking-problems/permutations-ii.cpp

@@ -0,0 +1,41 @@
+/**
+ @author Farheen Bano
+  
+ Date 13-08-2021
+
+ References-
+ https://www.interviewbit.com/problems/all-unique-permutations/
+ https://leetcode.com/problems/permutations-ii/
+*/
+
+class Solution {
+public:
+    vector<vector<int>> permuteUnique(vector<int>& nums) {
+        vector<vector<int>> result;
+        vector<int> cur;
+        
+        unordered_map<int,int> counter;
+        for(int num:nums)
+            counter[num]++;    
+        
+        possiblePermutation(nums,cur,counter,result);
+        return result;
+    }    
+    
+     void possiblePermutation(vector<int>& nums, vector<int>& cur, unordered_map<int,int> counter, vector<vector<int>>& result){
+        if(cur.size()==nums.size())
+            result.push_back(cur);
+        
+        else{
+            for(auto& element:counter) {
+                if(counter[element.first]>0) {
+                    counter[element.first]--;
+                    cur.push_back(element.first);
+                    possiblePermutation(nums,cur,counter,result);
+                    cur.pop_back();
+                    counter[element.first]++;
+                }
+            }
+        }
+    }
+};

C++/soln-backtracking-problems/permutations.cpp

@@ -0,0 +1,34 @@
+/**
+ @author Farheen Bano
+  
+ Date 13-08-2021
+
+ References-
+ https://www.interviewbit.com/problems/permutations/
+ https://leetcode.com/problems/permutations/
+*/
+
+class Solution {
+public:
+    vector<vector<int>> permute(vector<int>& nums) {
+        vector<vector<int>> result;
+        vector<int> cur;
+        possiblePermutation(nums,cur,result);
+        return result;
+    }
+    
+    void possiblePermutation(vector<int>& nums, vector<int>& cur, vector<vector<int>>& result){        
+        if(cur.size()==nums.size())
+            result.push_back(cur);
+                
+        else{
+            for(int i=0;i<nums.size();i++){
+                if(find(cur.begin(), cur.end(), nums[i]) != cur.end())
+                    continue;
+                cur.push_back(nums[i]);
+                possiblePermutation(nums,cur,result);
+                cur.pop_back();
+            }
+        }
+    }
+};

C++/soln-backtracking-problems/subsets-ii.cpp

@@ -0,0 +1,31 @@
+/**
+ @author Farheen Bano
+
+ Date 13-08-2021
+  
+ Reference-
+ https://leetcode.com/problems/subsets-ii/
+*/
+
+class Solution {
+public:
+    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
+        sort(nums.begin(),nums.end());
+        vector<vector<int>> result;
+        vector<int> cur;
+        generateSubsets(0,nums,cur,result);
+        return result;
+    }
+    
+     void generateSubsets(int index, vector<int>& nums, vector<int>& cur, vector<vector<int>>& result){        
+        result.push_back(cur);
+
+        for(int i=index;i<nums.size();i++){
+            if(i>index && nums[i]==nums[i-1])
+                continue;
+            cur.push_back(nums[i]);
+            generateSubsets(i+1,nums,cur,result);
+            cur.pop_back();
+        }
+    }
+};

C++/soln-backtracking-problems/subsets.cpp

@@ -0,0 +1,28 @@
+/**
+ @author Farheen Bano
+  
+ Date 13-08-2021
+  
+ Reference-
+ https://leetcode.com/problems/subsets/
+*/
+
+class Solution {
+public:
+    vector<vector<int>> subsets(vector<int>& nums) {
+        vector<vector<int>> result;
+        vector<int> cur;
+        generateSubsets(0,nums,cur,result);
+        return result;
+    }
+    
+    void generateSubsets(int index, vector<int>& nums, vector<int>& cur, vector<vector<int>>& result){        
+        result.push_back(cur);
+
+        for(int i=index;i<nums.size();i++){
+            cur.push_back(nums[i]);
+            generateSubsets(i+1,nums,cur,result);
+            cur.pop_back();
+        }
+    }
+};

C++/soln-recursion-problems/generate-parentheses.cpp

@@ -0,0 +1,32 @@
+/**
+ @author Farheen Bano
+  
+ Date 13-08-2021
+
+ Reference-
+ https://leetcode.com/problems/generate-parentheses/
+*/
+
+class Solution {
+public:
+    vector<string> result;
+    
+    vector<string> generateParenthesis(int n) {
+        if(n==0)
+           return result;        
+        solve(n,n,"");
+        return result;        
+    }
+    
+    void solve(int open_br, int close_br, string str){
+        if(open_br==0 && close_br==0){
+            result.push_back(str);
+            return; 
+        }    
+        if(open_br!=0)
+            solve(open_br-1,close_br,str+"(");
+        
+        if(close_br>open_br)
+            solve(open_br,close_br-1,str+")");
+    }
+};

C++/soln-string-problems/anagrams-group-string-list.cpp

@@ -0,0 +1,30 @@
+/**
+ @author Farheen Bano
+
+ Date 15-07-2021
+  
+ References-
+ https://www.geeksforgeeks.org/given-a-sequence-of-words-print-all-anagrams-together/
+ https://leetcode.com/problems/group-anagrams/
+*/
+
+class Solution {
+public:
+    vector<vector<string>> groupAnagrams(vector<string>& strs) {
+        vector<vector<string>> result; 
+        if (strs.size() == 0) 
+            return result;
+        
+        unordered_map<string, vector<string>> anagrams;
+        for (string s : strs) {
+            string copy_s=s;
+            sort(s.begin(),s.end());
+            anagrams[s].push_back(copy_s);
+        }
+    
+        for(auto x:anagrams)
+            result.push_back(x.second);
+
+        return result;
+    }
+};

C++/soln-string-problems/longest-common-prefix.cpp

@@ -0,0 +1,30 @@
+/**
+ @author Farheen Bano
+  
+ Date 11-08-2021
+  
+ Reference-
+ https://leetcode.com/problems/longest-common-prefix/
+*/
+
+class Solution {
+public:
+    string longestCommonPrefix(vector<string>& strs) {
+        if(strs.size()==0)
+            return "";
+        if(strs.size()==1)
+            return strs[0];
+        
+        string first_word=strs[0];
+        string prefix="";
+
+        for(int i=0;i<first_word.size();i++){
+            for(int j=1;j<strs.size();j++)
+                if(i>=strs[j].size() || first_word[i]!=strs[j][i]){
+                    return prefix;
+            }
+            prefix=prefix+""+first_word[i];            
+        }
+        return prefix;
+    }
+};