no message

Author: Chris Wu

problems/find-and-replace-in-string.py

@@ -0,0 +1,23 @@
+"""
+`p` is the index on s which already processed.
+"""
+class Solution(object):
+    def findReplaceString(self, s, indices, sources, targets):
+        p = -1
+        ans = ''
+        
+        memo = {}
+        for i, index in enumerate(indices):
+            memo[index] = (sources[i], targets[i])
+        
+        for i in xrange(len(s)):
+            if i<=p: continue
+            
+            if i in memo and (s[i:i+len(memo[i][0])] if i+len(memo[i][0])<len(s) else s[i:])==memo[i][0]:
+                ans += memo[i][1]
+                p = i+len(memo[i][0])-1
+            else:
+                ans += s[i]
+                p = i
+            
+        return ans

problems/insert-interval.py

@@ -0,0 +1,20 @@
+class Solution(object):
+    def insert(self, intervals, newInterval):
+        if not intervals: return [newInterval]
+        
+        max_index = float('-inf')
+        min_index = float('inf')
+        s0 = newInterval[0]
+        e0 = newInterval[1]
+        
+        for i, interval in enumerate(intervals):
+            s = interval[0]
+            e = interval[1]
+            
+            if not (newInterval[1]<s or e<newInterval[0]):
+                s0 = min(s0, s)
+                e0 = max(e0, e)
+                max_index = max(max_index, i)
+                min_index = min(min_index, i)
+       
+        return intervals[:min_index]+[[s0, e0]]+intervals[max_index+1:] if min_index!=float('inf') else sorted(intervals+[[s0, e0]])

problems/merge-intervals.py

@@ -14,11 +14,24 @@
 class Solution(object):
     def merge(self, intervals):
         result = []
-        intervals.sort(key=lambda x: x.start) #[1]
+        intervals.sort() #[1]
 
         for inter in intervals:
-            if len(result)>0 and result[-1].end>=inter.start: #[2]
-                result[-1].end = max(result[-1].end, inter.end) #[3]
+            if len(result)>0 and result[-1][1]>=inter[0]: #[2]
+                result[-1][1] = max(result[-1][1], inter[1]) #[3]
             else: #[4]
                 result.append(inter) 
-        return result
+        return result
+        
+
+class Solution(object):
+    def merge(self, intervals):
+        intervals.sort()
+        
+        i = 0
+        while i<len(intervals)-1:
+            if intervals[i][1]>=intervals[i+1][0]:
+                intervals = intervals[:i] + [[min(intervals[i][0], intervals[i+1][0]), max(intervals[i][1], intervals[i+1][1])]] + intervals[i+2:]
+            else:
+                i += 1
+        return intervals

problems/minimum-size-subarray-sum.py

@@ -0,0 +1,20 @@
+"""
+As we move right the i and increament s, if the s >= target, we 
+
+"""
+class Solution(object):
+    def minSubArrayLen(self, target, nums):
+        s = 0
+        l = 0
+        ans = float('inf')
+        
+        for i in xrange(len(nums)):
+            s += nums[i]
+            
+            while s>=target:
+                ans = min(i-l+1, ans)
+                s -= nums[l]
+                l += 1
+        
+        return ans if ans!=float('inf') else 0
+                

problems/partition-labels.py

@@ -0,0 +1,52 @@
+"""
+1. Find each char's ranges. Store into `charRange`.
+2. Merge the ranges. Store into `r`.
+3. Change the `r` format.
+
+For example:
+The input is "ababcbacadefegdehijhklij"
+charRange will be: `{'a': [0, 8], 'c': [4, 7], 'b': [1, 5], 'e': [10, 15], 'd': [9, 14], 'g': [13, 13], 'f': [11, 11], 'i': [17, 22], 'h': [16, 19], 'k': [20, 20], 'j': [18, 23], 'l': [21, 21]}`
+After merging above the range should be `[[0, 8], [9, 15], [16, 23]]`. And store it in `r`: `[8, 15, 23]`.
+`ans` will be `[9,7,8]`
+"""
+class Solution(object):
+    def partitionLabels(self, s):
+        charRange = {}
+        r = []
+        
+        for i, c in enumerate(s):
+            if c not in charRange:
+                charRange[c] = [i, i]
+            else:
+                charRange[c][1] = i
+        
+        for i, c in enumerate(s):
+            if i==0 or charRange[c][0]>r[-1]:
+                r.append(charRange[c][1])
+            else:
+                r[-1] = max(r[-1], charRange[c][1])
+        
+        ans = []
+        for i in xrange(len(r)):
+            if i==0:
+                ans.append(r[i]+1)
+            else:
+                ans.append(r[i]-r[i-1])
+        return ans
+
+"""
+This offical answer is even cleaner.
+"""
+class Solution(object):
+    def partitionLabels(self, s):
+        lastSeen = {}
+        for i, c in enumerate(s): lastSeen[c] = i
+        
+        ans = []
+        start = end = 0
+        for i, c in enumerate(s):
+            end = max(end, lastSeen[c])
+            if i==end:
+                ans.append(end-start+1)
+                start = i+1
+        return ans

problems/product-of-array-except-self.py

@@ -36,4 +36,49 @@ def productExceptSelf(self, nums):
             output[i] = output[i]*t #[5]
             t = t*nums[i] #[4]
 
-        return output
+        return output
+
+"""
+Time: O(N)
+Space: O(N)
+
+left[i] := product of all the element left to nums[i]
+right[i] := product of all the element right to nums[i]
+"""
+class Solution(object):
+    def productExceptSelf(self, nums):
+        N = len(nums)
+        
+        left = [1]*N
+        for i in xrange(1, len(nums)):
+            left[i] = left[i-1] * nums[i-1]
+        
+        right = [1]*N
+        for i in xrange(N-2, -1, -1):
+            right[i] = right[i+1] * nums[i+1]
+        
+        ans = []
+        for i in xrange(N):
+            ans.append(left[i]*right[i])
+        return ans
+
+"""
+Time: O(N)
+Space: O(1)
+"""
+class Solution(object):
+    def productExceptSelf(self, nums):
+        N = len(nums)
+        
+        #[1]
+        opt = [1]*N
+        for i in xrange(1, len(nums)):
+            opt[i] = opt[i-1] * nums[i-1]
+        
+        #[2]
+        t = 1
+        for i in xrange(N-2, -1, -1):
+            t *= nums[i+1]
+            opt[i] *= t
+        
+        return opt

problems/summary-ranges.py

@@ -0,0 +1,18 @@
+"""
+For each iteration, if we found a new starting point we will append previous range to the opt.
+The range start from index s to index i-1.
+"""
+class Solution(object):
+    def summaryRanges(self, nums):
+        nums.append('#')
+        opt = []
+        s = 0
+        
+        for i in xrange(1, len(nums)):
+            if nums[i-1]+1!=nums[i]:
+                if i-1>s:
+                    opt.append(str(nums[s])+'->'+str(nums[i-1]))
+                else:
+                    opt.append(str(nums[s]))
+                s = i
+        return opt