refactor(algorithms, intervals): merge intervals

Author: BrianLusina

algorithms/intervals/merge_intervals/README.md

@@ -0,0 +1,75 @@
+# Merge Intervals
+
+Given an array of intervals where intervals[i] = [starti, endi], merge all overlapping intervals, and return an array
+of the non-overlapping intervals that cover all the intervals in the input.
+
+## Constraints
+
+- 1 ≤ `intervals.length` ≤ 10^3
+- `intervals[i].length` == 2
+- 0 ≤ `starti` ≤ `endi` ≤ 10^4
+
+
+Example 1:
+```text
+Input: intervals = [[1,3],[2,6],[8,10],[15,18]]
+Output: [[1,6],[8,10],[15,18]]
+Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6].
+```
+
+Example 2:
+```text
+Input: intervals = [[1,4],[4,5]]
+Output: [[1,5]]
+Explanation: Intervals [1,4] and [4,5] are considered overlapping.
+```
+
+## Solution
+
+### Naive Approach
+
+The naive approach to merging intervals involves comparing each interval with all the intervals that come after it. If 
+two intervals overlap, they are merged into a single interval by updating the start to the minimum of both start times 
+and the end to the maximum of both end times. After merging, the second interval (the one being compared) is removed 
+from the list, as its range is now included in the updated interval. The algorithm then checks for further overlaps with
+the updated interval from the same position. This process repeats until all overlapping intervals have been merged, 
+resulting in a final list of non-overlapping intervals.
+
+This process continues until all overlapping intervals are merged. While this method is easy to understand and doesn’t 
+require extra space, it can be inefficient for large inputs because it compares each interval with many others, leading 
+to a time complexity of O(n^2).
+
+### Optimized approach using the intervals pattern
+
+The optimized approach starts by sorting the intervals in ascending order based on their start times. This step ensures
+overlapping intervals are positioned next to each other, making identifying and merging them easier. Once sorted, the 
+algorithm initializes a result list with the first interval. It then iterates through the remaining intervals one by 
+one, comparing each to the last interval in the result list.
+
+If the current interval overlaps with the last one in the result (i.e., its start time is less than or equal to the end 
+time of the last interval), the two intervals are merged by updating the end time to the maximum of both intervals’ end 
+times. If there is no overlap, the current interval is added to the result list as a new entry. This process continues 
+until all intervals have been processed. In the end, the result list contains the merged, non-overlapping intervals.
+
+#### Solution summary
+
+To recap, the solution to this problem can be divided into the following two parts:
+
+1. Sort the intervals list according to the start time.
+2. Add the first interval from the sorted list to the output list. 
+3. Then, iterate through the remaining intervals one by one. For each interval, check if it overlaps with the last 
+   interval in the output list:
+   - If they overlap, merge them by updating the end time to the maximum of both end times, and update the last interval 
+     in the output list.
+   - If they don’t overlap, simply append the current interval to the output list as a separate entry.
+
+#### Time Complexity
+
+The time complexity of this solution is O(n log n) where n is the number of intervals. This is because we need to sort 
+the intervals list, which takes O(n log n) time. 
+
+#### Space Complexity
+
+The space complexity is O(n) for storing the result list. However, we do not count the space used merely for input and 
+output in the space complexity calculation. Apart from the space required by the built-in sorting algorithm, the space 
+complexity is O(1).

algorithms/intervals/merge_intervals/__init__.py

@@ -0,0 +1,33 @@
+from typing import List
+
+
+def merge(intervals: List[List[int]]) -> List[List[int]]:
+    """
+    Merges overlapping intervals in a list of intervals.
+    Args:
+        intervals (List[List[int]]): A list of intervals, where each interval is represented as a list of two integers [start, end].
+    Returns:
+        List[List[int]]: A list of merged intervals.
+    """
+    # no intervals to merge
+    if not intervals:
+        return []
+
+    # copy the `intervals` array to avoid mutating the input array
+    closed_intervals = intervals[:]
+    # sort the closed intervals array in place using the start time as the key. This sorts in ascending order
+    closed_intervals.sort(key=lambda x: x[0])
+
+    # the final result array
+    merged = []
+
+    for interval in closed_intervals:
+        # if the merged array is empty or the last interval in the merged array does not overlap with the current interval
+        if not merged or merged[-1][1] < interval[0]:
+            # add it to the merged list
+            merged.append(interval)
+        else:
+            # else we merge the intervals, by updating the max end time of the last interval in the merged list
+            merged[-1][1] = max(merged[-1][1], interval[1])
+
+    return merged

algorithms/intervals/merge_intervals/test_merge_intervals.py

@@ -0,0 +1,33 @@
+import unittest
+from typing import List
+from parameterized import parameterized
+from algorithms.intervals.merge_intervals import merge
+
+
+class MergeIntervalsTestCase(unittest.TestCase):
+    @parameterized.expand(
+        [
+            ([[10, 12], [12, 15]], [[10, 15]]),
+            ([[1, 3], [2, 6], [8, 10], [15, 18]], [[1, 6], [8, 10], [15, 18]]),
+            ([[1, 4], [4, 5]], [[1, 5]]),
+            ([[14, 20]], [[14, 20]]),
+            ([[1, 5], [4, 6], [3, 7], [6, 8]], [[1, 8]]),
+            (
+                [[1, 3], [2, 6], [15, 18], [8, 10], [18, 20]],
+                [[1, 6], [8, 10], [15, 20]],
+            ),
+            ([[4, 6], [3, 7], [1, 5]], [[1, 7]]),
+            ([[4, 6], [3, 7], [1, 5]], [[1, 7]]),
+            ([[1, 5], [4, 6], [11, 15], [6, 8]], [[1, 8], [11, 15]]),
+            ([[1, 5]], [[1, 5]]),
+            ([[1, 9], [3, 8], [4, 4]], [[1, 9]]),
+            ([[1, 2], [8, 8], [3, 4]], [[1, 2], [3, 4], [8, 8]]),
+        ]
+    )
+    def test_merge_intervals(self, intervals: List[List[int]], expected: List[int]):
+        actual = merge(intervals)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == "__main__":
+    unittest.main()

algorithms/sorting/__init__.py

@@ -5,16 +5,18 @@
 
 
 class CandyTestCase(unittest.TestCase):
-    @parameterized.expand([
-        ([1], 1),
-        ([1, 0, 2], 5),
-        ([1, 2, 2], 4),
-        ([1,3,4,5,2], 11),
-        ([1,3,4,5,2], 11),
-        ([1,2,3,4,5], 15),
-        ([5,4,3,2,1], 15),
-        ([5,5,5,5,5,5,5,5], 8),
-    ])
+    @parameterized.expand(
+        [
+            ([1], 1),
+            ([1, 0, 2], 5),
+            ([1, 2, 2], 4),
+            ([1, 3, 4, 5, 2], 11),
+            ([1, 3, 4, 5, 2], 11),
+            ([1, 2, 3, 4, 5], 15),
+            ([5, 4, 3, 2, 1], 15),
+            ([5, 5, 5, 5, 5, 5, 5, 5], 8),
+        ]
+    )
     def test_candy(self, ratings: List[int], expected: int):
         actual = candy(ratings)
         self.assertEqual(expected, actual)

algorithms/sorting/merge_intervals/README.md

@@ -21,6 +21,7 @@ def longest_ones(nums: List[int], k: int) -> int:
 
     return right - left + 1
 
+
 def find_max_consecutive_ones(nums: List[int]) -> int:
     """
     Finds the maximum consecutive ones in a binary array and returns it.

algorithms/sorting/merge_intervals/__init__.py

@@ -5,23 +5,26 @@
 
 
 class MaxConsecutiveOnesTestCase(unittest.TestCase):
-
-    @parameterized.expand([
-        ([1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0], 2, 6),
-        ([0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1], 3, 10),
-    ])
+    @parameterized.expand(
+        [
+            ([1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0], 2, 6),
+            ([0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1], 3, 10),
+        ]
+    )
     def test_longest_ones(self, nums: List[int], k: int, expected: int):
         actual = longest_ones(nums, k)
         self.assertEqual(expected, actual)
 
-    @parameterized.expand([
-        ([1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0], 4),
-        ([0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1], 4),
-        ([1,1,0,0,1,1,1,0,0,1,0], 3),
-        ([1,1,0,0,1,1], 2),
-        ([1,1,1,0,1,1,1,1], 4),
-        ([0,0,0,0], 0),
-    ])
+    @parameterized.expand(
+        [
+            ([1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0], 4),
+            ([0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1], 4),
+            ([1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0], 3),
+            ([1, 1, 0, 0, 1, 1], 2),
+            ([1, 1, 1, 0, 1, 1, 1, 1], 4),
+            ([0, 0, 0, 0], 0),
+        ]
+    )
     def test_find_max_consecutive_ones(self, nums: List[int], expected: int):
         actual = find_max_consecutive_ones(nums)
         self.assertEqual(expected, actual)