Add 3 interval solutions

* Identify All Interval Overlaps
* Largest Overlap of Intervals
* Merge Overlapping Intervals

Author: marttp

kotlin/Intervals/IdentifyAllIntervalOverlaps.kt

@@ -0,0 +1,28 @@
+data class Interval(var start: Int, var end: Int)
+
+fun identifyAllIntervalOverlaps(intervals1: List<Interval>, intervals2: List<Interval>): List<Interval> {
+    val overlaps = mutableListOf<Interval>()
+    var i = 0
+    var j = 0
+    while (i < intervals1.size && j < intervals2.size) {
+        // Set A to the interval that starts first and B to the other
+        // interval.
+        val (A, B) = if (intervals1[i].start <= intervals2[j].start) {
+            intervals1[i] to intervals2[j]
+        } else {
+            intervals2[j] to intervals1[i]
+        }
+        // If there's an overlap, add the overlap.
+        if (A.end >= B.start) {
+            overlaps.add(Interval(B.start, minOf(A.end, B.end)))
+        }
+        // Advance the pointer associated with the interval that ends
+        // first.
+        if (intervals1[i].end < intervals2[j].end) {
+            i++
+        } else {
+            j++
+        }
+    }
+    return overlaps
+}

kotlin/Intervals/LargestOverlapOfIntervals.kt

@@ -0,0 +1,23 @@
+data class Interval(var start: Int, var end: Int)
+
+fun largestOverlapOfIntervals(intervals: List<Interval>): Int {
+    val points = mutableListOf<Pair<Int, Char>>()
+    for (interval in intervals) {
+        points.add(interval.start to 'S')
+        points.add(interval.end to 'E')
+    }
+    // Sort in chronological order. If multiple points occur at the same
+    // time, ensure end points are prioritized before start points.
+    points.sortWith(compareBy({ it.first }, { it.second }))
+    var activeIntervals = 0
+    var maxOverlaps = 0
+    for ((time, pointType) in points) {
+        if (pointType == 'S') {
+            activeIntervals++
+        } else {
+            activeIntervals--
+        }
+        maxOverlaps = maxOf(maxOverlaps, activeIntervals)
+    }
+    return maxOverlaps
+}

kotlin/Intervals/MergeOverlappingIntervals.kt

@@ -0,0 +1,17 @@
+data class Interval(var start: Int, var end: Int)
+
+fun mergeOverlappingIntervals(intervals: List<Interval>): List<Interval> {
+    val sortedIntervals = intervals.sortedBy { it.start }
+    val merged = mutableListOf(sortedIntervals[0])
+    for (B in sortedIntervals.subList(1, sortedIntervals.size)) {
+        val A = merged.last()
+        // If A and B don't overlap, add B to the merged list.
+        if (A.end < B.start) {
+            merged.add(B)
+            // If they do overlap, merge A with B.
+        } else {
+            merged[merged.size - 1] = Interval(A.start, maxOf(A.end, B.end))
+        }
+    }
+    return merged
+}