updates

Author: wuduhren

problems/python3/find-minimum-in-rotated-sorted-array.py

@@ -0,0 +1,22 @@
+"""
+Usually the binary search problem, the hard part is to clear all the edge cases.
+What will be the edge case? It will be when the recursive function executed at the deepest level. Usually the list with only one or two element.
+So I will suggest before submit, try out the case like [0,1] or [1,0] to make sure it will not run unstop.
+"""
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        def helper(l, r):
+            nonlocal ans
+            if l>r: return
+            
+            m = l + int((r-l)/2)
+            if nums[l]<=nums[m]:
+                ans = min(ans, nums[l])
+                helper(m+1, r)
+            else:
+                ans = min(ans, nums[m+1])
+                helper(l, m)
+        
+        ans = float('inf')
+        helper(0, len(nums)-1)
+        return ans

problems/python3/koko-eating-bananas.py

@@ -0,0 +1,21 @@
+class Solution:
+    def minEatingSpeed(self, piles: List[int], h: int) -> int:
+        def canFinish(k):
+            timeNeeded = 0
+            for pile in piles:
+                timeNeeded += math.ceil(pile/k)
+            return timeNeeded<=h
+        
+        kMin = 1
+        kMax = max(piles)
+        ans = kMax
+        
+        while kMin<=kMax:
+            k = kMin + int((kMax-kMin)/2)
+            if canFinish(k):
+                ans = min(ans, k)
+                kMax = k-1
+            else:
+                kMin = k+1
+        
+        return ans

problems/python3/median-of-two-sorted-arrays.py

@@ -0,0 +1,27 @@
+class Solution:
+    def findMedianSortedArrays(self, A: List[int], B: List[int]) -> float:
+        if len(A)>len(B): A, B = B, A
+        
+        total = len(A)+len(B)
+        half = total//2
+        l = 0
+        r = len(A)-1
+        
+        while True:
+            i = l + (r-l)//2
+            j = half-(i+1)-1
+            
+            Aleft = A[i] if i>=0 else float('-inf')
+            Aright = A[i+1] if i+1<len(A) else float('inf')
+            Bleft = B[j] if j>=0 else float('-inf')
+            Bright = B[j+1] if j+1<len(B) else float('inf')
+            
+            if Aleft<=Bright and Bleft<=Aright:
+                if total%2==0:
+                    return (max(Aleft, Bleft)+min(Aright, Bright))/2
+                else:
+                    return min(Aright, Bright)
+            elif Aleft>Bright:
+                r = i-1
+            else:
+                l = i+1

problems/python3/time-based-key-value-store.py

@@ -0,0 +1,28 @@
+class TimeMap:
+
+    def __init__(self):
+        self.data = collections.defaultdict(list)
+
+    def set(self, key: str, value: str, timestamp: int) -> None:
+        self.data[key].append((timestamp, value))
+        
+    def get(self, key: str, timestamp: int) -> str:
+        dataList = self.data[key]
+        l = 0
+        r = len(dataList)-1
+        ans = ''
+        
+        while l<=r:
+            m = l + int((r-l)/2)
+            t = dataList[m][0]
+            
+            if t<timestamp:
+                ans = dataList[m][1]
+                l = m+1
+            elif t>timestamp:
+                r = m-1
+            else:
+                ans = dataList[m][1]
+                break
+        
+        return ans