Solved Problems

Author: gouthampradhan

README.md

@@ -0,0 +1,33 @@
+package array;
+
+import java.util.*;
+
+/**
+ * Created by gouthamvidyapradhan on 14/08/2019 Given an array of 2n integers, your task is to group
+ * these integers into n pairs of integer, say (a1, b1), (a2, b2), ..., (an, bn) which makes sum of
+ * min(ai, bi) for all i from 1 to n as large as possible.
+ *
+ * <p>Example 1: Input: [1,4,3,2]
+ *
+ * <p>Output: 4 Explanation: n is 2, and the maximum sum of pairs is 4 = min(1, 2) + min(3, 4).
+ * Note: n is a positive integer, which is in the range of [1, 10000]. All the integers in the array
+ * will be in the range of [-10000, 10000].
+ *
+ * <p>Solution: O(n log n) General idea is to pair the smallest with the next smallest value inorder
+ * to get the max sum of minimum.
+ */
+public class ArrayPartitionI {
+  public static void main(String[] args) {
+    int[] A = {1, 2, 3, 4};
+    System.out.println(new ArrayPartitionI().arrayPairSum(A));
+  }
+
+  public int arrayPairSum(int[] nums) {
+    Arrays.sort(nums);
+    int sum = 0;
+    for (int i = 1; i < nums.length; i += 2) {
+      sum += Math.min(nums[i - 1], nums[i]);
+    }
+    return sum;
+  }
+}

problems/src/array/ArrayPartitionI.java

@@ -0,0 +1,117 @@
+package array;
+
+/**
+ * Created by gouthamvidyapradhan on 14/08/2019 Given a 01 matrix M, find the longest line of
+ * consecutive one in the matrix. The line could be horizontal, vertical, diagonal or anti-diagonal.
+ * Example: Input: [[0,1,1,0], [0,1,1,0], [0,0,0,1]] Output: 3 Hint: The number of elements in the
+ * given matrix will not exceed 10,000.
+ *
+ * <p>Solution O(N x M) for each cell keep track of maximum value possible horizontally, vertically
+ * and diagonally. Start iterating from left-right and top-bottom and repeat the same from
+ * right-left and top to bottom to get max for anti-diagonal and return the max value.
+ */
+public class LongestLineofConsecutiveOneinMatrix {
+  final int[] R = {0, 0, -1, 1};
+  final int[] C = {1, -1, 0, 0};
+
+  public static void main(String[] args) {
+    int[][] M = {
+      {1, 1, 0, 0, 1, 0, 0, 1, 1, 0},
+      {1, 0, 0, 1, 0, 1, 1, 1, 1, 1},
+      {1, 1, 1, 0, 0, 1, 1, 1, 1, 0},
+      {0, 1, 1, 1, 0, 1, 1, 1, 1, 1},
+      {0, 0, 1, 1, 1, 1, 1, 1, 1, 0},
+      {1, 1, 1, 1, 1, 1, 0, 1, 1, 1},
+      {0, 1, 1, 1, 1, 1, 1, 0, 0, 1},
+      {1, 1, 1, 1, 1, 0, 0, 1, 1, 1},
+      {0, 1, 0, 1, 1, 0, 1, 1, 1, 1},
+      {1, 1, 1, 0, 1, 0, 1, 1, 1, 1}
+    };
+    System.out.println(new LongestLineofConsecutiveOneinMatrix().longestLine(M));
+  }
+
+  class Cell {
+    int h, v, d;
+
+    Cell(int h, int v, int d) {
+      this.h = h;
+      this.v = v;
+      this.d = d;
+    }
+  }
+
+  public int longestLine(int[][] M) {
+    if (M.length == 0) return 0;
+    int max = 0;
+    Cell[][] cells = new Cell[M.length][M[0].length];
+    for (int i = 0; i < M.length; i++) {
+      for (int j = 0; j < M[0].length; j++) {
+        int h = 0, v = 0, d = 0;
+        if (M[i][j] == 1) {
+          h = 1;
+          v = 1;
+          d = 1;
+          max = Math.max(max, 1);
+          if (j - 1 >= 0) {
+            Cell left = cells[i][j - 1];
+            if (left.h > 0) {
+              h += left.h;
+              max = Math.max(max, h);
+            }
+          }
+          if (i - 1 >= 0) {
+            Cell top = cells[i - 1][j];
+            if (top.v > 0) {
+              v += top.v;
+              max = Math.max(max, v);
+            }
+          }
+          if (i - 1 >= 0 && j - 1 >= 0) {
+            Cell diagonal = cells[i - 1][j - 1];
+            if (diagonal.d > 0) {
+              d += diagonal.d;
+              max = Math.max(max, d);
+            }
+          }
+        }
+        cells[i][j] = new Cell(h, v, d);
+      }
+    }
+
+    for (int i = 0; i < M.length; i++) {
+      for (int j = M[0].length - 1; j >= 0; j--) {
+        int h = 0, v = 0, d = 0;
+        if (M[i][j] == 1) {
+          h = 1;
+          v = 1;
+          d = 1;
+          max = Math.max(max, 1);
+          if (j + 1 < M[0].length) {
+            Cell left = cells[i][j + 1];
+            if (left.h > 0) {
+              h += left.h;
+              max = Math.max(max, h);
+            }
+          }
+          if (i - 1 >= 0) {
+            Cell top = cells[i - 1][j];
+            if (top.v > 0) {
+              v += top.v;
+              max = Math.max(max, v);
+            }
+          }
+          if (i - 1 >= 0 && j + 1 < M[0].length) {
+            Cell diagonal = cells[i - 1][j + 1];
+            if (diagonal.d > 0) {
+              d += diagonal.d;
+              max = Math.max(max, d);
+            }
+          }
+        }
+        cells[i][j] = new Cell(h, v, d);
+      }
+    }
+
+    return max;
+  }
+}

problems/src/array/LongestLineofConsecutiveOneinMatrix.java

@@ -0,0 +1,67 @@
+package array;
+
+import java.util.*;
+
+/**
+ * Created by gouthamvidyapradhan on 15/08/2019 We are given a matrix with R rows and C columns has
+ * cells with integer coordinates (r, c), where 0 <= r < R and 0 <= c < C.
+ *
+ * <p>Additionally, we are given a cell in that matrix with coordinates (r0, c0).
+ *
+ * <p>Return the coordinates of all cells in the matrix, sorted by their distance from (r0, c0) from
+ * smallest distance to largest distance. Here, the distance between two cells (r1, c1) and (r2, c2)
+ * is the Manhattan distance, |r1 - r2| + |c1 - c2|. (You may return the answer in any order that
+ * satisfies this condition.)
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: R = 1, C = 2, r0 = 0, c0 = 0 Output: [[0,0],[0,1]] Explanation: The distances from (r0,
+ * c0) to other cells are: [0,1] Example 2:
+ *
+ * <p>Input: R = 2, C = 2, r0 = 0, c0 = 1 Output: [[0,1],[0,0],[1,1],[1,0]] Explanation: The
+ * distances from (r0, c0) to other cells are: [0,1,1,2] The answer [[0,1],[1,1],[0,0],[1,0]] would
+ * also be accepted as correct. Example 3:
+ *
+ * <p>Input: R = 2, C = 3, r0 = 1, c0 = 2 Output: [[1,2],[0,2],[1,1],[0,1],[1,0],[0,0]] Explanation:
+ * The distances from (r0, c0) to other cells are: [0,1,1,2,2,3] There are other answers that would
+ * also be accepted as correct, such as [[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]].
+ *
+ * <p>Note:
+ *
+ * <p>1 <= R <= 100 1 <= C <= 100 0 <= r0 < R 0 <= c0 < C
+ *
+ * <p>Solution: O (log (R x C)) Straight forward solution, find the Manhattan distance from the
+ * given cell to all the cells in the grid and sort by min distance and return their coordinates.
+ */
+public class MatrixCellsinDistanceOrder {
+  public static void main(String[] args) {
+    //
+  }
+
+  class Cell {
+    int max, i, j;
+
+    Cell(int max, int i, int j) {
+      this.max = max;
+      this.i = i;
+      this.j = j;
+    }
+  }
+
+  public int[][] allCellsDistOrder(int R, int C, int r0, int c0) {
+    List<Cell> list = new ArrayList<>();
+    for (int i = 0; i < R; i++) {
+      for (int j = 0; j < C; j++) {
+        int sum = Math.abs(r0 - i) + Math.abs(c0 - j);
+        list.add(new Cell(sum, i, j));
+      }
+    }
+    list.sort(Comparator.comparingInt(o -> o.max));
+    int[][] A = new int[list.size()][2];
+    for (int i = 0; i < A.length; i++) {
+      A[i][0] = list.get(i).i;
+      A[i][1] = list.get(i).j;
+    }
+    return A;
+  }
+}

problems/src/array/MatrixCellsinDistanceOrder.java

@@ -0,0 +1,80 @@
+package array;
+
+import java.util.*;
+
+/**
+ * Created by gouthamvidyapradhan on 15/08/2019 Given an array A of non-negative integers, return
+ * the maximum sum of elements in two non-overlapping (contiguous) subarrays, which have lengths L
+ * and M. (For clarification, the L-length subarray could occur before or after the M-length
+ * subarray.)
+ *
+ * <p>Formally, return the largest V for which V = (A[i] + A[i+1] + ... + A[i+L-1]) + (A[j] + A[j+1]
+ * + ... + A[j+M-1]) and either:
+ *
+ * <p>0 <= i < i + L - 1 < j < j + M - 1 < A.length, or 0 <= j < j + M - 1 < i < i + L - 1 <
+ * A.length.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: A = [0,6,5,2,2,5,1,9,4], L = 1, M = 2 Output: 20 Explanation: One choice of subarrays
+ * is [9] with length 1, and [6,5] with length 2. Example 2:
+ *
+ * <p>Input: A = [3,8,1,3,2,1,8,9,0], L = 3, M = 2 Output: 29 Explanation: One choice of subarrays
+ * is [3,8,1] with length 3, and [8,9] with length 2. Example 3:
+ *
+ * <p>Input: A = [2,1,5,6,0,9,5,0,3,8], L = 4, M = 3 Output: 31 Explanation: One choice of subarrays
+ * is [5,6,0,9] with length 4, and [3,8] with length 3.
+ *
+ * <p>Note:
+ *
+ * <p>L >= 1 M >= 1 L + M <= A.length <= 1000 0 <= A[i] <= 1000 Solution O(N ^ 2) Find prefix sum of
+ * array of length L and array of length M and keep track of their begin and end indices. Now,
+ * brute-force compare pairs of prefix array sum where their indices don't overlap and return the
+ * max possible answer.
+ */
+public class MaximumSumofTwoNonOverlappingSubarrays {
+  public static void main(String[] args) {
+    int[] A = {2, 1, 5, 6, 0, 9, 5, 0, 3, 8};
+    System.out.println(new MaximumSumofTwoNonOverlappingSubarrays().maxSumTwoNoOverlap(A, 4, 3));
+  }
+
+  class MaxWithIndex {
+    int max, i, j;
+
+    MaxWithIndex(int max, int i, int j) {
+      this.max = max;
+      this.i = i;
+      this.j = j;
+    }
+  }
+
+  public int maxSumTwoNoOverlap(int[] A, int L, int M) {
+    List<MaxWithIndex> first = getMax(A, L);
+    List<MaxWithIndex> second = getMax(A, M);
+    int max = 0;
+    for (MaxWithIndex f : first) {
+      for (MaxWithIndex s : second) {
+        if (f.j < s.i || s.j < f.i) {
+          max = Math.max(max, f.max + s.max);
+        }
+      }
+    }
+    return max;
+  }
+
+  private List<MaxWithIndex> getMax(int[] A, int L) {
+    List<MaxWithIndex> list = new ArrayList<>();
+    int i = 0, j = L;
+    int sum = 0;
+    for (; i < L; i++) {
+      sum += A[i];
+    }
+    list.add(new MaxWithIndex(sum, 0, j - 1));
+    for (i = 1; j < A.length; i++, j++) {
+      sum -= A[i - 1];
+      sum += A[j];
+      list.add(new MaxWithIndex(sum, i, j));
+    }
+    return list;
+  }
+}

problems/src/array/MaximumSumofTwoNonOverlappingSubarrays.java

@@ -0,0 +1,43 @@
+package array;
+
+import java.util.*;
+
+/**
+ * Created by gouthamvidyapradhan on 20/08/2019 Given an array A of non-negative integers, half of
+ * the integers in A are odd, and half of the integers are even.
+ *
+ * <p>Sort the array so that whenever A[i] is odd, i is odd; and whenever A[i] is even, i is even.
+ *
+ * <p>You may return any answer array that satisfies this condition.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: [4,2,5,7] Output: [4,5,2,7] Explanation: [4,7,2,5], [2,5,4,7], [2,7,4,5] would also
+ * have been accepted.
+ *
+ * <p>Note:
+ *
+ * <p>2 <= A.length <= 20000 A.length % 2 == 0 0 <= A[i] <= 1000 Solution: O(N) straight forward
+ * linear solution, keep track of odd and even indices and increment by 2 every time a value is
+ * added at the index.
+ */
+public class SortArrayByParityII {
+  public static void main(String[] args) {
+    //
+  }
+
+  public int[] sortArrayByParityII(int[] A) {
+    int[] R = new int[A.length];
+    int i = 0, j = 1;
+    for (int a : A) {
+      if (a % 2 == 0) {
+        R[i] = a;
+        i += 2;
+      } else {
+        R[j] = a;
+        j += 2;
+      }
+    }
+    return R;
+  }
+}