more

Author: Sonia Mathew

.idea/workspace.xml

@@ -0,0 +1,35 @@
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Given an array of elements, return the length of the longest subarray where all its elements are distinct.
+ *
+ * For example, given the array [5, 1, 3, 5, 2, 3, 4, 1], return 5 as the longest subarray of distinct elements is
+ * [5, 2, 3, 4, 1].
+ */
+public class DailyCoding189 {
+    public static void main(String[] args) {
+        System.out.println(longestSubArray(new int[]{5,1,3,5,2,3,4,1})==5);
+    }
+    public static int longestSubArray(int[] nums) {
+        Set<Integer> numbers = new HashSet<>();
+        int start = 0;
+        int curr = 0;
+        int maxLen = 0;
+        while(curr < nums.length) {
+            if (numbers.contains(nums[curr])) {
+                maxLen = Math.max(maxLen, numbers.size());
+                while (nums[start]!= nums[curr]) {
+                    numbers.remove(nums[start]);
+                    start++;
+                }
+                numbers.remove(nums[start]);
+                start++;
+            }
+            numbers.add(nums[curr]);
+            curr++;
+        }
+        maxLen = Math.max(maxLen, numbers.size());
+        return maxLen;
+    }
+}

src/DailyCoding189.java

@@ -0,0 +1,32 @@
+/**
+ * Given a circular array, compute its maximum subarray sum in O(n) time. A subarray can be empty, and in this case the
+ * sum is 0.
+ *
+ * For example, given [8, -1, 3, 4], return 15 as we choose the numbers 3, 4, and 8 where the 8 is obtained from
+ * wrapping around.
+ *
+ * Given [-4, 5, 1, 0], return 6 as we choose the numbers 5 and 1.
+ */
+public class DailyCoding190 {
+    public static void main(String[] args) {
+        System.out.println(maxSumSubArray(new int[]{8,-1,3,4})==15);
+        System.out.println(maxSumSubArray(new int[]{-4,5,1,0})==6);
+    }
+    public static int maxSumSubArray(int[] nums) {
+        //first find maximum sum sub array considering that the array is not circular
+        //then find the minimum sum sub array considering that the array is not circular
+        //maximum sum sub array, when the array is circular would be total sum - min sub array sum
+        int total = 0, maxSum = Integer.MIN_VALUE, curMax = 0, curMin = 0, minSum = Integer.MAX_VALUE;
+        for (int n : nums) {
+            curMax = Math.max(curMax+n, n);
+            maxSum = Math.max(maxSum, curMax);
+            curMin = Math.min(curMin+n, n);
+            minSum = Math.min(curMin, minSum);
+            total += n;
+        }
+        //corner case: when all numbers are negative, the maxSum = max(nums) and minSum = sum(nums).
+        //max(maxSum, total - minSum) = 0. However, we should be returning 0, representing empty sub array
+        return maxSum > 0 ? Math.max(maxSum, total - minSum) : 0;
+    }
+}
+

src/DailyCoding190.java

@@ -0,0 +1,42 @@
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * Given a collection of intervals, find the minimum number of intervals you need to remove to make the rest of the
+ * intervals non-overlapping.
+ *
+ * Intervals can "touch", such as [0, 1] and [1, 2], but they won't be considered overlapping.
+ *
+ * For example, given the intervals (7, 9), (2, 4), (5, 8), return 1 as the last interval can be removed and the first
+ * two won't overlap.
+ */
+public class DailyCoding191 {
+    public static void main(String[] args) {
+
+    }
+    public int eraseOverlapIntervals(Interval[] intervals) {
+        if(intervals.length==0){
+            return 0;
+        }
+        Arrays.sort(intervals, (i1, i2) -> {
+            if(i1.end == i2.end){
+                return 0;
+            } else if(i1.end < i2.end){
+                return -1;
+            } else if(i1.end > i2.end){
+                return 1;
+            }
+            return 0;
+        });
+        int count = 1, end = intervals[0].end;
+        /*Find the maximum number of non-overlapping intervals.
+        Then substract that from total number to get minimum number of intervals to be removed.*/
+        for(int i=1; i < intervals.length; i++){
+            if(end <= intervals[i].start){
+                count++;
+                end = intervals[i].end;
+            }
+        }
+        return intervals.length-count;
+    }
+}

src/DailyCoding191.java

@@ -0,0 +1,33 @@
+/**
+ * You are given an array of nonnegative integers. Let's say you start at the beginning of the array and are trying to
+ * advance to the end. You can advance at most, the number of steps that you're currently on. Determine whether you can
+ * get to the end of the array.
+ *
+ * For example, given the array [1, 3, 1, 2, 0, 1], we can go from indices 0 -> 1 -> 3 -> 5, so return true.
+ *
+ * Given the array [1, 2, 1, 0, 0], we can't reach the end, so return false.
+ */
+public class DailyCoding192 {
+    public static void main(String[] args) {
+        System.out.println(canJump(new int[]{1,3,1,2,0,1}));
+        System.out.println(canJump(new int[]{1,2,1,0,0}));
+    }
+    public static boolean canJump(int[] nums) {
+        boolean[] possible = new boolean[nums.length];
+        if(nums.length==0){
+            return true;
+        }
+        possible[0]=true;
+        for(int i=0; i<nums.length; i++){
+            for(int j=i-1; j>=0; j--){
+                if(possible[j]){
+                    possible[i] = j+nums[j]>=i;
+                    if(possible[i]){
+                        break;
+                    }
+                }
+            }
+        }
+        return possible[possible.length-1];
+    }
+}

src/DailyCoding192.java

@@ -0,0 +1,89 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * Suppose you are given two lists of n points, one list p1, p2, ..., pn on the line y = 0 and the other
+ * list q1, q2, ..., qn on the line y = 1. Imagine a set of n line segments connecting each point pi to qi.
+ * Write an algorithm to determine how many pairs of the line segments intersect.
+ */
+class LPoint {
+    int x;
+    int y;
+    public LPoint(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+}
+public class DailyCoding194 {
+    public static void main(String[] args) {
+        System.out.println(numInversions(new int[]{2,4,1,3,5}) == 3);
+        System.out.println(numInversions(new int[]{1, 20, 6, 4, 5}) == 5);
+    }
+    public static int intersections(int[] p, int[] q) {
+        List<LPoint> points = new ArrayList<>();
+        for (int i=0; i<p.length; i++) {
+            points.add(new LPoint(p[i], q[i]));
+        }
+        Collections.sort(points, (o1, o2) -> {
+            if (o1.x == o2.x) {
+                return 0;
+            } else if (o1.x > o2.x) {
+                return 1;
+            } else {
+                return -1;
+            }
+        });
+        int[] sorted = new int[q.length];
+        for (int i=0; i<points.size(); i++) {
+            sorted[i] = points.get(i).y;
+        }
+        return numInversions(sorted);
+    }
+    public static int numInversions(int[] arr) {
+        return mergeSort(arr, 0, arr.length-1);
+    }
+    public static int mergeSort(int[] arr, int start, int end) {
+        int count = 0;
+        if (start < end) {
+            int mid = (start + end)/2;
+            count += mergeSort(arr, start, mid);
+            count += mergeSort(arr, mid+1, end);
+            count += merge(arr, start, mid, end);
+        }
+        return count;
+    }
+    public static int merge(int[] arr, int start, int mid, int end) {
+        int n = end-start+1;
+        int[] tmp = new int[n];
+        int l = start, r = mid+1;
+        int k = 0, count = 0;
+        while (l <= mid && r<=end) {
+            if (arr[l] <= arr[r]) {
+                tmp[k] = arr[l];
+                l++;
+                k++;
+            } else {
+                count += (mid - l + 1);
+                tmp[k] = arr[r];
+                r++;
+                k++;
+            }
+        }
+        while (l <= mid) {
+            tmp[k] = arr[l];
+            k++;
+            l++;
+        }
+        while (r<=end) {
+            tmp[k] = arr[r];
+            r++;
+            k++;
+        }
+        for (int i=start; i<=end; i++) {
+            arr[i] = tmp[i-start];
+        }
+        return count;
+    }
+}

src/DailyCoding194.java

@@ -0,0 +1,47 @@
+/**
+ * Let A be an N by M matrix in which every row and every column is sorted.
+ *
+ * Given i1, j1, i2, and j2, compute the number of elements of M smaller than M[i1, j1] and larger than M[i2, j2].
+ */
+public class DailyCoding195 {
+    public static void main(String[] args) {
+        int[][] matrix = {{1,3,7,10,15,20}, {2,6,9,14,22,25}, {3,8,10,15,25,20}, {10,11,12,23,30,35}, {20,25,30,35,40,45}};
+        System.out.println(count(matrix, 1, 1, 3, 3));
+    }
+    public static int count(int[][] matrix, int i1, int j1, int i2, int j2) {
+        if (i1 == i2) {
+            if (j1 < j2) {
+                return countHelper(matrix, i1, j1, i2, j2);
+            } else {
+                return countHelper(matrix, i2, j2, i1, j1);
+            }
+        } else if(i1 < i2){
+            return countHelper(matrix, i1, j1, i2, j2);
+        } else {
+            return countHelper(matrix, i2, j2, i1, j1);
+        }
+    }
+    public static int countHelper(int[][] matrix, int i1, int j1, int i2, int j2) {
+        int count = 0;
+        for (int i=0; i< matrix.length; i++) {
+            int start = 0;
+            while (start < matrix[0].length && matrix[i][start] < matrix[i1][j1]) {
+                start++;
+            }
+            if (start == matrix[0].length) {
+                //there is nothing greater than starting point in this row.
+                continue;
+            }
+            int end = matrix.length-1;
+            while (end >=0 && matrix[i][end] > matrix[i2][j2]) {
+                end--;
+            }
+            if (end < 0) {
+                //there is nothing less than ending point
+                continue;
+            }
+            count += end - start + 1;
+        }
+        return count;
+    }
+}

src/DailyCoding195.java

@@ -0,0 +1,51 @@
+import java.util.*;
+
+/**
+ * Given the root of a binary tree, find the most frequent subtree sum. The subtree sum of a node is the sum of all
+ * values under a node, including the node itself.
+ *
+ *   5
+ *  / \
+ * 2  -5
+ *
+ * Return 2 as it occurs twice: once as the left leaf, and once as the sum of 2 + 5 - 5.
+ */
+
+public class DailyCoding196 {
+    public static void main(String[] args) {
+        TreeNode root = new TreeNode(5);
+        root.left = new TreeNode(2);
+        root.right = new TreeNode(-5);
+        Utility.print(findFrequentTreeSum(root));
+    }
+    public static int[] findFrequentTreeSum(TreeNode root) {
+        HashMap<Integer, Integer> counts = new HashMap<>();
+        int[] maxCount = {0};
+        findFrequentTreeSumHelper(root, counts, maxCount);
+        List<Integer> rs = new ArrayList<>();
+        for (Map.Entry<Integer, Integer> entry : counts.entrySet()) {
+            if (entry.getValue() == maxCount[0]) {
+                rs.add(entry.getKey());
+            }
+        }
+        int[] res = new int[rs.size()];
+        for (int i=0; i<rs.size(); i++) {
+            res[i] = rs.get(i);
+        }
+        return res;
+    }
+    public static int findFrequentTreeSumHelper(TreeNode root, HashMap<Integer, Integer> counts, int[] maxCount) {
+        if (root == null) {
+            return 0;
+        }
+        int left = findFrequentTreeSumHelper(root.left, counts, maxCount);
+        int right = findFrequentTreeSumHelper(root.right, counts, maxCount);
+
+        int total = root.val + left + right;
+        int count = counts.getOrDefault(total, 0);
+        counts.put(total, count+1);
+        maxCount[0] = Math.max(maxCount[0], count+1);
+        return total;
+    }
+}
+

src/DailyCoding196.java

@@ -0,0 +1,27 @@
+/**
+ * Given an array and a number k that's smaller than the length of the array, rotate the array to the right
+ * k elements in-place.
+ */
+public class DailyCoding197 {
+    public static void main(String[] args) {
+        Utility.print(rotate(new int[]{1,2,3,4,5,6,7}, 3));
+    }
+    public static int[] rotate(int[] nums, int k) {
+        int n = nums.length;
+        k = k%n;
+        int displaced = 0;
+        for(int i=0; displaced < n; i++) {
+            int current = i;
+            int value = nums[i];
+            do {
+                int index = (i+k)%n;
+                int replaced = nums[index];
+                nums[index] = value;
+                i = index;
+                value = replaced;
+                displaced++;
+            } while (i != current);
+        }
+        return nums;
+    }
+}