feat(algorithms, intervals): merge and insert intervals

Author: BrianLusina

algorithms/intervals/insert_interval/README.md

@@ -0,0 +1,24 @@
+# Insert Interval
+
+You are given a list of non-overlapping intervals, intervals, where each interval is represented as [starti, endi] and 
+the list is sorted in ascending order by the start of each interval (starti). You are also given another interval, 
+new_interval = [start, end].
+
+Your task is to insert new_interval into the list of intervals such that the list remains sorted by starting times and 
+still contains no overlapping intervals. If any intervals overlap after the insertion, merge them accordingly.
+
+Return the updated list of intervals.
+
+> Note You don’t need to modify intervals in place. You can make a new array and return it.
+
+## Constraints
+
+- 0 ≤ `intervals.length` ≤ 10^4
+- `intervals[i].length`, `new_interval.length` == 2
+- 0 ≤ `starti` < `endi` ≤ 10^4
+- The list of intervals is sorted in ascending order based on the start time
+
+## Examples
+
+![Example 1](./images/examples/insert_interval_example_1.png)
+![Example 2](./images/examples/insert_interval_example_2.png)

algorithms/intervals/insert_interval/__init__.py

@@ -0,0 +1,46 @@
+from typing import List
+
+
+def insert_interval(existing_intervals: List[List[int]], new_interval: List[int]):
+    """
+    Inserts the new interval into the list of existing intervals and return the updated list of intervals. This assumes
+    that the existing_intervals array is already sorted by the start time.
+    Args:
+        existing_intervals (List[List[int]]): A list of intervals, where each interval is represented as a list of two integers [start, end].
+        new_interval (List[int]): A new interval to be inserted into the list of existing intervals.
+    Returns:
+        List[List[int]]: The updated list of intervals after inserting the new interval.
+    """
+    # no intervals to insert
+    if not existing_intervals:
+        return [new_interval]
+    result = []
+    i = 0
+    n = len(existing_intervals)
+    new_start, new_end = new_interval
+
+    # add all intervals that come completely before the new interval
+    while i < n and existing_intervals[i][1] < new_start:
+        result.append(existing_intervals[i])
+        i += 1
+
+    # merge all intervals that overlap with the new interval
+    merged_start = new_start
+    merged_end = new_end
+
+    # add all intervals that come completely after the new interval
+    while i < n and existing_intervals[i][0] <= merged_end:
+        # Update merged-start and merged_end
+        merged_start = min(merged_start, existing_intervals[i][0])
+        merged_end = max(merged_end, existing_intervals[i][1])
+        i += 1
+
+    # add the merged interval
+    result.append([merged_start, merged_end])
+
+    # add all intervals that come completely after the new interval
+    while i < n:
+        result.append(existing_intervals[i])
+        i += 1
+
+    return result

algorithms/intervals/insert_interval/images/examples/insert_interval_example_1.png

@@ -0,0 +1,38 @@
+import unittest
+from typing import List
+from parameterized import parameterized
+from algorithms.intervals.insert_interval import insert_interval
+
+
+class InsertIntervalTestCase(unittest.TestCase):
+    @parameterized.expand(
+        [
+            ([[1, 2], [3, 4], [5, 8], [9, 15]], [2, 5], [[1, 8], [9, 15]]),
+            (
+                [[1, 6], [8, 9], [10, 15], [16, 18]],
+                [9, 10],
+                [[1, 6], [8, 15], [16, 18]],
+            ),
+            (
+                [[1, 2], [3, 4], [5, 8], [9, 15]],
+                [16, 17],
+                [[1, 2], [3, 4], [5, 8], [9, 15], [16, 17]],
+            ),
+            ([[1, 4], [5, 6], [7, 8], [9, 10]], [1, 5], [[1, 6], [7, 8], [9, 10]]),
+            ([[1, 3], [4, 6], [7, 8], [9, 10]], [1, 10], [[1, 10]]),
+            ([[1, 3], [5, 7], [8, 9], [10, 13]], [2, 6], [[1, 7], [8, 9], [10, 13]]),
+            ([[1, 3], [6, 9]], [2, 5], [[1, 5], [6, 9]]),
+        ]
+    )
+    def test_insert_interval(
+        self,
+        existing_intervals: List[List[int]],
+        new_interval: List[int],
+        expected: List[List[int]],
+    ):
+        actual = insert_interval(existing_intervals, new_interval)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == "__main__":
+    unittest.main()