🚀 08-Jul-2020

Author: sureshmangs

competitive programming/interviewbit/arrays/Add One To Number.cpp

@@ -0,0 +1,55 @@
+Given a non-negative number represented as an array of digits,
+
+add 1 to the number ( increment the number represented by the digits ).
+
+The digits are stored such that the most significant digit is at the head of the list.
+
+Example:
+
+If the vector has [1, 2, 3]
+
+the returned vector should be [1, 2, 4]
+
+as 123 + 1 = 124.
+
+ NOTE: Certain things are intentionally left unclear in this question which you should practice asking the interviewer.
+For example, for this problem, following are some good questions to ask :
+Q : Can the input have 0’s before the most significant digit. Or in other words, is 0 1 2 3 a valid input?
+A : For the purpose of this question, YES
+Q : Can the output have 0’s before the most significant digit? Or in other words, is 0 1 2 4 a valid output?
+A : For the purpose of this question, NO. Even if the input has zeroes before the most significant digit.
+
+
+
+
+
+
+
+
+
+
+
+vector<int> Solution::plusOne(vector<int> &a) {
+    int n=a.size();
+      vector<int>res;
+    if(n==0){
+        res.push_back(1); return res;
+    }
+    int carry=1; // initially adding one
+    for(int i=n-1;i>=0;i--){
+        int tmp=a[i]+carry;
+        if(tmp>=10){
+            carry=1;
+            tmp%=10;
+        } else carry=0;
+        res.push_back(tmp);
+    }
+    if(carry) res.push_back(1);
+    for(int i=res.size()-1; i>=0;i--){
+        if(res[i]==0){
+            res.erase(res.begin()+i);
+        } else break;
+    }
+    reverse(res.begin(), res.end());
+    return res;
+}

competitive programming/interviewbit/arrays/Max Sum Contiguous Subarray.cpp

@@ -0,0 +1,48 @@
+Find the contiguous subarray within an array, A of length N which has the largest sum.
+
+Input Format:
+
+The first and the only argument contains an integer array, A.
+Output Format:
+
+Return an integer representing the maximum possible sum of the contiguous subarray.
+Constraints:
+
+1 <= N <= 1e6
+-1000 <= A[i] <= 1000
+For example:
+
+Input 1:
+    A = [1, 2, 3, 4, -10]
+
+Output 1:
+    10
+
+Explanation 1:
+    The subarray [1, 2, 3, 4] has the maximum possible sum of 10.
+
+Input 2:
+    A = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+
+Output 2:
+    6
+
+Explanation 2:
+    The subarray [4,-1,2,1] has the maximum possible sum of 6.
+
+
+
+
+
+
+int Solution::maxSubArray(const vector<int> &a) {
+    int n=a.size();
+    // kadanes algo
+    int max_sum=INT_MIN, max_here=0;
+    for(int i=0;i<n;i++){
+        max_here+=a[i];
+        if(max_here> max_sum) max_sum=max_here;
+        if(max_here<0) max_here=0;
+    }
+    return max_sum;
+}

competitive programming/interviewbit/arrays/Maximum Absolute Difference.cpp

@@ -0,0 +1,56 @@
+You are given an array of N integers, A1, A2 ,…, AN. Return maximum value of f(i, j) for all 1 ≤ i, j ≤ N.
+f(i, j) is defined as |A[i] - A[j]| + |i - j|, where |x| denotes absolute value of x.
+
+For example,
+
+A=[1, 3, -1]
+
+f(1, 1) = f(2, 2) = f(3, 3) = 0
+f(1, 2) = f(2, 1) = |1 - 3| + |1 - 2| = 3
+f(1, 3) = f(3, 1) = |1 - (-1)| + |1 - 3| = 4
+f(2, 3) = f(3, 2) = |3 - (-1)| + |2 - 3| = 5
+
+So, we return 5.
+
+
+
+
+
+
+
+
+
+
+
+
+
+// O(n^2)
+
+int Solution::maxArr(vector<int> &a) {
+    int n=a.size();
+    int maxi=INT_MIN;
+    for(int i=0;i<n;i++){
+        for(int j=i+1;j<n;j++){
+            int tmp=abs(a[i]-a[j])+abs(i-j);
+            if(tmp>maxi) maxi=tmp;
+        }
+    }
+    return maxi;
+}
+
+
+
+
+
+int Solution::maxArr(vector<int> &a) {
+    int n=a.size();
+    int max1=INT_MIN, min1=INT_MAX, max2=INT_MIN, min2=INT_MAX;
+    for(int i=0;i<n;i++){
+        max1=max(max1, a[i]+i);
+        min1=min(min1, a[i]+i);
+        max2=max(max2, a[i]-i);
+        min2=min(min2, a[i]-i);
+    }
+    return max(max1-min1, max2-min2);
+}
+

competitive programming/interviewbit/arrays/Min Steps in Infinite Grid.cpp

@@ -0,0 +1,62 @@
+Problem Description
+
+You are in an infinite 2D grid where you can move in any of the 8 directions
+
+ (x,y) to
+    (x+1, y),
+    (x - 1, y),
+    (x, y+1),
+    (x, y-1),
+    (x-1, y-1),
+    (x+1,y+1),
+    (x-1,y+1),
+    (x+1,y-1)
+You are given a sequence of points and the order in which you need to cover the points.. Give the minimum number of steps in which you can achieve it. You start from the first point.
+
+NOTE: This question is intentionally left slightly vague. Clarify the question by trying out a few cases in the “See Expected Output” section.
+
+
+
+Input Format
+Given two integer arrays A and B, where A[i] is x coordinate and B[i] is y coordinate of ith point respectively.
+
+
+
+Output Format
+Return an Integer, i.e minimum number of steps.
+
+
+
+Example Input
+Input 1:
+
+ A = [0, 1, 1]
+ B = [0, 1, 2]
+
+
+Example Output
+Output 1:
+
+ 2
+
+
+Example Explanation
+Explanation 1:
+
+ Given three points are: (0, 0), (1, 1) and (1, 2).
+ It takes 1 step to move from (0, 0) to (1, 1). It takes one more step to move from (1, 1) to (1, 2).
+
+
+
+
+
+
+
+ int Solution::coverPoints(vector<int> &a, vector<int> &b) {
+    int n=a.size();
+    int steps=0;
+    for(int i=0;i<n-1;i++){
+        steps+=max(abs(a[i]-a[i+1]), abs(b[i]-b[i+1]));
+    }
+    return steps;
+}

competitive programming/interviewbit/math/MATH_BUG0.cpp

@@ -0,0 +1,17 @@
+Following code tries to figure out if a number is prime ( Wiki )
+However, it has a bug in it.
+Please correct the bug and then submit the code.
+
+
+
+
+// Return 1 if A is prime, else 0
+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/interviewbit/math/MATH_BUG02.cpp

@@ -0,0 +1,30 @@
+Given a non negative integer A,
+following code tries to find all pair of integers (a, b) such that
+
+a and b are positive integers
+a <= b, and
+a2 + b2 = A.
+0 <= A <= 100000
+However, the code has a small bug. Correct the bug and submit the code
+
+
+
+
+
+
+
+
+vector<vector<int> > Solution::squareSum(int A) {
+    vector<vector<int> > ans;
+    for (int a = 0; a * a < A; a++) {
+        for (int b = a; b * b < A; b++) {
+            if (a * a + b * b == A) {
+                vector<int> newEntry;
+                newEntry.push_back(a);
+                newEntry.push_back(b);
+                ans.push_back(newEntry);
+            }
+        }
+    }
+    return ans;
+}

competitive programming/leetcode/2020-July-Challenge/Day-07-Island Perimeter.cpp

@@ -0,0 +1,58 @@
+You are given a map in form of a two-dimensional integer grid where 1 represents land and 0 represents water.
+
+Grid cells are connected horizontally/vertically (not diagonally). The grid is completely surrounded by water, and there is exactly one island (i.e., one or more connected land cells).
+
+The island doesn't have "lakes" (water inside that isn't connected to the water around the island). One cell is a square with side length 1. The grid is rectangular, width and height don't exceed 100. Determine the perimeter of the island.
+
+
+
+Example:
+
+Input:
+[[0,1,0,0],
+ [1,1,1,0],
+ [0,1,0,0],
+ [1,1,0,0]]
+
+Output: 16
+
+Explanation: The perimeter is the 16 yellow stripes in the image below:
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    bool isValid(int i, int j, int m, int n){
+        return ( i>=0 && i<m && j>=0 && j<n);
+    }
+    int islandPerimeter(vector<vector<int>>& grid) {
+        int m=grid.size();
+        int n=grid[0].size();
+        int peri=0;
+        for(int i=0;i<m;i++){
+            for(int j=0;j<n;j++){
+                if(grid[i][j]==1){  // land
+                    // top
+                    if(isValid(i-1, j, m, n)==false) peri+=1;
+                    else if(grid[i-1][j]==0) peri+=1;
+                    // right
+                    if(isValid(i, j+1, m, n)==false) peri+=1;
+                    else if(grid[i][j+1]==0) peri+=1;
+                    // down
+                    if(isValid(i+1, j, m, n)==false) peri+=1;
+                    else if(grid[i+1][j]==0) peri+=1;
+                    // left
+                    if(isValid(i, j-1, m, n)==false) peri+=1;
+                    else if(grid[i][j-1]==0) peri+=1;
+                }
+            }
+        }
+        return peri;
+    }
+};

competitive programming/leetcode/463. Island Perimeter.cpp

@@ -0,0 +1,58 @@
+You are given a map in form of a two-dimensional integer grid where 1 represents land and 0 represents water.
+
+Grid cells are connected horizontally/vertically (not diagonally). The grid is completely surrounded by water, and there is exactly one island (i.e., one or more connected land cells).
+
+The island doesn't have "lakes" (water inside that isn't connected to the water around the island). One cell is a square with side length 1. The grid is rectangular, width and height don't exceed 100. Determine the perimeter of the island.
+
+
+
+Example:
+
+Input:
+[[0,1,0,0],
+ [1,1,1,0],
+ [0,1,0,0],
+ [1,1,0,0]]
+
+Output: 16
+
+Explanation: The perimeter is the 16 yellow stripes in the image below:
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    bool isValid(int i, int j, int m, int n){
+        return ( i>=0 && i<m && j>=0 && j<n);
+    }
+    int islandPerimeter(vector<vector<int>>& grid) {
+        int m=grid.size();
+        int n=grid[0].size();
+        int peri=0;
+        for(int i=0;i<m;i++){
+            for(int j=0;j<n;j++){
+                if(grid[i][j]==1){  // land
+                    // top
+                    if(isValid(i-1, j, m, n)==false) peri+=1;
+                    else if(grid[i-1][j]==0) peri+=1;
+                    // right
+                    if(isValid(i, j+1, m, n)==false) peri+=1;
+                    else if(grid[i][j+1]==0) peri+=1;
+                    // down
+                    if(isValid(i+1, j, m, n)==false) peri+=1;
+                    else if(grid[i+1][j]==0) peri+=1;
+                    // left
+                    if(isValid(i, j-1, m, n)==false) peri+=1;
+                    else if(grid[i][j-1]==0) peri+=1;
+                }
+            }
+        }
+        return peri;
+    }
+};