🚀 09-Jul-2020

Author: sureshmangs

competitive programming/interviewbit/math/All Factors.cpp

@@ -0,0 +1,32 @@
+Given a number N, find all factors of N.
+
+Example:
+
+N = 6
+factors = {1, 2, 3, 6}
+Make sure the returned array is sorted
+
+
+
+
+
+
+
+
+vector<int> Solution::allFactors(int n) {
+    vector<int> res, tmp;
+    if(n==0){
+        res.push_back(0);
+        return res;
+    }
+    for(int i=1;i*i<=n;i++){
+        if(n%i==0){
+            res.push_back(i);
+            if((i*i)!=n) tmp.push_back(n/i);
+        }
+    }
+    int k=tmp.size();
+    for(int i=k-1;i>=0;i--)
+        res.push_back(tmp[i]);
+    return res;
+}

competitive programming/interviewbit/math/Binary Representation.cpp

@@ -0,0 +1,25 @@
+Given a number N >= 0, find its representation in binary.
+
+Example:
+
+if N = 6,
+
+binary form = 110
+
+
+
+
+
+
+
+string Solution::findDigitsInBinary(int n) {
+    string res;
+    if(n==0) res.push_back(0+'0');
+    while(n){
+        int tmp=n%2;
+        n/=2;
+        res.push_back(tmp+'0');
+    }
+    reverse(res.begin(), res.end());
+    return res;
+}

competitive programming/interviewbit/math/Hamming Distance.cpp

@@ -0,0 +1,77 @@
+Problem Description
+
+Hamming distance between two non-negative integers is defined as the number of positions at which the corresponding bits are different.
+
+Given an array A of N non-negative integers, find the sum of hamming distances of all pairs of integers in the array. Return the answer modulo 1000000007.
+
+
+
+Problem Constraints
+1 <= |A| <= 200000
+
+1 <= A[i] <= 109
+
+
+
+Input Format
+First and only argument is array A.
+
+
+
+Output Format
+Return one integer, the answer to the problem.
+
+
+
+Example Input
+Input 1:
+
+ A = [1]
+Input 2:
+
+ A = [2, 4, 6]
+
+
+Example Output
+Output 1:
+
+ 0
+Output 2:
+
+ 8
+
+
+Example Explanation
+Explanation 1:
+
+ No pairs are formed.
+Explanation 2:
+
+ We return, f(2, 2) + f(2, 4) + f(2, 6) + f(4, 2) + f(4, 4) + f(4, 6) + f(6, 2) + f(6, 4) + f(6, 6) = 8
+
+
+
+
+
+
+
+
+
+ // O(n^2)
+ int Solution::hammingDistance(const vector<int> &a) {
+    int n=a.size();
+    int cnt=0;
+    for(int i=0;i<n;i++){
+       for(int j=0;j<n;j++){
+           int x=a[i];
+           int y=a[j];
+           int tmp=x^y;
+            while(tmp>0){
+                cnt+=tmp & 1;
+                tmp=tmp>>1;
+            }
+       }
+
+    }
+    return cnt;
+}

competitive programming/interviewbit/math/Prime Numbers.cpp

@@ -0,0 +1,42 @@
+Given a number N, find all prime numbers upto N ( N included ).
+
+Example:
+
+if N = 7,
+
+all primes till 7 = {2, 3, 5, 7}
+
+Make sure the returned array is sorted.
+
+
+
+
+
+
+
+
+
+vector<int> Solution::sieve(int n) {
+    vector<int> res;
+    vector<bool> prime(n+1, true);
+    prime[0]=false;
+    prime[1]=false;
+    int i=2*2;
+    while(i<=n){
+        prime[i]=false;   // multiples of 2
+         i+=2;
+    }
+    for(i=3;i*i<n;i+=2){
+        int tmp=i*2;
+        if(prime[i]){
+            while(tmp<=n){
+                prime[tmp]=false;
+                tmp+=i;
+            }
+        }
+    }
+    for(int i=2;i<=n;i++){
+        if(prime[i]) res.push_back(i);
+    }
+    return res;
+}

competitive programming/interviewbit/math/Prime Sum.cpp

@@ -0,0 +1,51 @@
+Given an even number ( greater than 2 ), return two prime numbers whose sum will be equal to given number.
+
+NOTE A solution will always exist. read Goldbach’s conjecture
+
+Example:
+
+
+Input : 4
+Output: 2 + 2 = 4
+
+If there are more than one solutions possible, return the lexicographically smaller solution.
+
+If [a, b] is one solution with a <= b,
+and [c,d] is another solution with c <= d, then
+
+[a, b] < [c, d]
+
+If a < c OR a==c AND b < d.
+
+
+
+
+
+
+
+
+
+
+vector<int> Solution::primesum(int n) {
+    vector<int> ret;
+    vector<bool> seive(n+1, true);
+    seive[0]=false;
+    seive[1]=false;
+    for(int i=2;i*i<=n;i++){
+        int tmp=i*2;
+        if(seive[i]){
+            while(tmp<=n){
+                seive[tmp]=false;
+                tmp+=i;
+            }
+        }
+    }
+    for(int i=0;i<n;i++){
+        if(seive[i] && seive[n-i]){
+            ret.push_back(i);
+            ret.push_back(n-i);
+            break;
+        }
+    }
+    return ret;
+}

competitive programming/interviewbit/math/Verify Prime.cpp

@@ -0,0 +1,23 @@
+Given a number N, verify if N is prime or not.
+
+Return 1 if N is prime, else return 0.
+
+Example :
+
+Input : 7
+Output : True
+
+
+
+
+
+
+
+int Solution::isPrime(int n) {
+    if(n<=1) return 0;
+    if(n<=3) return 1;
+    if(n%2==0 || n%3==0) return 0;
+    for(int i=5;i*i<n;i+=6)
+        if(n%i==0 || n%(i+2)==0) return 0;
+    return 1;
+}

competitive programming/leetcode/2020-July-Challenge/Day-08-3Sum.cpp

@@ -0,0 +1,62 @@
+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]
+]
+   Hide Hint #1
+So, we essentially need to find three numbers x, y, and z such that they add up to the given value. If we fix one of the numbers say x, we are left with the two-sum problem at hand!
+   Hide Hint #2
+For the two-sum problem, if we fix one of the numbers, say
+x
+, we have to scan the entire array to find the next number
+y
+which is
+value - x
+where value is the input parameter. Can we change our array somehow so that this search becomes faster?
+   Hide Hint #3
+The second train of thought for two-sum is, without changing the array, can we use additional space somehow? Like maybe a hash map to speed up the search?
+
+
+
+
+
+
+
+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;
+    }
+};