added tasks 350, 352, 354

src/main/java/g0301_0400/s0350_intersection_of_two_arrays_ii/Solution.java

@@ -0,0 +1,40 @@
+package g0301_0400.s0350_intersection_of_two_arrays_ii;
+
+// #Easy #Top_Interview_Questions #Array #Hash_Table #Sorting #Binary_Search #Two_Pointers
+
+import java.util.Arrays;
+
+public class Solution {
+    public int[] intersect(int[] nums1, int[] nums2) {
+        // First sort the array
+        Arrays.sort(nums1);
+        // Similar this one as well
+        Arrays.sort(nums2);
+        // "i" will point at nums1
+        int i = 0;
+        // "j" will point at nums2
+        int j = 0;
+        // "k" will point at nums1 and helps in getting the intersection answer;
+        int k = 0;
+        // Loop will run until "i" & "j" doesn't reach the array boundary;
+        while (i < nums1.length && j < nums2.length) {
+            if (nums1[i] < nums2[j]) {
+                // Check if nums1 value is less then nums2 value;
+                // Increment "i"
+                i++;
+            } else if (nums1[i] > nums2[j]) {
+                // Check if nums2 value is less then nums1 value;
+                // Increment "j"
+                j++;
+
+            } else {
+                // Check if nums1 value is equals to nums2 value;
+                // Dump into nums1 and increment k, increment i & increment j as well;
+                nums1[k++] = nums1[i++];
+                j++;
+            }
+        }
+        // Only return nums1 0th index to kth index value, because that's will be our intersection;
+        return Arrays.copyOfRange(nums1, 0, k);
+    }
+}

src/main/java/g0301_0400/s0350_intersection_of_two_arrays_ii/readme.md

@@ -0,0 +1,30 @@
+350\. Intersection of Two Arrays II
+
+Easy
+
+Given two integer arrays `nums1` and `nums2`, return _an array of their intersection_. Each element in the result must appear as many times as it shows in both arrays and you may return the result in **any order**.
+
+**Example 1:**
+
+**Input:** nums1 = \[1,2,2,1\], nums2 = \[2,2\]
+
+**Output:** \[2,2\]
+
+**Example 2:**
+
+**Input:** nums1 = \[4,9,5\], nums2 = \[9,4,9,8,4\]
+
+**Output:** \[4,9\]
+
+**Explanation:** \[9,4\] is also accepted.
+
+**Constraints:**
+
+*   `1 <= nums1.length, nums2.length <= 1000`
+*   `0 <= nums1[i], nums2[i] <= 1000`
+
+**Follow up:**
+
+*   What if the given array is already sorted? How would you optimize your algorithm?
+*   What if `nums1`'s size is small compared to `nums2`'s size? Which algorithm is better?
+*   What if elements of `nums2` are stored on disk, and the memory is limited such that you cannot load all elements into the memory at once?

src/main/java/g0301_0400/s0352_data_stream_as_disjoint_intervals/SummaryRanges.java

@@ -0,0 +1,67 @@
+package g0301_0400.s0352_data_stream_as_disjoint_intervals;
+
+// #Hard #Binary_Search #Design #Ordered_Set
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SummaryRanges {
+    private static class Node {
+        int min;
+        int max;
+
+        public Node(int min, int max) {
+            this.min = min;
+            this.max = max;
+        }
+
+        public Node(int val) {
+            min = val;
+            max = val;
+        }
+    }
+
+    List<Node> list;
+    // Initialize your data structure here.
+    public SummaryRanges() {
+        list = new ArrayList<>();
+    }
+
+    public void addNum(int val) {
+        int left = 0;
+        int right = list.size() - 1;
+        int index = list.size();
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+            Node node = list.get(mid);
+            if (node.min <= val && val <= node.max) {
+                return;
+            } else if (val < node.min) {
+                index = mid;
+                right = mid - 1;
+            } else if (val > node.max) {
+                left = mid + 1;
+            }
+        }
+        list.add(index, new Node(val));
+    }
+
+    public int[][] getIntervals() {
+        for (int i = 1; i < list.size(); i++) {
+            Node prev = list.get(i - 1);
+            Node curr = list.get(i);
+            if (curr.min == prev.max + 1) {
+                prev.max = curr.max;
+                list.remove(i--);
+            }
+        }
+        int len = list.size();
+        int[][] res = new int[len][2];
+        for (int i = 0; i < len; i++) {
+            Node node = list.get(i);
+            res[i][0] = node.min;
+            res[i][1] = node.max;
+        }
+        return res;
+    }
+}

src/main/java/g0301_0400/s0352_data_stream_as_disjoint_intervals/readme.md

@@ -0,0 +1,39 @@
+352\. Data Stream as Disjoint Intervals
+
+Hard
+
+Given a data stream input of non-negative integers <code>a<sub>1</sub>, a<sub>2</sub>, ..., a<sub>n</sub></code>, summarize the numbers seen so far as a list of disjoint intervals.
+
+Implement the `SummaryRanges` class:
+
+*   `SummaryRanges()` Initializes the object with an empty stream.
+*   `void addNum(int val)` Adds the integer `val` to the stream.
+*   `int[][] getIntervals()` Returns a summary of the integers in the stream currently as a list of disjoint intervals <code>[start<sub>i</sub>, end<sub>i</sub>]</code>.
+
+**Example 1:**
+
+**Input** \["SummaryRanges", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals"\] \[\[\], \[1\], \[\], \[3\], \[\], \[7\], \[\], \[2\], \[\], \[6\], \[\]\]
+
+**Output:** \[null, null, \[\[1, 1\]\], null, \[\[1, 1\], \[3, 3\]\], null, \[\[1, 1\], \[3, 3\], \[7, 7\]\], null, \[\[1, 3\], \[7, 7\]\], null, \[\[1, 3\], \[6, 7\]\]\]
+
+**Explanation:**
+```
+SummaryRanges summaryRanges = new SummaryRanges(); 
+summaryRanges.addNum(1); // arr = [1] 
+summaryRanges.getIntervals(); // return [[1, 1]] 
+summaryRanges.addNum(3); // arr = [1, 3] 
+summaryRanges.getIntervals(); // return [[1, 1], [3, 3]] 
+summaryRanges.addNum(7); // arr = [1, 3, 7] 
+summaryRanges.getIntervals(); // return [[1, 1], [3, 3], [7, 7]] 
+summaryRanges.addNum(2); // arr = [1, 2, 3, 7] 
+summaryRanges.getIntervals(); // return [[1, 3], [7, 7]] 
+summaryRanges.addNum(6); // arr = [1, 2, 3, 6, 7] 
+summaryRanges.getIntervals(); // return [[1, 3], [6, 7]]
+```
+
+**Constraints:**
+
+*   <code>0 <= val <= 10<sup>4</sup></code>
+*   At most <code>3 * 10<sup>4</sup></code> calls will be made to `addNum` and `getIntervals`.
+
+**Follow up:** What if there are lots of merges and the number of disjoint intervals is small compared to the size of the data stream?

src/main/java/g0301_0400/s0354_russian_doll_envelopes/Solution.java

@@ -0,0 +1,30 @@
+package g0301_0400.s0354_russian_doll_envelopes;
+
+// #Hard #Array #Dynamic_Programming #Sorting #Binary_Search
+
+import java.util.Arrays;
+
+public class Solution {
+    public int maxEnvelopes(int[][] envelopes) {
+        Arrays.sort(envelopes, (a, b) -> a[0] != b[0] ? a[0] - b[0] : b[1] - a[1]);
+        int[] tails = new int[envelopes.length];
+        int size = 0;
+        for (int[] enve : envelopes) {
+            int i = 0;
+            int j = size;
+            while (i != j) {
+                int mid = i + ((j - i) >> 1);
+                if (tails[mid] < enve[1]) {
+                    i = mid + 1;
+                } else {
+                    j = mid;
+                }
+            }
+            tails[i] = enve[1];
+            if (i == size) {
+                size++;
+            }
+        }
+        return size;
+    }
+}

src/main/java/g0301_0400/s0354_russian_doll_envelopes/readme.md

@@ -0,0 +1,31 @@
+354\. Russian Doll Envelopes
+
+Hard
+
+You are given a 2D array of integers `envelopes` where <code>envelopes[i] = [w<sub>i</sub>, h<sub>i</sub>]</code> represents the width and the height of an envelope.
+
+One envelope can fit into another if and only if both the width and height of one envelope are greater than the other envelope's width and height.
+
+Return _the maximum number of envelopes you can Russian doll (i.e., put one inside the other)_.
+
+**Note:** You cannot rotate an envelope.
+
+**Example 1:**
+
+**Input:** envelopes = \[\[5,4\],\[6,4\],\[6,7\],\[2,3\]\]
+
+**Output:** 3
+
+**Explanation:** The maximum number of envelopes you can Russian doll is `3` (\[2,3\] => \[5,4\] => \[6,7\]).
+
+**Example 2:**
+
+**Input:** envelopes = \[\[1,1\],\[1,1\],\[1,1\]\]
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= envelopes.length <= 5000`
+*   `envelopes[i].length == 2`
+*   <code>1 <= w<sub>i</sub>, h<sub>i</sub> <= 10<sup>4</sup></code>

src/test/java/g0301_0400/s0350_intersection_of_two_arrays_ii/SolutionTest.java

@@ -0,0 +1,22 @@
+package g0301_0400.s0350_intersection_of_two_arrays_ii;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void intersect() {
+        assertThat(
+                new Solution().intersect(new int[] {1, 2, 2, 1}, new int[] {2, 2}),
+                equalTo(new int[] {2, 2}));
+    }
+
+    @Test
+    void intersect2() {
+        assertThat(
+                new Solution().intersect(new int[] {4, 9, 5}, new int[] {9, 4, 9, 8, 4}),
+                equalTo(new int[] {4, 9}));
+    }
+}

src/test/java/g0301_0400/s0352_data_stream_as_disjoint_intervals/SummaryRangesTest.java

@@ -0,0 +1,50 @@
+package g0301_0400.s0352_data_stream_as_disjoint_intervals;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SummaryRangesTest {
+    SummaryRanges summaryRanges = new SummaryRanges();
+
+    @Test
+    void testGetInterval() {
+        summaryRanges.addNum(1);
+        assertThat(summaryRanges.getIntervals(), equalTo(new int[][] {{1, 1}}));
+    }
+
+    @Test
+    void testGetInterval2() {
+        summaryRanges.addNum(1);
+        summaryRanges.addNum(3);
+        assertThat(summaryRanges.getIntervals(), equalTo(new int[][] {{1, 1}, {3, 3}}));
+    }
+
+    @Test
+    void testGetInterval3() {
+        summaryRanges.addNum(1);
+        summaryRanges.addNum(3);
+        summaryRanges.addNum(7);
+        assertThat(summaryRanges.getIntervals(), equalTo(new int[][] {{1, 1}, {3, 3}, {7, 7}}));
+    }
+
+    @Test
+    void testGetInterval4() {
+        summaryRanges.addNum(1);
+        summaryRanges.addNum(2);
+        summaryRanges.addNum(3);
+        summaryRanges.addNum(7);
+        assertThat(summaryRanges.getIntervals(), equalTo(new int[][] {{1, 3}, {7, 7}}));
+    }
+
+    @Test
+    void testGetInterval5() {
+        summaryRanges.addNum(1);
+        summaryRanges.addNum(2);
+        summaryRanges.addNum(3);
+        summaryRanges.addNum(6);
+        summaryRanges.addNum(7);
+        assertThat(summaryRanges.getIntervals(), equalTo(new int[][] {{1, 3}, {6, 7}}));
+    }
+}

src/test/java/g0301_0400/s0354_russian_doll_envelopes/SolutionTest.java

@@ -0,0 +1,21 @@
+package g0301_0400.s0354_russian_doll_envelopes;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+
+    @Test
+    void testMaxEnvelopes() {
+        assertThat(
+                new Solution().maxEnvelopes(new int[][] {{5, 4}, {6, 4}, {6, 7}, {2, 3}}),
+                equalTo(3));
+    }
+
+    @Test
+    void testMaxEnvelopes2() {
+        assertThat(new Solution().maxEnvelopes(new int[][] {{1, 1}, {1, 1}, {1, 1}}), equalTo(1));
+    }
+}