no message

Author: Chris Wu

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

@@ -34,3 +34,42 @@ def findMin(self, nums):
                 else:
                     break
         return m
+
+
+
+"""
+Pointer l and r is at the start and at the end of the list. [0]
+We only consider the numbers between l and r.
+
+If the list is already sorted, return the left most element. [1]
+
+Now, we cut the rotated array into half. l~m and m~r.
+Normally, one part will be sorted, the other half is not.
+The min must be in the unsorted part.
+So we move the pointer and do the same thing on the unsorted part. [2]
+
+One scenario to consider is that the cutting point, m, being the smallest element.
+This will cause both l~m and m~r to both be sorted.
+So we need to check it. [3]
+
+Time: O(LogN)
+Space: O(1)
+"""
+
+class Solution(object):
+    def findMin(self, nums):
+        if not nums: return 0
+        l = 0 #[0]
+        r = len(nums)-1 #[0]
+
+        while l<=r:
+            if nums[l]<=nums[r]: return nums[l] #[1]
+            
+            m = (l+r)/2
+            if m-1>=0 and nums[m-1]>nums[m]: return nums[m] #[3]
+            
+            if nums[l]<=nums[m]:
+                l = m+1 #[2]
+            else:
+                r = m-1 #[2]
+        return 0

problems/find-peak-element.py

@@ -30,3 +30,29 @@ def findPeakElement(self, nums):
             r = nums[i+1] if (i+1)<len(nums) else float('-inf')
             if nums[i]>l and nums[i]>r: return i
         return None
+
+
+#2020/7/23
+class Solution(object):
+    def findPeakElement(self, nums):
+        l = 0
+        r = len(nums)-1
+        
+        while l<=r:
+            if l==r: return l
+            if nums[l]>nums[l+1]: return l #check l is peak
+            if nums[r-1]<nums[r]: return r #check r is peak
+            
+            m = (l+r)/2
+            
+            if nums[m]<nums[m+1]:
+                #m is in the falling slope
+                l = m
+            elif nums[m]>nums[m+1]:
+                #m is in the rising slope
+                r = m
+        return l
+                
+                
+            
+        

problems/search-in-rotated-sorted-array-ii.py

@@ -35,3 +35,38 @@ def search(self, nums, t):
                     r = r-1
                     l = l+1
         return False
+
+
+#2020/7/20, recursive.
+class Solution(object):
+    def search(self, nums, target):
+        def binary_search(l, r):
+            if l>r: return False
+            if nums[l]==target: return True
+            if nums[r]==target: return True
+
+            m = (l+r)/2
+            if nums[m]==target:
+                return m
+            if target<nums[m]:
+                return binary_search(l, m-1)
+            else:
+                return binary_search(m+1, r)
+        
+            if not nums: return False
+        
+        def helper(l, r):
+            if l>r: return False
+            if nums[l]==target: return True
+            if nums[r]==target: return True
+            if nums[l]<nums[r]: return binary_search(l+1, r-1)
+            
+            m = (l+r)/2
+            if nums[m]==target: return m
+
+            if helper(l+1, m-1): return True
+            if helper(m+1, r-1): return True
+            return False
+        
+        if not nums: return False
+        return helper(0, len(nums)-1)

problems/search-in-rotated-sorted-array.py

@@ -131,3 +131,46 @@ def search(self, nums, target):
 
 
 
+
+
+
+#2020/7/20, recursive.
+class Solution(object):
+    def search(self, nums, target):
+        def binary_search(l, r):
+            if l>r: return -1
+            if nums[l]==target: return l
+            if nums[r]==target: return r
+
+            m = (l+r)/2
+            if nums[m]==target:
+                return m
+            if target<nums[m]:
+                return binary_search(l, m-1)
+            else:
+                return binary_search(m+1, r)
+
+        if not nums: return -1
+
+        def helper(l, r):
+            if l>r: return -1
+            if nums[l]==target: return l
+            if nums[r]==target: return r
+            if nums[l]<=nums[r]: return binary_search(l+1, r-1)
+            
+            m = (l+r)/2
+            if nums[m]==target: return m
+
+            if nums[l]<nums[m]:
+                if nums[l]<target and target<nums[m]:
+                    return binary_search(l+1, m-1)
+                else:
+                    return helper(m+1, r)
+            else:
+                if nums[m]<target and target<nums[r]:
+                    return binary_search(m+1, r-1)
+                else:
+                    return helper(l, m-1)
+        
+        if not nums: return -1
+        return helper(0, len(nums)-1)

problems/sqrtx.py

@@ -25,3 +25,28 @@ def isAns(a):
             else:
                 r = m-1
         return -1
+
+
+"""
+The answer must always be in l~r.
+In every iteration, we test the m, `m_sqr==x or (m_sqr<x and x<(m+1)**2)`.
+If not the answer, we adjust l or r.
+
+Time complexity: O(LogN).
+Space complexity: O(1).
+"""
+class Solution(object):
+    def mySqrt(self, x):
+        l = 0
+        r = x
+        
+        while l<=r:
+            m = (l+r)/2
+            m_sqr = m**2
+            
+            if m_sqr==x or (m_sqr<x and x<(m+1)**2):
+                return m
+            elif m_sqr<x:
+                l = m+1
+            else:
+                r = m-1

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

@@ -1,25 +1,3 @@
-"""
-We need a hash-table to store the key-value information.
-For every key, there are multiple values and we need it to sort by`timestamp`.
-
-First, we use two array, `t` and `v` to store timestamp and value separately.
-And becuase the problem says **The timestamps for all TimeMap.set operations are strictly increasing.**
-So for the `set()` method, we only need to simply append `value` and `timestamp` to the end of `v` and `t`.
-The array `t` and its corresponding `v` is sorted already.
-
-[bisect](https://docs.python.org/2/library/bisect.html) can help us implement our `get()` method.
-It returns an insertion point which comes after (to the right of) any existing entries, if we insert the **`timestamp` we are going to get()** into a the array, `t`.
-So `bisect(t, timestamp)` returns `i`:
-    * If `i==0`: it means that there are no value samller than the `timestamp`, `return ""`.
-    * If `i>0`: it means `i` is the index where its value just exceed the `timestamp`, return the value at `i-1`.
-
-We can also implement our own `bisect` by binary search.
-The implementation assume there are no duplicate value in the array.
-
-Time Complexity, O(1) for `set()`. O(LogN) for `get()`.
-Space complexity is O(N)
-N is the number of value stored.
-"""
 import collections
 import bisect
 
@@ -74,6 +52,29 @@ def bisect(self, A, x):
                 l = p+1
         return l
 
+"""
+We need a hash-table to store the key-value information.
+For every key, there are multiple values and we need it to sort by`timestamp`.
+
+First, we use two array, `t` and `v` to store timestamp and value separately.
+And becuase the problem says **The timestamps for all TimeMap.set operations are strictly increasing.**
+So for the `set()` method, we only need to simply append `value` and `timestamp` to the end of `v` and `t`.
+The array `t` and its corresponding `v` is sorted already.
+
+[bisect](https://docs.python.org/2/library/bisect.html) can help us implement our `get()` method.
+It returns an insertion point which comes after (to the right of) any existing entries, if we insert the **`timestamp` we are going to get()** into a the array, `t`.
+So `bisect(t, timestamp)` returns `i`:
+    * If `i==0`: it means that there are no value samller than the `timestamp`, `return ""`.
+    * If `i>0`: it means `i` is the index where its value just exceed the `timestamp`, return the value at `i-1`.
+
+We can also implement our own `bisect` by binary search.
+The implementation assume there are no duplicate value in the array.
+
+Time Complexity, O(1) for `set()`. O(LogN) for `get()`.
+Space complexity is O(N)
+N is the number of value stored.
+"""
+
 t = TimeMap()
 t.set('love', 'low', 10)
 t.set('love', 'high', 20)
@@ -85,3 +86,49 @@ def bisect(self, A, x):
 
 
 
+#2020/7/20
+from collections import defaultdict
+class TimeMap(object):
+
+    def __init__(self):
+        self.v = defaultdict(list)
+        self.t = defaultdict(list)
+        
+
+    def set(self, key, value, timestamp):
+        self.v[key].append(value)
+        self.t[key].append(timestamp)
+        
+
+    def get(self, key, timestamp):
+        if key not in self.t: return ""
+        i = self.bisect(self.t[key], timestamp)
+        return self.v[key][i-1] if i>0 else ""
+    
+
+    #return an insertion point right to an index
+    #where the target's value just exceed the index's value
+    def bisect(self, L, target): 
+        if not L: return 0
+
+        l = 0
+        r = len(L)-1
+
+        while l<=r:
+            if target<L[l]: return l
+            if target==L[l]: return l+1
+            if target>=L[r]: return r+1
+            
+            m = (l+r)/2
+
+            if target==L[m]:
+                return m+1
+            elif target<L[m]:
+                r = m-1
+            else:
+                l = m+1
+        return 0
+"""
+Time Complexity: set(), O(1). get(), O(LogN).
+Space Complexity: O(N).
+"""