upload on 3/22

Author: gyb1325

164. Maximum Gap.py

@@ -0,0 +1,30 @@
+class Solution:
+
+    def maximumGap(self, nums: List[int]) -> int:
+        n = len(nums)
+        if n <= 1:
+            return 0
+        min_val = min(nums)
+        max_val = max(nums)
+        gap = math.ceil((float)(max_val - min_val) / (n - 1))
+
+        bucket_min = [float("inf")] * (n - 1)
+        bucket_max = [float("-inf")] * (n - 1)
+
+        for num in nums:
+            if num == min_val or num == max_val:
+                continue
+            idx = (num - min_val) // gap
+            bucket_min[idx] = min(bucket_min[idx], num)
+            bucket_max[idx] = max(bucket_max[idx], num)
+        print(bucket_min, bucket_max)
+        prev = min_val
+        max_gap = 0
+        for i in range(n - 1):
+            if bucket_min[i] == float("inf") or bucket_max[i] == float("-inf"):
+                continue
+            max_gap = max(max_gap, bucket_min[i] - prev)
+            prev = bucket_max[i]
+        max_gap = max(max_gap, max_val - prev)
+
+        return max_gap

165. Compare Version Numbers.py

@@ -0,0 +1,27 @@
+class Solution:
+
+    def compareVersion(self, version1: str, version2: str) -> int:
+
+        v1 = version1.split(".")
+        v2 = version2.split(".")
+        v1 = list(map(int, v1))
+        v2 = list(map(int, v2))
+        len1 = len(v1)
+        len2 = len(v2)
+        if len1 > len2:
+            for i in range(len1 - len2):
+                v2 = v2 + [0]
+        else:
+            for i in range(len2 - len1):
+                v1 = v1 + [0]
+        a1 = 0
+        a2 = 0
+        for i in range(len(v1)):
+            a1 = a1 * 10 + v1[i]
+            a2 = a2 * 10 + v2[i]
+        if a1 > a2:
+            return 1
+        elif a1 < a2:
+            return -1
+        else:
+            return 0

167. Two Sum II - Input array is sorted.py

@@ -0,0 +1,13 @@
+class Solution:
+
+    def twoSum(self, numbers: List[int], target: int) -> List[int]:
+        n = len(numbers)
+        s = 0
+        e = n - 1
+        while s < e:
+            if numbers[s] + numbers[e] == target:
+                return [s + 1, e + 1]
+            elif numbers[s] + numbers[e] > target:
+                e -= 1
+            elif numbers[s] + numbers[e] < target:
+                s += 1

70. Climbing Stairs.py

@@ -0,0 +1,19 @@
+class Solution:
+
+    def climbStairs(self, n: int) -> int:
+        # step = [0] * (n+1)
+        # step[0] = 1
+        # step[1] = 1
+        # for i in range(2, n+1):
+        #     step[i] = step[i-1] + step[i-2]
+        # return step[-1]
+        if n == 1:
+            return 1
+        prev = 1
+        prev_prev = 1
+        cur = 0
+        for i in range(2, n + 1):
+            cur = prev + prev_prev
+            prev_prev = prev
+            prev = cur
+        return cur

72. Edit Distance.py

@@ -0,0 +1,17 @@
+class Solution:
+
+    def minDistance(self, word1: str, word2: str) -> int:
+        m = len(word1)
+        n = len(word2)
+        aux = [[0] * (n + 1) for _ in range(m + 1)]
+
+        for i in range(m + 1):
+            aux[i][0] = i
+        for j in range(n + 1):
+            aux[0][j] = j
+
+        for i in range(1, m + 1):
+            for j in range(1, n + 1):
+                step = int(word1[i - 1] != word2[j - 1])
+                aux[i][j] = min(1 + aux[i - 1][j], 1 + aux[i][j - 1], step + aux[i - 1][j - 1])
+        return aux[-1][-1]

73. Set Matrix Zeroes.py

@@ -0,0 +1,26 @@
+class Solution:
+
+    def setZeroes(self, matrix: List[List[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        m = len(matrix)
+        if m == 0:
+            reutrn
+        n = len(matrix[0])
+
+        setr = set()
+        setc = set()
+
+        for i in range(m):
+            for j in range(n):
+                if matrix[i][j] == 0:
+                    setr.add(i)
+                    setc.add(j)
+        for item in setr:
+            for c in range(n):
+                matrix[item][c] = 0
+
+        for item in setc:
+            for r in range(m):
+                matrix[r][item] = 0

74. Search a 2D Matrix.py

@@ -0,0 +1,33 @@
+class Solution:
+
+    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
+        m = len(matrix)
+        if m == 0:
+            return False
+        n = len(matrix[0])
+
+        if n == 0:
+            return False
+        row = []
+        for i in range(m):
+            row.append(matrix[i][0])
+
+        # row search
+        idx, flag = self.helper(row, 0, m - 1, target)
+        if flag:
+            return True
+
+        idx, flag = self.helper(matrix[idx], 0, n - 1, target)
+
+        return flag
+
+    def helper(self, lst, start, end, target):
+        if start > end:
+            return start - 1, False
+        mid = (start + end) // 2
+        if target == lst[mid]:
+            return mid, True
+        if target > lst[mid]:
+            return self.helper(lst, mid + 1, end, target)
+        else:
+            return self.helper(lst, start, mid - 1, target)

75. Sort Colors.py

@@ -0,0 +1,18 @@
+class Solution:
+
+    def sortColors(self, nums: List[int]) -> None:
+        """
+        Do not return anything, modify nums in-place instead.
+        """
+        l, r, ptr = 0, len(nums) - 1, 0
+
+        while ptr <= r:
+            if nums[ptr] == 0:
+                nums[l], nums[ptr] = nums[ptr], nums[l]
+                l += 1
+                ptr += 1
+            elif nums[ptr] == 2:
+                nums[r], nums[ptr] = nums[ptr], nums[r]
+                r -= 1
+            else:
+                ptr += 1