add change 5

Author: afrozchakure

LeetCode/Algorithms/Medium/MinimumOperationsToMakeAUniValueGrid.cpp

@@ -0,0 +1,100 @@
+class Solution {
+    public:
+        int minOperations(vector<vector<int>>& grid, int x) {
+            // add x or substract x from any eleemnt in grid 
+    
+            // minimum no. of opertions to make grid uni-value else -1 
+            
+            vector<int> array; 
+            int remainder = grid[0][0]%x; 
+            // Step 1: insert the array elements
+            for(int i=0; i<grid.size(); i++) {
+                for(int j=0; j<grid[0].size(); j++) {
+                    if(grid[i][j] % x != remainder) {
+                        return -1; 
+                    }
+
+                    array.push_back(grid[i][j]);
+                }
+            }
+
+            // Step 2 : Sort 1D array 
+            sort(array.begin(), array.end()); 
+            int n = array.size(); 
+            int median = n / 2; 
+            
+            // Step 3: Count steps required
+            int steps = 0;
+            for(int i=0; i<n; i++) {
+                steps += abs(array[median] - array[i]) / x; 
+            }
+
+            return steps; 
+        }
+};
+
+
+/*
+Time Complexity - O(MNlogMN + MN) ~~ O(MN log MN)  (sorting + flattening)
+Space Complexity - O(MN)
+
+
+min      max 
+
+gap = 10^4, no. of items - 10^5, total 10^9 > 10^8
+
+Pair Equality 
+
+Goal: 1. Make a & b equal 
+a = 10, b = 30 
+
+2. Do it in min steps 
+x = 5 
+{For a pair (a, b) any point from a to b will be optimal}
+
+Note: 
+1. a and b can become equal only when a % x == b % x
+
+c = 12 % 5 = 2     e = 10 % 5 = 0 
+d = 32 % 5 = 2     f = 31 % 5 = 1
+x = 5              x = 5 
+
+Array Uni-value 
+
+a[] = [9, 14, 29, 39], x = 5  
+
+if a[i] % x is same for all elements then they can meet 
+
+if all pairs(c, d) where c % x == d % x then the array 
+can be made uni-value more optmially 
+
+if a[i] % x is same for all i -> 0 to (N - 1),
+then the array can be made uni-value 
+
+
+meeting point 
+
+   9    14   (19)  (24)  29      39  -- even (find the points within two middle points)
+
+   9    14   29  34  39  -- odd (take middle element)
+
+
+9    29 
+39   14 
+
+Flatten - [9, 29, 39, 14]  -> mn
+
+[9, 14, 29, 39] --> mnlogmn
+
+median = N / 2 = 2 
+
+// meet at index = 2 
+
+Iterate and check remainder whilte flattening 
+
+rem = 9 % 5 = 4 
+
+steps += abs(a[i] - a[median]) / x 
+
+steps = 0 -> 4 -> 7 -> 9 
+*/ 

LeetCode/Algorithms/Medium/MultiplyStrings.cpp

@@ -0,0 +1,38 @@
+class Solution {
+public:
+    string multiply(string num1, string num2) {
+        if(num1 == "0" || num2 == "0") {
+            return "0";
+        }
+
+        int m = num1.size(); 
+        int n = num2.size(); 
+
+        vector<int> result(m + n, 0); 
+
+        reverse(num1.begin(), num1.end()); 
+        reverse(num2.begin(), num2.end()); 
+
+        for(int i=0; i<m; i++) {
+            for(int j=0; j<n; j++) {
+                int digit = (num1[i] - '0') * (num2[i] - '0'); 
+
+                result[i + j] += digit; 
+                result[i + j + 1] += (result[i + j] / 10);
+                result[i + j] = result[i + j] % 10; 
+            }
+        }
+
+        reverse(result.begin(), result.end()); 
+        int begin = 0; 
+        while(begin < result.size() && result[begin] == 0) {
+            begin++; 
+        }
+        
+        string output = ""; 
+        for(int i=begin; i<result.size(); i++) {
+            output += result[i]; 
+        }
+        return output; 
+    }
+};

LeetCode/Algorithms/Medium/PrimeSubtractionOperation.cpp

@@ -0,0 +1,45 @@
+class Solution {
+public:
+    bool primeSubOperation(vector<int>& nums) {
+        
+        int prev = 0; 
+
+        // O(n * m * sqrt(m))
+        for(auto &n : nums) {
+            int upper_bound = n - prev; // non-inclusive [2, n)
+            int largest_p = 0;
+
+            for(int i=upper_bound-1; i>=2; i--) {
+                if(is_prime(i)) {
+                    largest_p = i; 
+                    break;
+                }
+            }
+
+            if((n - largest_p) <= prev) {
+                return false; 
+            }
+
+            prev = n - largest_p;
+
+        }
+    }
+
+    bool isPrime(int n) {
+        for(int i=2; i<pow(n, 0.5) + 1; i++) {
+            if(n % i == 0) {
+                return false; 
+            }
+        }
+        return true; 
+    }
+};
+
+// Time Complexity - O(N * M * sqrt(M))
+// Space Complexity - O(N)
+
+// 1. nums[i-1] < nums[i] - p < nums[i + 1]
+// 2. If nums[i] - p < nums[i - 1]
+//    should we backtrack?
+// 3. Greedy: make each num as small as possible 
+//    from the get go

LeetCode/Algorithms/Medium/ShortestSubarrayToBeRemovedToMakeArraySorted.cpp

@@ -0,0 +1,99 @@
+class Solution {
+public:
+    int findLengthOfShortestSubarray(vector<int>& arr) {
+        // remove prefix 
+        int n = arr.size(); 
+        int r = n-1; 
+
+        while(r > 0 && arr[r-1] > arr[r]) {
+            r--; 
+        }
+
+        int res = r; 
+
+        // remove postfix 
+        int l = 0; 
+        while(l + 1 < n && arr[l] < arr[l + 1]) {
+            l++; 
+        }
+
+        res = min(res, n - l - 1);
+
+        // remove middle 
+        l = 0
+        r = n-1; 
+        while(l < r) {
+            // shrink the valid window (make it l+1 so that res is not negative when both r and l are equal)
+            while(r < n && (l + 1) < r && arr[r-1] <= arr[r] && arr[l] <= arr[r]) {
+                r--; 
+            }
+
+            // [1, 2, 3, 10, 6, 1, 2, 3]
+
+            // Expand Invalid Window 
+            while(r < n && arr[l] > arr[r]) {
+                r++; 
+            }
+
+            res = min(res, r - l - 1);
+
+            if(arr[l] > arr[l + 1]) {
+                break;
+            }
+            l += 1;
+        }
+        return res;
+    }
+};
+
+// 1. Prefix 
+// 2. Postfix 
+// 3. Middle 
+// Take the minimum of all 3 above
+
+// Time Complexity - O(N)
+// Space Complexity - O(1)
+
+// Method - 2 
+
+class Solution {
+public:
+    int findLengthOfShortestSubarray(vector<int>& arr) {
+        int n = arr.size(); 
+        int l = 0; 
+        int r = n-1; 
+        // remove prefix 
+        while(r >0 && arr[r-1] <= arr[r]) {
+            r--; 
+        }
+
+        int res = r;
+        
+                                    //    l         r 
+        // remove middle and postfix  -- [1, 10, 6, 1, 2, 3]
+        l = 0;
+        while(l < r) {
+           
+            // Expand Invalid Window 
+            while(r < n && arr[l] > arr[r]) {
+                r++; 
+            }
+
+            res = min(res, r - l - 1); 
+                
+            if(arr[l + 1] < arr[l]) {
+                break;
+            }
+            l++; 
+        }
+        return res;
+    }
+};
+
+// 1. Prefix 
+// 2. Postfix 
+// 3. Middle 
+// Take the minimum of all 3 above
+
+// Time Complexity - O(N)
+// Space Complexity - O(1)

LeetCode/Algorithms/Medium/ShortestSubarrayWithOrAtLeastK2.cpp

@@ -0,0 +1,65 @@
+class Solution {
+public:
+    void updateFreq(vector<int> &bitFreq, int val) {
+        for(int i=0; i<32; i++) {
+            if(number & (1<<i)) {
+                bitFreq[i] += val; 
+            }
+        }
+    }
+
+    int getNumber(vector<int> &bitFreq) {
+        int number = 0; 
+        long long pow = 1; 
+        for(int i =0; i<32; i++) {
+            if(bitFreq[i] > 0) {
+                number += pow; 
+            }
+            pow *= 2; 
+        }
+        return number; 
+    }
+
+    int minimumSubarrayLength(vector<int>& nums, int k) {
+        // A ^ B =
+
+        // 0 ^ 0 = 1
+
+        // Find bit value of k
+
+        // find all 
+
+        if(k == 0) {
+            return 1; 
+        }
+
+        int n = nums.size(); 
+        int shortest = INT_MAX;
+        int left = 0, right = 0; 
+        int currOR = 0; 
+        vector<int> bitFreq(32);o 
+
+        while(right < n) {
+            updateFreq(bitFreq, nums[right], 1); 
+            currOR |= nums[right]; 
+
+            // resize window 
+            while(left <= right and currOR >= k) {
+                shortest = min(shortest, right - left + 1); 
+                updateFreq(bitFreq, nums[left], -1); 
+                currOR = getNumber(bitFreq); 
+                left++; 
+            }
+            right++; 
+        }
+        return shortest == INT_MAX ? -1: shortest; 
+    }
+};
+
+// Observations 
+
+// 1. 0 or 0 or ... or 0 or 1 = 1
+// 2. OR for +ve nos will always be non-decreasing 
+
+// In non-decreasing curve to find smallest subarray use sliding window 
+

LeetCode/Algorithms/Medium/TakeKOfEachCharacterFromLeftAndRight.cpp

@@ -0,0 +1,42 @@
+class Solution {
+public:
+    int takeCharacters(string s, int k) {
+        // minimum no . of minutes to take atleast k of each character
+
+        // total counts
+        int a=0, b=0, c =0; 
+        int n = s.size(); 
+        for(auto &ch: s) {
+            if(ch == 'a') a++; 
+            if(ch == 'b') b++; 
+            if(ch == 'c') c++; 
+        }
+
+        if(min(a, min(b, c)) < k) {
+            return -1; 
+        }
+
+        // Sliding Window 
+        int l=0;
+        int result = 0;
+        int ans = INT_MAX;
+        for(int r=0; r<s.size(); r++) {
+            if(s[r] == 'a') a--; 
+            if(s[r] == 'b') b--;  
+            if(s[r] == 'c') c--; 
+
+            while(min(a, min(b, c)) < k) {
+                if(s[l] == 'a') a++; 
+                if(s[l] == 'b') b++; 
+                if(s[l] == 'c') c++; 
+                l++; 
+            }
+
+            ans = min(ans, n - (r - l + 1));
+        }
+        return ans;
+    }
+};
+
+// Time Complexity - O(N)
+// Space Complexity - O(1)