Practise 09-Jun-2020

Author: sureshmangs

competitive programming/leetcode/2020-June-Challenge/Day-08-Power of Two.cpp

@@ -0,0 +1,28 @@
+Given an integer, write a function to determine if it is a power of two.
+
+Example 1:
+
+Input: 1
+Output: true
+Explanation: 20 = 1
+Example 2:
+
+Input: 16
+Output: true
+Explanation: 24 = 16
+Example 3:
+
+Input: 218
+Output: false
+
+
+
+
+class Solution {
+public:
+    bool isPowerOfTwo(int n) {
+         if(abs(floor(log2(n))-ceil(log2(n)))==0) return true;
+         else return false;
+    }
+};
+

competitive programming/leetcode/231. Power of Two.cpp

@@ -0,0 +1,29 @@
+Given an integer, write a function to determine if it is a power of two.
+
+Example 1:
+
+Input: 1
+Output: true
+Explanation: 20 = 1
+Example 2:
+
+Input: 16
+Output: true
+Explanation: 24 = 16
+Example 3:
+
+Input: 218
+Output: false
+
+
+
+
+
+class Solution {
+public:
+    bool isPowerOfTwo(int n) {
+         if(abs(floor(log2(n))-ceil(log2(n)))==0) return true;
+         else return false;
+    }
+};
+

dynamic programming/minimum_sum_partition.cpp

@@ -0,0 +1,100 @@
+/*
+Given an array, the task is to divide it into two sets S1 and S2 such that the absolute difference between their sums is minimum.
+
+Input:
+The first line contains an integer 'T' denoting the total number of test cases. In each test cases, the first line contains an integer 'N' denoting the size of array. The second line contains N space-separated integers A1, A2, ..., AN denoting the elements of the array.
+
+
+Output:
+In each seperate line print minimum absolute difference.
+
+
+Constraints:
+1<=T<=200
+1<=N<=50
+1<=A[i]<=200
+
+
+Example:
+Input:
+2
+4
+1 6 5 11
+4
+36 7 46 40
+
+Output :
+1
+23
+
+Explaination :
+Testcase 1:
+Subset1 = {1, 5, 6} ; sum of Subset1 = 12
+Subset2 = {11} ;       sum of Subset2 = 11
+
+Testcase 2:
+Subset1 = {7, 46} ;   sum = 53
+Subset2 = {36, 40} ; sum = 76
+*/
+
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int minSumPartion(int a[], int n){
+    int range=0;
+    for(int i=0;i<n;i++) range+=a[i];
+
+    bool dp[n+1][range+1];
+
+    for(int i=0;i<n+1;i++) dp[i][0]=true;
+    for(int j=1;j<range+1;j++) dp[0][j]=false;
+
+    for(int i=1;i<n+1;i++){
+        for(int j=1;j<range+1;j++){
+            if(a[i-1]<=j){
+                dp[i][j]=dp[i-1][j-a[i-1]] || dp[i-1][j];
+            } else {
+                dp[i][j]=dp[i-1][j];
+            }
+        }
+    }
+
+    vector<int> v;
+    for(int j=0;j<(range)/2 + 1;j++){
+        if(dp[n][j]) v.push_back(j);
+    }
+
+    int mini=INT_MAX;
+
+    for(auto x: v){
+        int tmp=range-2*x;
+        if(tmp<mini) mini=tmp;
+    }
+
+    return mini;
+
+}
+
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;
+        int a[n];
+        for(int i=0;i<n;i++) cin>>a[i];
+        cout<<minSumPartion(a,n)<<endl;
+    }
+
+return 0;
+}

dynamic programming/subset_count_with_given_difference.cpp

@@ -0,0 +1,47 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int subsetCountDiff(int a[], int x, int n){
+    int dp[n+1][x+1];
+
+    for(int i=0;i<n+1;i++)  dp[i][0]=1;
+    for(int j=1;j<x+1;j++) dp[0][j]=0;
+
+    for(int i=1;i<n+1;i++){
+        for(int j=1;j<x+1;j++){
+            if(a[i-1]<=j){
+                dp[i][j]=dp[i-1][j-a[i-1]] + dp[i-1][j];
+            }
+            else dp[i][j]=dp[i-1][j];
+        }
+    }
+
+    return dp[n][x];
+}
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;
+        int a[n];
+
+        for(int i=0;i<n;i++) cin>>a[i];
+
+        int diff;
+        cin>>diff;
+
+        int sum=0;
+        for(int i=0;i<n;i++) sum+=a[i];
+
+        int x=(diff+sum);
+
+        if(x%2!=0) cout<<"0"<<endl;
+        else cout<<subsetCountDiff(a, x/2, n)<<endl;
+    }
+return 0;
+}

dynamic programming/subset_sum.cpp

@@ -40,10 +40,10 @@ bool subsetsum(int a[], int sum, int n){
 
     for(int i=1;i<n+1;i++){
         for(int j=1;j<sum+1;j++){
-            if(a[i-1]<=sum){
+            if(a[i-1]<=j){
                 dp[i][j]=dp[i-1][j-a[i-1]] || dp[i-1][j];
             }
-            else dp[i][j]=dp[i-1][sum];
+            else dp[i][j]=dp[i-1][j];
         }
     }
     return dp[n][sum];

dynamic programming/subset_sum_count.cpp

@@ -1,30 +1,43 @@
+/*
+Given an array arr[] of length N and an integer X, the task is to find the number of subsets with sum equal to X.
+
+Examples:
+
+Input: arr[] = {1, 2, 3, 3}, X = 6
+Output: 3
+All the possible subsets are {1, 2, 3},
+{1, 2, 3} and {3, 3}
+
+
+
+Input: arr[] = {1, 1, 1, 1}, X = 1
+Output: 4
+*/
+
+
+
+
+
+
 #include<bits/stdc++.h>
 using namespace std;
 
 int subsetsumcount(int a[], int sum, int n){
-    bool dp[n+1][sum+1];
+    int dp[n+1][sum+1];
 
-    for(int i=0;i<n+1;i++)  dp[i][0]=true;
-    for(int j=1;j<sum+1;j++) dp[0][j]=false;
+    for(int i=0;i<n+1;i++)  dp[i][0]=1;
+    for(int j=1;j<sum+1;j++) dp[0][j]=0;
 
     for(int i=1;i<n+1;i++){
         for(int j=1;j<sum+1;j++){
-            if(a[i-1]<=sum){
-                dp[i][j]=dp[i-1][j-a[i-1]] || dp[i-1][j];
+            if(a[i-1]<=j){
+                dp[i][j]=dp[i-1][j-a[i-1]] + dp[i-1][j];
             }
-            else dp[i][j]=dp[i-1][sum];
+            else dp[i][j]=dp[i-1][j];
         }
     }
-    for(int i=0;i<n+1;i++){
-        for(int j=0;j<sum+1;j++){
-            cout<<dp[i][j]<<" ";
-        } cout<<endl;
-    }
-    int cnt=0;
-    for(int i=0;i<n+1;i++){
-        if(dp[i][sum]==true) cnt++;
-    }
-    return cnt;
+
+    return dp[n][sum];
 }
 
 int main(){