no message

Author: Chris Wu

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

@@ -44,7 +44,7 @@ def findMin(self, nums):
 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.
+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]
 
@@ -72,4 +72,39 @@ def findMin(self, nums):
                 l = m+1 #[2]
             else:
                 r = m-1 #[2]
-        return 0
+        return 0
+
+
+#2021/7/18
+"""
+Pointer l and r is at the start and at the end of the list.
+We only consider the numbers between l and r.
+
+If the list is already sorted, return the left most element. [0]
+If the list is unsorted, one of the part l~m or m~r will be sorted and the other will be unsorted.
+
+The MIN will be in the unsorted part.
+Adjust l and r and repeat the above process.
+
+Time: Log(N)
+Space: O(1)
+"""
+class Solution(object):
+    def findMin(self, nums):
+        N = len(nums)
+        
+        l = 0
+        r = N-1
+        
+        while l<=r:
+            m = (l+r)/2
+            
+            if nums[l]<=nums[m] and nums[m]<=nums[r]: return nums[l] #[0]
+            
+            if nums[l]>nums[m]:
+                #l~m is unsorted
+                r = m
+            else:
+                #m~r is unsorted
+                #in this case, we already sure that current m is not the MIN, so we can +1 to speed up and avoid infinitive loop
+                l = m+1

problems/longest-common-prefix.py

@@ -21,4 +21,20 @@ def longestCommonPrefix(self, strs):
             for s in strs:
                 if s[:i]!=common_substring: #[2]
                     return bench_mark[:i-1]
-        return bench_mark #[3]
+        return bench_mark #[3]
+
+# 2021/7/10
+class Solution(object):
+    def longestCommonPrefix(self, strs):
+        j = 0
+        minLen = float('inf')
+        for s in strs: minLen = min(minLen, len(s))
+        if minLen==float('inf'): return ""
+        
+        while j<minLen:
+            c = strs[0][j]
+            for i in xrange(1, len(strs)):
+                if strs[i][j]!=c: return strs[i][:j]
+            j += 1
+            
+        return strs[0][:j]

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

@@ -24,7 +24,7 @@
 ```python
 max_left_A<=min_right_B and max_left_B<=min_right_A
 ```
-And if `min_right_B<max_left_A`, it means that `i` is too large, so we adjust the upper limit of `i`, that is `h = i-1`.
+And if `min_right_B<max_left_A`, it means that `i` is too large, so we adjust the upper limit of `i`, that is `r = i-1`.
 Otherwise it means that `i` is too small, so we adjust the lower limit of `i`, that is `l = i+1`.
 
 Edge cases.
@@ -55,10 +55,10 @@ def findMedianSortedArrays(self, A, B):
         if len(A)>len(B): A, B = B, A #[0]
 
         M, N = len(A), len(B)
-        l, h = 0, M
+        l, r = 0, M
 
-        while l<=h:
-            i = (h+l)/2
+        while l<=r:
+            i = (r+l)/2
             j = (M+N)/2-i #[1]
 
             max_left_A = A[i-1] if i>0 else float('-inf') #[2]
@@ -73,7 +73,7 @@ def findMedianSortedArrays(self, A, B):
                 else:
                     return min(min_right_A, min_right_B) #[1]
             elif min_right_B<max_left_A:
-                h = i-1
+                r = i-1
             else:
                 l = i+1
         return None
@@ -130,12 +130,12 @@ def findMedianSortedArrays(self, X, Y):
         M, N = len(X), len(Y)
 
         after = (M+N-1)/2
-        l, h = 0, M
+        l, r = 0, M
 
-        while l<h:
-            i = (l+h)/2
+        while l<r:
+            i = (l+r)/2
             if after-i-1 < 0 or X[i] >= Y[after-i-1]:
-                h = i
+                r = i
             else:
                 l = i + 1
         i = l

problems/next-permutation.py

@@ -0,0 +1,32 @@
+"""
+This answer is the python version of the offical answer.
+
+Time: O(N)
+Space: O(1)
+"""
+class Solution(object):
+    def nextPermutation(self, nums):
+        def reverse(start):
+            end = len(nums)-1
+            
+            while start<end:
+                swap(start, end)
+                start += 1
+                end -= 1
+        
+        def swap(i, j):
+            nums[i], nums[j] = nums[j], nums[i]
+        
+        
+        i = len(nums)-2
+        
+        while i>=0 and nums[i+1]<=nums[i]:
+            i -= 1
+        
+        if i>=0:
+            j = len(nums)-1
+            while nums[j]<=nums[i]: j -= 1
+            swap(i, j)
+        
+        reverse(i+1)
+        return nums

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

@@ -69,4 +69,63 @@ def helper(l, r):
             return False
 
         if not nums: return False
-        return helper(0, len(nums)-1)
+        return helper(0, len(nums)-1)
+
+
+"""
+Time: O(LogN). Worse Case: O(N).
+Space: O(1)
+
+The key idea for most rotated array question is that
+If you cut the array into half,
+One of the half will be rotated and one half will be in-order.
+OR
+Both of them are in-order (if you are lucky)
+"""
+class Solution(object):
+    def search(self, A, T):
+        N = len(A)
+        l = 0
+        r = N-1
+        
+        while l<=r:
+
+            #skip repeated numbers
+            while r>0 and A[r]==A[r-1]: r -= 1
+            while l<N-1 and A[l]==A[l+1]: l += 1
+            while r>0 and A[l]==A[r]: r -= 1
+            while l<N-1 and A[l]==A[r]: l += 1
+            
+            m = (l+r)/2
+            
+            if A[l]==T or A[m]==T or A[r]==T: return True
+            
+            if A[l]<=A[m] and A[m]<=A[r]:
+                #l~r is in-order, standard binary search.
+                if T<A[l] or T>A[r]: return False #out of range l~r
+                
+                if A[m]<T:
+                    l = m+1
+                else:
+                    r = m-1
+            elif A[l]<=A[m]:
+                #l~m is in-order
+
+                if A[l]<T and T<A[m]:
+                    #T is in l~m, so search in l~m
+                    r = m-1
+                else:
+                    #T is not in l~m, so search in m~r
+                    l = m+1
+            else:
+                #m~r is in-order
+
+                if A[m]<T and T<A[r]:
+                    #T is in m~r, so search m~r
+                    l = m+1
+                else:
+                    #T is not in m~r, so search in l~m
+                    r = m-1
+        
+        return False
+        

problems/search-insert-position.py

@@ -76,6 +76,44 @@ def searchInsert(self, nums, target):
         return 0
 
 
+#2021/7/17
+"""
+Time: O(logN)
+Space: O(1)
+"""
+class Solution(object):
+    def searchInsert(self, A, T):
+        if not A: return 0
+        
+        N = len(A)
+        r = N-1
+        l = 0
 
+        #we are going to check the element within l and r by constantly narrow down l and r.z 
+        while l<=r:
+            m = (l+r)/2
+            
+            if A[l]==T: return l
+            if A[m]==T: return m
+            if A[r]==T: return r
+            
+            #check if the target is out of range.
+            if A[r]<T: return r+1
+            if T<A[l]: return l
+            
+            #using `m` to navigate `l` and `r`.
+            #if the value on the pivot is larger then the target, we search the left-half.
+            #if the value on the pivot is smaller then the target, we search the right-half.
+            if T<A[m]:
+                r = m-1
+            else:
+                l = m+1
+        
+        return "Error"
+
+
+class Solution(object):
+    def searchInsert(self, A, T):
+        return bisect.bisect_left(A, T)