feat(algorithms): remove min intervals

Author: BrianLusina

algorithms/heap/min_cost_hire_k_workers/__init__.py

@@ -30,7 +30,7 @@ def min_cost_to_hire_workers_2(quality, wage, k):
 
     heap = []  # A max-heap (using negative values for qualities)
     total_quality = 0  # Sum of the qualities of the selected workers
-    min_cost = float('inf')  # Initialize the minimum cost to infinity
+    min_cost = float("inf")  # Initialize the minimum cost to infinity
 
     # Step 2: Iterate through each worker sorted by their wage-to-quality ratio
     for ratio, q in workers:

algorithms/heap/min_cost_hire_k_workers/test_min_cost_to_hire_workers.py

@@ -1,7 +1,10 @@
 import unittest
 from typing import List
 from parameterized import parameterized
-from algorithms.heap.min_cost_hire_k_workers import min_cost_to_hire_workers, min_cost_to_hire_workers_2
+from algorithms.heap.min_cost_hire_k_workers import (
+    min_cost_to_hire_workers,
+    min_cost_to_hire_workers_2,
+)
 
 MIN_COST_TO_HIRE_K_WORKERS_TEST_CASES = [
     ([10, 20, 5], [70, 50, 30], 2, 105.00000),

algorithms/intervals/remove_min_intervals/README.md

@@ -0,0 +1,81 @@
+# Non-overlapping Intervals
+
+Given an array of intervals `intervals` where `intervals[i] = [starti, endi)` contains the half-open interval (start, endi),
+return the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.
+
+> A half-open interval is one that contains only one of its boundary elements. The “(” parenthesis denotes the exclusion
+> of the starting point. The “]” bracket denotes the inclusion of the ending point.
+
+Note that intervals which only touch at a point are non-overlapping. For example, [1, 2] and [2, 3] are non-overlapping.
+
+> Note: Two intervals (a,b] and (c,d] are considered overlapping if there exists a value x such that a<x≤b and c<x≤d. In
+> other words, if there is any point within both intervals (excluding their starting points) where both intervals have
+> values, they are considered overlapping. For example, the intervals (7,11] and (10,12] are overlapping, whereas the
+> intervals (2,4] and (4,5] are non-overlapping.
+
+## Examples
+
+Example 1:
+```text
+Input: intervals = [[1,2],[2,3],[3,4],[1,3]]
+Output: 1
+Explanation: [1,3] can be removed and the rest of the intervals are non-overlapping.
+```
+
+Example 2:
+```text
+Input: intervals = [[1,2],[1,2],[1,2]]
+Output: 2
+Explanation: You need to remove two [1,2] to make the rest of the intervals non-overlapping.
+```
+
+Example 3:
+```text
+Input: intervals = [[1,2],[2,3]]
+Output: 0
+Explanation: You don't need to remove any of the intervals since they're already non-overlapping.
+```
+
+## Constraints
+
+- 1 <= intervals.length <= 10^5
+- intervals[i].length == 2
+- -5 * 10^4 <= starti < endi <= 5 * 10^4
+
+## Topics
+
+- Array
+- Dynamic Programming
+- Greedy
+- Sorting
+
+## Solution
+
+1. Sort the intervals array in an ascending order based on the end time of each interval.
+2. Declare two variables that will assist us in the algorithm:
+   - end: This stores the end time of the last included interval.
+   - remove: This stores the number of intervals to be removed. It is initialized to 
+3. Traverse the sorted intervals array to determine which interval needs to be excluded. For each interval, the following
+   conditions are checked:
+   - If the start time of the current interval is greater than or equal to end, this interval does not overlap with the
+     previously included interval and can be included. Therefore, we update end to the end time of the current interval,
+     which is the next earliest possible end time.
+   - Otherwise, the current interval overlaps with the previously included intervals. Therefore, it must be removed, so
+     we increment remove.
+4. After the sorted intervals array has been traversed completely, there are no more intervals left to evaluate, so we
+   return remove, which now contains the minimum number of intervals to be removed.
+
+### Time Complexity
+
+The time complexity of this solution is O(n log(n)), where n is the length of the `intervals` array.
+
+Explanation:
+
+- Time taken to sort the intervals array: O(nlog(n))
+- Time taken to traverse the intervals array: O(n)
+
+Therefore, the overall time complexity becomes O(n + n log(n)), which simplifies to O(nlog(n)).
+
+### Space Complexity
+
+The space complexity of this solution is O(1).

algorithms/intervals/remove_min_intervals/__init__.py

@@ -0,0 +1,41 @@
+from typing import List
+import sys
+from math import inf
+
+
+def remove_min_intervals(intervals: List[List[int]]) -> int:
+    # Sort the intervals based on their ending points
+    intervals.sort(key=lambda x: x[1])
+
+    # Initialize a variable to keep track of the current end point
+    end = -sys.maxsize - 1
+
+    # Initialize a variable to count the intervals that need to be removed
+    remove = 0
+
+    # Loop through each interval in the sorted list
+    for interval in intervals:
+        # Check if the start point of the current interval is greater than or equal to the current end point
+        if interval[0] >= end:
+            # If it is, update the current end point to the end point of the current interval
+            end = interval[1]
+        else:
+            # If not, increment the count of intervals to be removed
+            remove += 1
+
+    # Return the count of intervals to be removed
+    return remove
+
+
+def remove_min_intervals_2(intervals: List[List[int]]) -> int:
+    sorted_intervals = sorted(intervals, key=lambda x: x[1])
+
+    current_minimum_end, count = float(-inf), 0
+
+    for interval_start, interval_end in sorted_intervals:
+        if interval_start >= current_minimum_end:
+            current_minimum_end = interval_end
+        else:
+            count += 1
+
+    return count

algorithms/intervals/remove_min_intervals/test_remove_min_intervals.py

@@ -0,0 +1,30 @@
+import unittest
+from typing import List
+from parameterized import parameterized
+from algorithms.intervals.remove_min_intervals import (
+    remove_min_intervals,
+    remove_min_intervals_2,
+)
+
+
+REMOVE_MIN_INTERVALS_TEST_CASES = [
+    ([[1, 2], [2, 3], [3, 4], [1, 3]], 1),
+    ([[1, 2], [1, 2], [1, 2]], 2),
+    ([[1, 2], [2, 3]], 0),
+]
+
+
+class RemoveMinIntervalsTestCase(unittest.TestCase):
+    @parameterized.expand(REMOVE_MIN_INTERVALS_TEST_CASES)
+    def test_remove_min_intervals(self, intervals: List[List[int]], expected: int):
+        actual = remove_min_intervals(intervals)
+        self.assertEqual(expected, actual)
+
+    @parameterized.expand(REMOVE_MIN_INTERVALS_TEST_CASES)
+    def test_remove_min_intervals_2(self, intervals: List[List[int]], expected: int):
+        actual = remove_min_intervals_2(intervals)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == "__main__":
+    unittest.main()