added cpp solutions for leetcode problems

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);
+    }
+};

leetcode/cpp/Binary Search/162.cpp

@@ -0,0 +1,30 @@
+//brute force
+class Solution {
+public:
+    int findPeakElement(vector<int>& nums) {
+        bool flag;
+        for(int i=0;i<nums.size();i++){
+            flag=1;
+            if(i>0) flag&=(nums[i]>nums[i-1]);
+            if(i<nums.size()-1) flag&=(nums[i]>nums[i+1]);
+            if(flag) return i;
+        }
+        return -1;
+    }
+};
+
+//binary search
+class Solution {
+public:
+    int findPeakElement(vector<int>& nums) {
+        int l=0,r=nums.size()-1,mid;
+        while(l+1<r){
+            mid=(l+r)/2;
+            if(nums[mid]<nums[mid+1]) l=mid;
+            else if(nums[mid]<nums[mid-1]) r=mid;
+            else return mid;
+        }
+        if(nums[l]>nums[r]) return l;
+        return r;
+    }
+};

leetcode/cpp/Binary Search/278.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int firstBadVersion(int n) {
+        long long int l=1,r=n,mid;
+        while(l<=r){
+            mid=(l+r)/2;
+            if(isBadVersion(mid)) r=mid-1;
+            else l=mid+1;
+        }
+        return l;
+    }
+};

leetcode/cpp/Binary Search/287.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    bool duplicateRange(vector<int> &nums,int l,int r){
+        int count=0;
+        for(int i=0;i<nums.size();i++){
+            if(nums[i]>=l && nums[i]<=r) ++count;
+        }
+        return r-l+1<count;
+    }
+
+    int findDuplicate(vector<int>& nums) {
+        int l=1,r=nums.size()-1,mid;
+        while(l<r){
+            mid=(l+r)/2;
+            if(duplicateRange(nums,l,mid)) r=mid;
+            else l=mid+1;
+        }
+        return l;
+    }
+};

leetcode/cpp/Divide&Conquer/4.cpp

@@ -0,0 +1,53 @@
+class Solution {
+public:
+    int findpos(vector<int> &x,int target){
+        int m=x.size(),left=0,right=x.size(),pos;
+        while(left<right){
+            pos=(int)(left+right)/2;
+            if(target>=x[pos]){
+                if(pos<m-1){
+                    if(target<=x[pos+1]) break;
+                }else{
+                    break;
+                }
+            }
+            if(x[pos]<target) left=pos+1;
+            else right=pos-1;
+        }
+        return pos;
+    }
+    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
+        int m=nums1.size(),n=nums2.size();
+        unsigned int pos=0;
+        if(m && n) pos=findpos(nums1,nums2[0]);
+        if(pos) pos-=1;
+        int i=pos,j=0;
+        vector<int> v;
+        if(!m) v=nums1;
+        else if(!n) v=nums2;
+        else v.insert(v.end(),nums1.begin(),nums1.begin()+i);
+        while(true){
+            if(i==m){
+             v.insert(v.end(),nums2.begin()+j,nums2.end());
+             break;
+            }
+            if(j==n){
+                v.insert(v.end(),nums1.begin()+i,nums1.end());
+                break;
+            }
+            if(nums1[i]<=nums2[j]){
+                v.push_back(nums1[i]);
+                i++;
+            }else{
+                v.push_back(nums2[j]);
+                j++;
+            }
+        }
+        int size=v.size();
+        int mid=(int)size/2;
+        if(size%2){
+            return v[mid];
+        }
+        return (v[mid]+v[mid-1])/2.0;
+    }
+};

leetcode/cpp/Divide&Conquer/53.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int maxSubArray(vector<int>& nums) {
+        int sum=0,ans=INT_MIN;
+        for(auto i:nums){
+            sum+=i;
+            ans=max(ans,sum);
+            sum=max(sum,0);
+        }
+        return ans;
+    }
+};