no message

Author: Chris Wu

problems/container-with-most-water.py

@@ -0,0 +1,33 @@
+"""
+`l` and `r` are the points on width that form the area.
+The height on `l` is `H[l]` and `r` is `H[r]`.
+The area that form by `l` and `r` is `(r-l)*min(H[r], H[l])`.
+
+We are going to calculate the area everytime we move `l` or `r`.
+And maintain the `ans`, which is the max of all area.
+
+Now, we put `l` and `r` at the beginning and at the end of the array.
+We calculate the area and update `ans`, move `l` or `r` inward.
+How are we going to find a larger area with shorter width that form by `l` and `r`?
+The answer is, we move the `l` or `r` with shorter `H[l]` or `H[r]`, so we might get a larger `min(H[r], H[l])`, which leads to possibly larger area.
+
+By doing this, we now have a new pair of `l` and `r`.
+We calculate the area and update `ans`, move `l` or `r` inward.
+
+...
+
+We repeat the process until `l` and `r` collapse.
+So by repeatedly moving `l` and `r` inward, we can run through all the shorter width that might form area larger than `ans`.
+"""
+class Solution(object):
+    def maxArea(self, H):
+        r, l = len(H)-1, 0
+        ans = float('-inf')
+
+        while r>l:
+            ans = max(ans, (r-l)*min(H[r], H[l]))
+            if H[r]>H[l]:
+                l = l+1
+            else:
+                r = r-1
+        return ans

problems/two-sum-ii-input-array-is-sorted.py

@@ -0,0 +1,28 @@
+class Solution(object):
+    def twoSum(self, numbers, target):
+        memo = {}
+        for i, n in enumerate(numbers):
+            if target-n in memo:
+                return [memo[target-n]+1, i+1]
+            memo[n] = i
+
+"""
+We put `l` and `r` at the beginning and at the end of the array.
+Everytime with new pair of `l` and `r`, we check if its sum is target. If true, return the answer.
+If the sum is larger than the target, we need to reduce the sum, and the only way to do that is to move `r` leftward, since `l` is already at the leftmost.
+If the sum is smaller than the target, we need to increase the sum, and the only way to do that is to move `l` rightward, since `r` is already at the rightmost.
+
+The time complexity is O(N).
+The space complexity is O(1).
+"""
+class Solution(object):
+    def twoSum(self, numbers, target):
+        r, l = len(numbers)-1, 0
+        while r>l:
+            if numbers[r]+numbers[l]==target:
+                return [l+1, r+1]
+            elif numbers[r]+numbers[l]>target:
+                r = r-1
+            else:
+                l = l+1
+        return []