[Leo] 13th Week solutions

insert-interval/Leo.py

@@ -0,0 +1,17 @@
+class Solution:
+    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
+        left = []
+        right = []
+
+        for interval in intervals:
+            if interval[1] < newInterval[0]:
+                left.append(interval)
+            elif interval[0] > newInterval[1]:
+                right.append(interval)
+            else:
+                newInterval[0] = min(newInterval[0], interval[0])
+                newInterval[1] = max(newInterval[1], interval[1])
+
+        return left + [newInterval] + right
+
+        ## TC: O(n), SC: O(n)

meeting-rooms-ii/Leo.py

@@ -0,0 +1,19 @@
+class Solution:
+    def minMeetingRooms(self, intervals: List[List[int]]) -> int:
+        if not intervals:
+            return 0
+
+        rooms_needed, end_pointer = 0, 0
+
+        start_times = sorted([interval[0] for interval in intervals])
+        end_times = sorted([interval[1] for interval in intervals])
+
+        for i in range(len(start_times)):
+            if start_times[i] >= end_times[end_pointer]:
+                end_pointer += 1
+            else:
+                rooms_needed += 1
+
+        return rooms_needed
+
+        ## TC: O(nlogn), SC: O(n)

merge-intervals/Leo.py

@@ -0,0 +1,20 @@
+class Solution:
+    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
+        def sort_key(interval):
+            return interval[0]
+
+        intervals.sort(key=sort_key)
+
+        result = [intervals[0]]
+
+        for start, end in intervals[1:]:
+            lastEnd = result[-1][1]
+
+            if start <= lastEnd:
+                result[-1][1] = max(lastEnd, end)
+            else:
+                result.append([start, end])
+
+        return result
+
+        ## TC: O(nlogn), SC: O(n)

non-overlapping-intervals/Leo.py

@@ -0,0 +1,16 @@
+class Solution:
+    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
+        last_end = -math.inf
+        overlap_count = 0
+
+        sorted_intervals = sorted(intervals, key=lambda interval: interval[1])
+
+        for start, end in sorted_intervals:
+            if start >= last_end:
+                last_end = end
+            else:
+                overlap_count += 1
+
+        return overlap_count
+
+        ## TC: O(nlogn), SC: O(n)

rotate-image/Leo.py

@@ -0,0 +1,14 @@
+class Solution:
+    def rotate(self, matrix: List[List[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        matrix.reverse()
+
+        n = len(matrix)
+
+        for i in range(n):
+            for j in range(i + 1, n):
+                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
+
+        ## TC: O(n^2), SC: O(1)