space extra

Arrays/Find Permutation.cpp

@@ -0,0 +1,32 @@
+/*
+Solution by : Bhavik Dhandhalya
+Given a positive integer n and a string s consisting only of letters D or I, you have to find any permutation of first n positive integer that satisfy the given input string.
+
+D means the next number is smaller, while I means the next number is greater.
+
+Notes
+Length of given string s will always equal to n - 1
+Your solution should run in linear time and space.
+
+Input 1:
+
+n = 3
+s = ID
+Return: [1, 3, 2]
+
+Solution Complexity : O(N) time and O(1) space
+Refer this URL for lexicographically smaller permutation solution:
+https://leetcode.com/articles/find-permutation/
+*/
+
+vector<int> Solution::findPerm(const string A, int B) {
+    vector < int > ans;
+    int n = A.length();
+    int maxi = n + 1, mini = 1;
+    for (int i = 0; i < n; i++) {
+        if (A[i] == 'I') ans.push_back(mini++);
+        if (A[i] == 'D') ans.push_back(maxi--);
+    }
+    ans.push_back(maxi);
+    return ans;
+}

Arrays/Flip simple code.cpp

@@ -0,0 +1,51 @@
+/*
+You are given a binary string(i.e. with characters 0 and 1) S consisting of characters S1, S2, …, SN. In a single operation, you can choose two indices L and R such that 1 ≤ L ≤ R ≤ N and flip the characters SL, SL+1, …, SR. By flipping, we mean change character 0 to 1 and vice-versa.
+
+Your aim is to perform ATMOST one operation such that in final string number of 1s is maximised. If you don’t want to perform the operation, return an empty array. Else, return an array consisting of two elements denoting L and R. If there are multiple solutions, return the lexicographically smallest pair of L and R.
+
+Notes:
+
+Pair (a, b) is lexicographically smaller than pair (c, d) if a < c or, if a == c and b < d.
+For example,
+S = 010
+Output = [1 1]
+*/
+
+vector<int> Solution::flip(string A) {
+    int n = A.length();
+    int ones = 0;
+    int zeros = 0;
+    int L = INT_MAX, R = 0;
+    int ansL = 0, ansR = 0;
+    int prev = 0;
+    bool found = false;
+
+    for (int i = 0; i < n; i++) {
+        ones += A[i] == '1';
+        zeros += A[i] == '0';
+        if (zeros) found = true;
+
+        if (ones > zeros) {
+            ones = 0;
+            zeros = 0;
+            L = INT_MAX;
+            R = 0;
+        } else if (A[i] == '0') {
+            L = min(L, i);
+            R = i;
+
+            if (zeros - ones > prev) {
+                ansR = R;
+                ansL = L;
+                prev = zeros - ones;
+            }
+        }
+    }
+
+    vector < int > ans;
+    if (found) {
+        ans.push_back(ansL + 1);
+        ans.push_back(ansR + 1);
+    }
+    return ans;
+}

Arrays/MaxDistance.cpp

@@ -1,41 +1,80 @@
 // https://www.interviewbit.com/problems/max-distance/
+
+int Solution::maximumGap(const vector<int> &A) {
+    // Base case     
+    if(A.size() <= 1)return 0;
+
+    // Make two arrays such that one of them holds the minimum from the left
+    // and the other holds maximum from the right
+    vector<int> v1 (A.size(), 0), v2(A.size(), 0);
+
+    // Fill the first array with minimum from the left
+    v1[0] = A[0];
+    for(int i = 1 ; i < A.size(); i++)v1[i] = min(v1[i-1], A[i]);
+
+    // Fill the second array with maximum from the right
+    v2[A.size()-1] = A[A.size()-1];
+    for(int i = A.size()-2 ; i >= 0 ; i--)v2[i] = max(v2[i+1], A[i]);
+
+
+    int i = 0, j = 0;
+    int ans = -1;
+    // While we don't traverse the complete array, check if the minimum element is indeed
+    // less than the maximum element in the other array, if yes, update the answer.
+    // Move the pointer as required. If the element in second array is greater than
+    // that in first array, keep moving the second pointer and update the answer
+    // else move the first pointer.
+    while(j < A.size() && i < A.size()){
+        if(v2[j] >= v1[i]){
+            if(j-i > ans){
+                ans = j-i;
+            }
+            j = j + 1;
+        }else i = i + 1;
+    }
+    return ans;
+}
+
+
+
+
 // Here we are making an array to check whether all the elements on the left of an index are smaller than it or not
 // If true then we are checking for greater j such that A[j] is greater than A[i]. If so then that j is greater than all i on the left
 // also. On finding such a j or a false in the check array, we decrement i.
 
-int Solution::maximumGap(const vector<int> &A) {
-    // Do not write main() function.
-    // Do not read input, instead use the arguments to the function.
-    // Do not print the output, instead return values as specified
-    // Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
-    vector<bool> tempArr(A.size());
-    int min = A[0];
-    int max_distance = 0;
-    int i = A.size()-1;
-    int j = A.size()-1;
+// int Solution::maximumGap(const vector<int> &A) {
+//     // Do not write main() function.
+//     // Do not read input, instead use the arguments to the function.
+//     // Do not print the output, instead return values as specified
+//     // Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
+//     vector<bool> tempArr(A.size());
+//     int min = A[0];
+//     int max_distance = 0;
+//     int i = A.size()-1;
+//     int j = A.size()-1;
 
-    for(int i = 0; i < A.size(); i++){
-        if(A[i] > min){
-            tempArr[i] = false;
-        }
-        else{
-            min = A[i];
-            tempArr[i] = true;
-        }
-    }
+//     for(int i = 0; i < A.size(); i++){
+//         if(A[i] > min){
+//             tempArr[i] = false;
+//         }
+//         else{
+//             min = A[i];
+//             tempArr[i] = true;
+//         }
+//     }
 
-    LOOP:while(i >= 0){
-        if(tempArr[i] == false){
-            i--;
-            goto LOOP;
-        }
-        while((A[i] > A[j]) && (j > i)){
-            j--;
-        }
-        if((j-i) > max_distance){
-            max_distance = j-i;
-        }
-        i--;
-    }
-    return max_distance;
-}
+//     LOOP:while(i >= 0){
+//         if(tempArr[i] == false){
+//             i--;
+//             goto LOOP;
+//         }
+//         while((A[i] > A[j]) && (j > i)){
+//             j--;
+//         }
+//         if((j-i) > max_distance){
+//             max_distance = j-i;
+//         }
+//         i--;
+//     }
+//     return max_distance;
+// }

Arrays/MinStepsInInfiniteGrid.cpp

@@ -1,6 +1,9 @@
 // https://www.interviewbit.com/problems/min-steps-in-infinite-grid/
 // Input : X and Y co-ordinates of the points in order.
 // Each point is represented by (X[i], Y[i])
+
+// Explanatory code
+/*
 int Solution::coverPoints(vector<int> &X, vector<int> &Y) {
 
     int steps = 0, dx, dy, i = 0;
@@ -38,3 +41,19 @@ int Solution::coverPoints(vector<int> &X, vector<int> &Y) {
 
     return steps;
 }
+*/
+
+// Concise code
+int coverPoints(vector<int> &X, vector<int> &Y) {
+
+    int size1=X.size(),size2=Y.size(),ans=0;
+
+    for(int i=1;i<size1;i++)
+
+    {
+     ans = ans + (abs(X[i]-X[i-1])<abs(Y[i]-Y[i-1])?abs(Y[i]-Y[i-1]):abs(X[i]-X[i-1]));
+    }
+
+    return ans;
+} 
+

Backtracking/CombinationSum.cpp

@@ -0,0 +1,27 @@
+void aux(int i, int sum, int k, vector<int> &A, vector<int> &temp, set<vector<int>> &ans) {
+    if(i == A.size() || sum >= k){
+        if(sum == k){
+            ans.insert(temp);
+        }
+        return;
+    }
+
+    temp.push_back(A[i]);
+    aux(i, sum+A[i], k, A, temp, ans);
+    aux(i+1, sum+A[i], k, A, temp, ans);
+    temp.pop_back();
+    aux(i+1, sum, k, A, temp, ans);
+}
+
+vector<vector<int> > Solution::combinationSum(vector<int> &A, int B) {
+    set<vector<int>> ans;
+    sort(A.begin(), A.end());
+    vector<int> temp;
+    aux(0, 0, B, A, temp, ans);
+    vector<vector<int>> res;
+
+    for(auto i = ans.begin(); i != ans.end(); i++){
+        res.push_back(*i);
+    }
+    return res;
+}

Backtracking/NQueens.cpp

@@ -0,0 +1,50 @@
+vector<vector<string> >ans;
+int n;
+
+void recur(int ind, vector<int> pos)
+{
+    int i,j;
+    if(ind == n)
+    {
+       vector<string> valid;
+        for(i=0;i<n;i++)
+        {
+            string row = "";
+            for(j=0;j<n;j++)
+            {
+                if(j == pos[i])
+                    row += 'Q';
+                else
+                    row += '.';
+            }
+            valid.push_back(row);
+        }
+        ans.push_back(valid);
+
+        return;
+    }
+    for(i = 0;i<n;i++)
+    {
+        bool flag = true;
+        for(j=0;j<pos.size();j++)
+        {
+            if(abs(ind-j) == abs(pos[j]-i) || i == pos[j])
+                flag = false;
+        }
+        if(!flag)
+            continue;
+        pos.push_back(i);
+        recur(ind+1,pos);
+        pos.pop_back();
+        //pos[ind] = -1;
+    }
+}
+vector<vector<string> > Solution::solveNQueens(int A) 
+{
+    ans.clear();
+    vector<int> pos;
+    int i;
+    n = A;
+    recur(0,pos);
+    return ans;
+}

Binary-Search/RotatedSortedArraySearch.cpp

@@ -1,5 +1,43 @@
 // https://www.interviewbit.com/problems/rotated-sorted-array-search/
 
+int search1(const vector<int> &arr, int low, int high, int B) 
+{ 
+    if (low > high) return -1; 
+
+    int mid = (low) + (high-low)/2; 
+    if (arr[mid] == B) return mid; 
+
+    if (arr[low] <= arr[mid]) 
+    { 
+        if (B >= arr[low] && B <= arr[mid]) 
+        return search1(arr, low, mid-1, B); 
+
+        return search1(arr, mid+1, high, B); 
+    } 
+
+    else if (arr[mid] <= arr[high])
+    {
+    if (B >= arr[mid] && B <= arr[high]) 
+        return search1(arr, mid+1, high, B); 
+
+    return search1(arr, low, mid-1, B); 
+    }
+} 
+
+
+int Solution::search(const vector<int> &A, int B) {
+
+   int n = A.size();
+   int i = search1(A, 0, n-1, B); 
+
+    if (i != -1) 
+    return i;
+    else
+    return -1;
+
+}
+
+/*
 int findPivot(const vector<int> &A){
     int start = 0;
     int end = A.size()-1;
@@ -64,3 +102,4 @@ int Solution::search(const vector<int> &A, int B) {
     // B < A[pivot]
 
 }
+*/

Bit-Manipulation/DivideInteger.cpp

@@ -0,0 +1,18 @@
+int Solution::divide(int a, int b) {
+    if(a==0)
+    return 0;
+    if(b==0)
+    return (INT_MAX);
+   int sign=1;
+    //remove sign of operands
+    int t=0,q=0;
+    a=abs(a);
+    b=abs(b);
+    for(int i=31;i>=0;--i){
+        if(t+(b<<i)<=a){
+            t+=b<<i;
+            q+=1LL<<i;
+        }
+    }
+    return (sign*q>=INT_MAX||sign*q<INT_MIN)?INT_MAX:sign*q;
+}