🚀 12-Sep-2020

Author: sureshmangs

competitive programming/codeforces/1406A - Subset Mex.cpp

@@ -0,0 +1,111 @@
+/*
+A. Subset Mex
+time limit per test1 second
+memory limit per test512 megabytes
+inputstandard input
+outputstandard output
+Given a set of integers (it can contain equal elements).
+
+You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
+
+Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
+
+mex({1,4,0,2,2,1})=3
+mex({3,3,2,1,3,0,0})=4
+mex(∅)=0 (mex for empty set)
+The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
+
+Input
+The input consists of multiple test cases. The first line contains an integer t (1≤t≤100) — the number of test cases. The description of the test cases follows.
+
+The first line of each test case contains an integer n (1≤n≤100) — the size of the set.
+
+The second line of each testcase contains n integers a1,a2,…an (0≤ai≤100) — the numbers in the set.
+
+Output
+For each test case, print the maximum value of mex(A)+mex(B).
+
+Example
+inputCopy
+4
+6
+0 2 1 5 0 1
+3
+0 1 2
+4
+0 2 0 1
+6
+1 2 3 4 5 6
+outputCopy
+5
+3
+4
+0
+Note
+In the first test case, A={0,1,2},B={0,1,5} is a possible choice.
+
+In the second test case, A={0,1,2},B=∅ is a possible choice.
+
+In the third test case, A={0,1,2},B={0} is a possible choice.
+
+In the fourth test case, A={1,3,5},B={2,4,6} is a possible choice.
+
+
+*/
+
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+
+    int t;
+    cin>>t;
+
+    while(t--){
+        int n;
+        cin>>n;
+
+        vector<int> v;
+        for(int i=0;i<n;i++){
+            int ch;
+            cin>>ch;
+            v.push_back(ch);
+        }
+
+        set<int> a, b;
+
+        for(auto &x: v){
+            if(a.find(x)==a.end()){
+                a.insert(x);
+            } else b.insert(x);
+        }
+
+
+        int i, res=0;
+        for(i=0;i<101;i++){
+            if(a.find(i)==a.end())
+                break;
+        }
+
+        res+=i;
+
+        for(i=0;i<101;i++){
+            if(b.find(i)==b.end())
+                break;
+        }
+
+        res+=i;
+
+        cout<<res<<endl;
+    }
+
+    return 0;
+}

competitive programming/leetcode/2020-September-Challenge/Day-11-Maximum Product Subarray.cpp

@@ -0,0 +1,47 @@
+Given an integer array nums, find the contiguous subarray within an array (containing at least one number) which has the largest product.
+
+Example 1:
+
+Input: [2,3,-2,4]
+Output: 6
+Explanation: [2,3] has the largest product 6.
+Example 2:
+
+Input: [-2,0,-1]
+Output: 0
+Explanation: The result cannot be 2, because [-2,-1] is not a subarray.
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    int maxProduct(vector<int>& nums) {
+        int n=nums.size();
+        if(n==0) return 0;
+        int ans=INT_MIN, maxVal=1, minVal=1, prevMax;
+        for(int i=0;i<n;i++){
+            if(nums[i]>0){
+                maxVal=maxVal*nums[i];
+                minVal=min(1, minVal*nums[i]);
+            } else if(nums[i]==0){
+                maxVal=0;
+                minVal=1;
+            } else if(nums[i]<0){
+                prevMax=maxVal;
+                maxVal=minVal*nums[i];
+                minVal=prevMax*nums[i];
+            }
+
+            ans=max(ans, maxVal);
+
+            if(maxVal<=0)
+                maxVal=1;
+        }
+        return ans;
+    }
+};

competitive programming/leetcode/2020-September-Challenge/Day-12-Combination Sum III.cpp

@@ -0,0 +1,47 @@
+Find all possible combinations of k numbers that add up to a number n,
+given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.
+
+Note:
+
+All numbers will be positive integers.
+The solution set must not contain duplicate combinations.
+Example 1:
+
+Input: k = 3, n = 7
+Output: [[1,2,4]]
+Example 2:
+
+Input: k = 3, n = 9
+Output: [[1,2,6], [1,3,5], [2,3,4]]
+
+
+
+
+
+
+class Solution {
+public:
+
+    void combSum3(int k, int start, int target, vector<int> &comb, vector<vector<int> > &res){
+        if(comb.size()==k && target==0){
+            res.push_back(comb);
+            return;
+        }
+
+        if(comb.size()>=k || target<=0)
+            return;
+
+        for(int i=start; i<10;i++){
+            comb.push_back(i);
+            combSum3(k, i+1, target-i, comb, res);
+            comb.erase(comb.end()-1);
+        }
+    }
+
+    vector<vector<int>> combinationSum3(int k, int n) {
+        vector<vector<int> > res;
+        vector<int> comb;
+        combSum3(k, 1, n, comb, res);
+        return res;
+    }
+};