🚀 28-Jun-2020

Author: sureshmangs

array/generate_all_subarrays.cpp

@@ -0,0 +1,29 @@
+/*
+A subbarray is a contiguous part of array. An array that is inside another array. For example, consider the array [1, 2, 3, 4], There are 10 non-empty sub-arrays. The subbarays are (1), (2), (3), (4), (1,2), (2,3), (3,4), (1,2,3), (2,3,4) and (1,2,3,4). In general, for an array/string of size n, there are n*(n+1)/2 non-empty subarrays/subsrings.
+*/
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+void allSubArray(int a[], int n)
+{
+	for (int i=0; i <n; i++){
+		for (int j=i; j<n; j++){
+			for (int k=i; k<=j; k++)
+				cout << a[k] << " ";
+			cout << endl;
+		}
+	}
+}
+
+int main()
+{   int n=4;
+	int a[] = {1, 2, 3, 4};
+	allSubArray(a, n);
+	return 0;
+}

array/largest_subarray_with_sum_0.cpp

@@ -0,0 +1,80 @@
+/*
+
+Given an array having both positive and negative integers. The task is to compute the length of the largest subarray with sum 0.
+
+Input:
+The first line of input contains an element T denoting the number of test cases. Then T test cases follow. Each test case consists of 2 lines. The first line of each test case contains a number denoting the size of the array A. Then in the next line are space-separated values of the array A.
+
+Output:
+For each test case, the output will be the length of the largest subarray which has sum 0.
+
+User Task:
+Since this is a functional problem you don't have to worry about input, you just have to complete the function maxLen() which takes two arguments an array A and n, where n is the size of the array A and returns the length of the largest subarray with 0 sum.
+
+Expected Time Complexity: O(N*Log(N)).
+Expected Auxiliary Space: O(N).
+
+Constraints:
+1 <= T <= 100
+1 <= N <= 104
+-1000 <= A[i] <= 1000, for each valid i
+
+Example:
+Input
+1
+8
+15 -2 2 -8 1 7 10 23
+
+Output
+5
+
+Explanation
+Testcase 1: In the above test case the largest subarray with sum 0 will be -2 2 -8 1 7.
+*/
+
+
+
+
+
+
+
+
+
+
+
+#include <bits/stdc++.h>
+using namespace std;
+
+int maxLen(int A[], int n);
+
+int main()
+{
+    int T;
+    cin >> T;
+    while (T--)
+    {
+        int N;
+        cin >> N;
+        int A[N];
+        for (int i = 0; i < N; i++)
+            cin >> A[i];
+        cout << maxLen(A, N) << endl;
+    }
+}
+
+
+
+
+int maxLen(int a[], int n)
+{
+   int maxLen=0;
+   unordered_map<int, int> m;
+   int sum=0;
+   for(int i=0;i<n;i++){
+       sum+=a[i];
+       if(sum==0) maxLen=max(maxLen, i+1);
+       if(m.find(sum)!=m.end()) maxLen=max(maxLen, i-m[sum]);
+       else m.insert({sum, i});
+   }
+   return maxLen;
+}

array/three_sum_problem.cpp

@@ -0,0 +1,69 @@
+/*
+Given an array A[] of N numbers and another number x, determine whether or not there exist three elements in A[] whose sum is exactly x.
+
+Input:
+First line of input contains number of testcases T. For each testcase, first line of input contains n and x. Next line contains array elements.
+
+Output:
+Print 1 if there exist three elements in A whose sum is exactly x, else 0.
+
+Constraints:
+1 ≤ T ≤ 100
+1 ≤ N ≤ 103
+1 ≤ A[i] ≤ 105
+
+Example:
+Input:
+2
+6 13
+1 4 45 6 10 8
+5 10
+1 2 4 3 6
+
+Output:
+1
+1
+
+Explanation:
+Testcase 1: There is one triplet with sum 13 in the array. Triplet elements are 1, 4, 8, whose sum is 13.
+*/
+
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+
+int threeSum(int a[], int n, int x){
+    sort(a, a+n);
+    for(int i=0;i<n-2;i++){
+        int reqSum=x-a[i];
+        int l=i+1, r=n-1;
+        while(l<r){
+            else if(a[l]+a[r]<reqSum) l++;
+            else r--;
+        }
+    }
+    return 0;
+}
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n, x;
+        cin>>n>>x;
+        int a[n];
+        for(int i=0;i<n;i++) cin>>a[i];
+        cout<<threeSum(a, n, x)<<endl;
+    }
+
+return 0;
+}

competitive programming/leetcode/15. 3Sum.cpp

@@ -0,0 +1,53 @@
+Given an array nums of n integers, are there elements a, b, c in nums such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.
+
+Note:
+
+The solution set must not contain duplicate triplets.
+
+Example:
+
+Given array nums = [-1, 0, 1, 2, -1, -4],
+
+A solution set is:
+[
+  [-1, 0, 1],
+  [-1, -1, 2]
+]
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        vector<vector<int> > res;
+        int n=nums.size();
+        if(n<3) return res;
+
+        sort(nums.begin(), nums.end());
+
+        for(int i=0;i<n-2;i++){
+            if(i==0 || (i>0 && nums[i]!=nums[i-1])){ // not taking duplicates
+                int sum=0-nums[i];
+                int low=i+1, high=n-1;
+                while(low<high){
+                    if(nums[low]+nums[high]==sum){
+                        res.push_back({nums[i], nums[low], nums[high]});
+                        while(low<high && nums[low]==nums[low+1]) low++;
+                        while(low<high && nums[high]==nums[high-1]) high--;
+                        low++; high--;
+                    } else if(nums[low]+nums[high]>sum) high--;
+                    else low++;
+                }
+
+            }
+        }
+        return res;
+    }
+};

competitive programming/leetcode/18. 4Sum.cpp

@@ -0,0 +1,61 @@
+Given an array nums of n integers and an integer target, are there elements a, b, c, and d in nums such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.
+
+Note:
+
+The solution set must not contain duplicate quadruplets.
+
+Example:
+
+Given array nums = [1, 0, -1, 0, -2, 2], and target = 0.
+
+A solution set is:
+[
+  [-1,  0, 0, 1],
+  [-2, -1, 1, 2],
+  [-2,  0, 0, 2]
+]
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<vector<int>> fourSum(vector<int>& nums, int target) {
+        vector<vector<int> > res;
+        int n=nums.size();
+        if(n<4) return res;
+
+        sort(nums.begin(), nums.end());
+
+        for(int i=0;i<n-3;i++){
+            if(i==0 || (i>0 && nums[i]!=nums[i-1])){  // check duplicates
+                int k1=target-nums[i];
+                for(int j=i+1;j<n-2;j++){
+                    if(j==i+1 || (j>i+1 && nums[j]!=nums[j-1])){  // check duplicates
+                        int k2=k1-nums[j];
+                        int low=j+1, high=n-1;
+                        while(low<high){
+                            if(nums[low]+nums[high]==k2){
+                                res.push_back({nums[i], nums[j], nums[low], nums[high]});
+                                while(low<high && nums[low]==nums[low+1]) low++;
+                                while(low<high && nums[high]==nums[high-1]) high--;
+                                low++;
+                                high--;
+                            }
+                            else if(nums[low]+nums[high]>k2) high--;
+                            else low++;
+                        }
+                }
+
+            }
+        }
+    }
+        return res;
+    }
+};

competitive programming/leetcode/2020-June-Challenge/Day-27-Perfect Squares.cpp

@@ -0,0 +1,63 @@
+
+Given a positive integer n, find the least number of perfect square numbers (for example, 1, 4, 9, 16, ...) which sum to n.
+
+Example 1:
+
+Input: n = 12
+Output: 3
+Explanation: 12 = 4 + 4 + 4.
+Example 2:
+
+Input: n = 13
+Output: 2
+Explanation: 13 = 4 + 9.
+
+
+
+
+
+
+
+class Solution {
+public:
+    int numSquares(int n) {
+        if(n<=3) return n;
+        int dp[n+1];
+
+        for(int i=0;i<=n;i++){
+            dp[i]=i;
+            for(int j=1;j*j<=i;j++){
+                int sq=j*j;
+                dp[i]=min(dp[i], 1+dp[i-sq]);
+            }
+        }
+        return dp[n];
+    }
+};
+
+
+
+
+
+
+
+
+//Recursion
+class Solution {
+    int solve(int n)
+    {
+        if(n<=3)
+            return n;
+
+        int ans=n;
+        for(int i=1;i*i<=n;++i)
+           ans = min(ans,1+solve(n-i*i));
+
+        return ans;
+    }
+public:
+    int numSquares(int n) {
+        int ans = solve(n);
+        return ans;
+    }
+};