Add 88

Author: CharryWu

2024/meta/prep.py

@@ -1560,3 +1560,33 @@ def numFriendRequests(self, ages: List[int]) -> int:
             left = bisect.bisect_right(ages, 0.5 * a + 7)
             cnt += max(0, right - left - 1)
         return cnt
+
+############# 636. Exclusive Time of Functions #############
+class Solution:
+    def exclusiveTime(self, n: int, logs: List[str]) -> List[int]:
+        """
+        let's look between adjacent events, with duration time - prev_time.
+        If we started a function, and we have a function in the background,
+        then it was running during this time.
+
+        Otherwise, we ended the function that is most recent in our stack
+        """
+        res = [0] * n
+        prevtime = 0
+        stack = []
+        for log in logs:
+            funcid, startend, time = log.split(':')
+            funcid = int(funcid)
+            time = int(time)
+
+            if startend == "start":
+                if stack:
+                    res[stack[-1]] += time-prevtime
+                stack.append(funcid)
+                prevtime = time
+            else:
+                res[stack.pop()] += time-prevtime + 1
+                prevtime = time+1
+
+        return res
+

array-intervals/meeting-rooms/986. Interval List Intersections.py

@@ -0,0 +1,15 @@
+class Solution:
+    def intervalIntersection(self, firstList: List[List[int]], secondList: List[List[int]]) -> List[List[int]]:
+        res = []
+        i, j = 0, 0
+        while i < len(firstList) and j < len(secondList):
+            newstart = max(firstList[i][0], secondList[j][0])
+            newend = min(firstList[i][1], secondList[j][1])
+
+            if newstart <= newend:
+                res.append((newstart, newend))
+            if firstList[i][1] < secondList[j][1]:
+                i += 1
+            else:
+                j += 1
+        return res

array-merge/88. Merge Sorted Array.py

@@ -0,0 +1,22 @@
+class Solution:
+    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
+        """
+        Do not return anything, modify nums1 in-place instead.
+        """
+        i, j = m-1, n-1
+        k = len(nums1)-1
+
+        while i >= 0 and j >= 0:
+            if nums1[i] > nums2[j]:
+                nums1[k] = nums1[i]
+                i -= 1
+            else:
+                nums1[k] = nums2[j]
+                j -= 1
+
+            k -= 1
+
+        while j >= 0:
+            nums1[k] = nums2[j]
+            k -= 1
+            j -= 1

stack/636. Exclusive Time of Functions.py

@@ -0,0 +1,28 @@
+class Solution:
+    def exclusiveTime(self, n: int, logs: List[str]) -> List[int]:
+        """
+        let's look between adjacent events, with duration time - prev_time.
+        If we started a function, and we have a function in the background,
+        then it was running during this time.
+
+        Otherwise, we ended the function that is most recent in our stack
+        """
+        res = [0] * n
+        prevtime = 0
+        stack = []
+        for log in logs:
+            funcid, startend, time = log.split(':')
+            funcid = int(funcid)
+            time = int(time)
+
+            if startend == "start":
+                if stack:
+                    res[stack[-1]] += time - prevtime
+                stack.append(funcid)
+                prevtime = time
+            else:
+                res[stack.pop()] += time + 1 -prevtime
+                prevtime = time+1
+
+        return res
+