Merge pull request larissalages#32 from jaesharma/master

added cpp solutions for leetcode problems

Author: larissalages

leetcode/cpp/Array/11.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    int maxArea(vector<int>& height) {
+        int left=0,right=height.size()-1,area,x,y,temp;
+        while(left<right){
+            x=right-left;
+            y=min(height[left],height[right]);
+            temp=x*y;
+            if(temp>area){
+                area=temp;
+            }
+            if(height[left]<height[right]){
+                left+=1;
+            }else{
+                right-=1;
+            }
+        }
+        return area;
+    }
+};

leetcode/cpp/Array/121.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        if(!prices.size()) return 0;
+        int profit=0,max_profit=INT_MIN,min=prices[0];
+        for(int i=0;i<prices.size();i++){
+            if(prices[i]<min)
+                min=prices[i];
+            profit=prices[i]-min;
+            if(profit>max_profit)
+                max_profit=profit;
+        }
+        return max_profit;
+    }
+};

leetcode/cpp/Array/15.cpp

@@ -0,0 +1,34 @@
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+      vector<vector<int>> triplets;
+      if(nums.size()<3) return triplets;
+      vector<int> sortedNums;
+      copy(nums.begin(),nums.end(),back_inserter(sortedNums));
+      sort(sortedNums.begin(),sortedNums.end());
+      int indexA,indexB,indexC,a,sum;
+      for(int i=0;i<sortedNums.size()-2;i++){
+          indexA=i;
+          a=sortedNums[indexA];
+          if(a>0) return triplets;
+          if(i>0 && a==sortedNums[indexA-1]) continue;
+          indexB=i+1;
+          indexC=sortedNums.size()-1;
+          while(indexB<indexC){
+              sum=sortedNums[indexA]+sortedNums[indexB]+sortedNums[indexC];
+              if(sum==0){
+                  triplets.push_back({a,sortedNums[indexB],sortedNums[indexC]});
+                  while(indexB<indexC && sortedNums[indexB]==sortedNums[indexB+1]) indexB++;
+                  while(indexC>indexB && sortedNums[indexC]==sortedNums[indexC-1]) indexC--;
+                  indexB++;
+                  indexC--;
+              }else if(sum<0){
+                  indexB++;
+              }else{
+                  indexC--;
+              }
+          }
+      }
+      return triplets;
+    }
+};

leetcode/cpp/Array/152.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+     int maxProduct(vector<int>& nums) 
+    {
+         if(!nums.size()) return 0;
+         int mx=nums[0],mn=nums[0],ans=nums[0],x,y;
+         for(int i=1;i<nums.size();i++){
+             x=nums[i]*mx;
+             y=nums[i]*mn;
+             mx=max(nums[i],max(x,y));
+             mn=min(nums[i],min(x,y));
+             ans=max(ans,max(mx,mn));
+         }
+         return ans;
+    }
+};

leetcode/cpp/Array/16.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int threeSumClosest(vector<int>& nums, int target) {
+        if(nums.size()<3) return 0;
+        vector<int> sortedNums;
+        copy(nums.begin(),nums.end(),back_inserter(sortedNums));
+        sort(sortedNums.begin(),sortedNums.end());
+        int ans,a,sum,diff,mindiff=INT_MAX,indexA,indexB,indexC;
+        for(int i=0;i<sortedNums.size()-2;i++){
+            indexA=i;
+            a=sortedNums[indexA];
+            if(indexA>0 && a==sortedNums[indexA-1]) continue;
+            indexB=i+1;
+            indexC=sortedNums.size()-1;
+            while(indexB<indexC){
+                sum=sortedNums[indexA]+sortedNums[indexB]+sortedNums[indexC];
+                diff=abs(target-sum);
+                if(diff==0) return sum;
+                if(diff<mindiff){
+                    mindiff=diff;
+                    ans=sum;
+                }
+                if(sum<target) indexB++;
+                else indexC--;
+            }
+        }
+        return ans;
+    }
+};

leetcode/cpp/Array/26.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        int n=nums.size();
+        if (n<=1) return n; 
+	    int j = 0; 
+	    for (int i=0; i < n-1; i++) 
+	        if (nums[i] != nums[i+1]) 
+	            nums[j++] = nums[i]; 
+	  
+	    nums[j++] = nums[n-1]; 
+	  
+	    return j; 
+    }
+};

leetcode/cpp/Array/39.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    void helper(vector<int>& candidates,vector<vector<int>>& ans,vector<int>& combination,int target,int start){
+        if(target==0){
+            ans.push_back(combination);
+            return;
+        }
+        for(int i=start;i<candidates.size();i++){
+            if(candidates[i]>target) break;
+            combination.push_back(candidates[i]);
+            helper(candidates,ans,combination,target-candidates[i],i);
+            combination.pop_back();
+        }
+    }
+    
+    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
+        vector<vector<int>> ans;
+        vector<int> combination;
+        sort(candidates.begin(),candidates.end());
+        helper(candidates,ans,combination,target,0);
+        return ans;
+    }
+};

leetcode/cpp/Array/40.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    void helper(vector<int>& candidates,vector<int>& combination,vector<vector<int>>& ans,int target,int start){
+        if(target==0){
+            ans.push_back(combination);
+            return;
+        }
+        for(int i=start;i<candidates.size();i++){
+            if(candidates[i]>target) break;
+            if(i>start && candidates[i]==candidates[i-1]) continue;
+            combination.push_back(candidates[i]);
+            helper(candidates,combination,ans,target-candidates[i],i+1);
+            combination.pop_back();
+        }
+    }
+    
+    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
+        vector<vector<int>> ans;
+        vector<int> combination;
+        sort(candidates.begin(),candidates.end());
+        helper(candidates,combination,ans,target,0);
+        return ans;
+    }
+};

leetcode/cpp/Array/48.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    void swap(int *x,int *y){
+        int temp=*x;
+        *x=*y;
+        *y=temp;
+    }
+    
+    void rotate(vector<vector<int>>& matrix) {
+        int n=matrix.size(),temp;
+        for(int j=0;j<(n/2);j++){
+            for(int i=j;i<(n-1-j);i++){
+                temp=matrix[j][i];
+                swap(&temp,&matrix[i][n-1-j]);
+                swap(&temp,&matrix[n-1-j][n-1-i]);
+                swap(&temp,&matrix[n-1-i][j]);
+                swap(&temp,&matrix[j][i]);
+            }
+        }
+    }
+};

leetcode/cpp/Array/621.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int leastInterval(vector<char>& tasks, int n) {
+        vector<int> count(26,0);
+        int max_freq=0,min_units,task_count=tasks.size();
+        for(auto elem: tasks){
+            count[elem-'A']++;
+            if(count[elem-'A']>max_freq) max_freq=count[elem-'A'];
+        }
+        min_units=(max_freq-1)*(n+1);
+        for(int i=0;i<26;i++){
+            if(count[i]==max_freq) min_units++;
+        }
+        return max(min_units,task_count);
+    }
+};