[8804who] WEEK 13 solutions

find-median-from-data-stream/8804who.py

@@ -0,0 +1,26 @@
+import heapq
+
+class MedianFinder:
+
+    def __init__(self):
+        self.max_heap = []
+        self.min_heap = []
+
+    def addNum(self, num: int) -> None:
+        if not self.min_heap or self.min_heap[0] <= num:
+            heapq.heappush(self.min_heap, num)
+        else:
+            heapq.heappush(self.max_heap, -num)
+
+        if len(self.min_heap) < len(self.max_heap):
+            heapq.heappush(self.min_heap, -heapq.heappop(self.max_heap))
+        elif len(self.min_heap) > len(self.max_heap) + 1:
+            heapq.heappush(self.max_heap, -heapq.heappop(self.min_heap))
+
+    def findMedian(self) -> float:
+        if len(self.min_heap) == len(self.max_heap):
+            return (self.min_heap[0]-self.max_heap[0])/2
+        else:
+            return self.min_heap[0]
+
+

insert-interval/8804who.py

@@ -0,0 +1,20 @@
+class Solution:
+    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
+        new_start = 1e9
+        new_end = -1
+
+        answer = []
+
+        for start, end in intervals:
+            if start <= newInterval[0] <= end or newInterval[0] <= start <= newInterval[1] or newInterval[0] <= end <= newInterval[1] or start <= newInterval[1] <= end:
+                if new_start == 1e9:
+                    new_start = start
+                new_end = end
+            else:
+                answer.append([start, end])
+        new_start = min(new_start, newInterval[0])
+        new_end = max(new_end, newInterval[1])
+
+        answer.append([new_start, new_end])
+        return sorted(answer)
+

kth-smallest-element-in-a-bst/8804who.py

@@ -0,0 +1,25 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        answer = 0
+
+        def dfs(node):
+            nonlocal k
+            nonlocal answer
+            if node.left:
+                dfs(node.left)
+            k -= 1
+            if k == 0:
+                answer = node.val
+                return
+            if node.right:
+                dfs(node.right)
+        dfs(root)
+
+        return answer
+

lowest-common-ancestor-of-a-binary-search-tree/8804who.py

@@ -0,0 +1,15 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        if p.val < root.val and  q.val < root.val:
+            return self.lowestCommonAncestor(root.left, p, q)
+        if p.val > root.val and q.val > root.val:
+            return self.lowestCommonAncestor(root.right, p, q)
+        return root
+