Add IntervalListIntersections task solution

Author: andrei-punko

src/main/java/by/andd3dfx/common/IntervalListIntersections.java

@@ -0,0 +1,85 @@
+package by.andd3dfx.common;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * <pre>
+ * <a href="https://leetcode.com/problems/interval-list-intersections/description/">Task description</a>
+ *
+ * You are given two lists of closed intervals, firstList and secondList, where firstList[i] = [starti, endi]
+ * and secondList[j] = [startj, endj]. Each list of intervals is pairwise disjoint and in sorted order.
+ *
+ * Return the intersection of these two interval lists.
+ *
+ * A closed interval [a, b] (with a <= b) denotes the set of real numbers x with a <= x <= b.
+ *
+ * The intersection of two closed intervals is a set of real numbers that are either empty or represented as a closed interval.
+ * For example, the intersection of [1, 3] and [2, 4] is [2, 3].
+ *
+ * Example 1:
+ * <img src="https://assets.leetcode.com/uploads/2019/01/30/interval1.png"/>
+ * Input: firstList = [[0,2],[5,10],[13,23],[24,25]], secondList = [[1,5],[8,12],[15,24],[25,26]]
+ * Output: [[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]]
+ *
+ * Example 2:
+ * Input: firstList = [[1,3],[5,9]], secondList = []
+ * Output: []
+ * </pre>
+ */
+public class IntervalListIntersections {
+
+    public static int[][] intervalIntersection(int[][] firstList, int[][] secondList) {
+        List<Point> points = new ArrayList<>();
+        populatePointList(firstList, points, 1);
+        populatePointList(secondList, points, 2);
+        points.sort(Comparator.comparing(Point::x).thenComparingInt(o -> o.type.ordinal()));
+
+        List<Pair> intersections = new ArrayList<>();
+        var startsAmount = 0;
+        var x = 0;
+        for (var point : points) {
+            switch (point.type) {
+                case START -> {
+                    startsAmount++;
+                    x = point.x;
+                }
+                case END -> {
+                    if (startsAmount <= 0) {
+                        throw new IllegalStateException("END going before any START!");
+                    }
+                    if (startsAmount == 2) {
+                        intersections.add(new Pair(x, point.x));
+                    }
+                    startsAmount--;
+                }
+            }
+        }
+
+        int[][] result = new int[intersections.size()][2];
+        for (int i = 0; i < intersections.size(); i++) {
+            result[i][0] = intersections.get(i).x1;
+            result[i][1] = intersections.get(i).x2;
+        }
+        return result;
+    }
+
+    private static void populatePointList(int[][] firstList, List<Point> points, int listNumber) {
+        for (var pair : firstList) {
+            points.add(new Point(pair[0], Point.Type.START, listNumber));
+            points.add(new Point(pair[1], Point.Type.END, listNumber));
+        }
+    }
+
+    public record Point(int x, Type type, int listNumber) {
+
+        public enum Type {
+            START, END
+        }
+    }
+
+    public record Pair(int x1, int x2) {
+
+    }
+}

src/test/java/by/andd3dfx/common/IntervalListIntersectionsTest.java

@@ -0,0 +1,22 @@
+package by.andd3dfx.common;
+
+import static by.andd3dfx.common.IntervalListIntersections.intervalIntersection;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class IntervalListIntersectionsTest {
+
+    @Test
+    public void testIntervalIntersection() {
+        assertThat(intervalIntersection(
+            new int[][]{{0, 2}, {5, 10}, {13, 23}, {24, 25}},
+            new int[][]{{1, 5}, {8, 12}, {15, 24}, {25, 26}}
+        )).isEqualTo(new int[][]{{1, 2}, {5, 5}, {8, 10}, {15, 23}, {24, 24}, {25, 25}});
+
+        assertThat(intervalIntersection(
+            new int[][]{{1, 3}, {5, 9}},
+            new int[][]{}))
+            .isEqualTo(new int[][]{});
+    }
+}