:squirrel:

angelgladin · angelgladin · commit 228c8b0024ad · 2020-02-19T04:13:20.000-06:00
diff --git a/add-strings.py b/add-strings.py
@@ -0,0 +1,29 @@
+# 415. Add Strings
+# https://leetcode.com/problems/add-strings/
+
+class Solution:
+    def addStrings(self, num1: str, num2: str) -> str:
+        n1, n2 = len(num1), len(num2)
+        i, j = n1-1, n2-1
+        carry = 0
+        ans = []
+        while i >= 0 or j >= 0:
+            s = carry
+            if i >= 0:
+                s += int(num1[i])
+                i -= 1
+            if j >= 0:
+                s += int(num2[j])
+                j -= 1
+
+            if s > 9:
+                carry = 1
+            else:
+                carry = 0
+            
+            ans.append(str(s%10))
+
+        if carry == 1:
+            ans.append('1')
+        
+        return ''.join(ans[::-1])
diff --git a/best-time-to-buy-and-sell-stock.py b/best-time-to-buy-and-sell-stock.py
@@ -0,0 +1,11 @@
+# 121. Best Time to Buy and Sell Stock
+# https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        min_price = float('inf')
+        max_profit = 0
+        for x in prices:
+            min_price = min(x, min_price)
+            max_profit = max(max_profit, x - min_price)
+        return max_profit
diff --git a/binary-tree-right-side-view.py b/binary-tree-right-side-view.py
@@ -0,0 +1,34 @@
+# 199. Binary Tree Right Side View
+# https://leetcode.com/problems/binary-tree-right-side-view/
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def rightSideView(self, root: TreeNode) -> List[int]:
+        if not root:
+            return []
+
+        levels = []
+        sublevel = []
+        q = [root, None]
+        while q:
+            val = q.pop(0)
+            if val == None:
+                # If sublevel it's empty means that we've reach the end
+                if sublevel: 
+                    q.append(None)
+                    levels.append(sublevel[:])
+                    sublevel.clear()
+            else:
+                sublevel.append(val.val)
+                if val.left:
+                    q.append(val.left)
+                if val.right:
+                    q.append(val.right)
+            
+        return [x[-1] for x in levels]
diff --git a/clone-graph.py b/clone-graph.py
@@ -0,0 +1,29 @@
+# 133. Clone Graph
+# https://leetcode.com/problems/clone-graph/
+
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val = 0, neighbors = []):
+        self.val = val
+        self.neighbors = neighbors
+"""
+class Solution:
+    def cloneGraph(self, node: 'Node') -> 'Node':
+        if not node:
+            return None
+        
+        f = {}
+        q = [node]
+        
+        f[node] = Node(node.val, [])
+        
+        while q:
+            u = q.pop(0)
+            for v in u.neighbors:
+                if v not in f:
+                    f[v] = Node(v.val, [])
+                    q.append(v)
+                f[u].neighbors.append(f[v])
+        
+        return f[node]
diff --git a/continuous-subarray-sum.py b/continuous-subarray-sum.py
@@ -0,0 +1,16 @@
+# 523. Continuous Subarray Sum
+# https://leetcode.com/problems/continuous-subarray-sum/
+
+class Solution:
+    def checkSubarraySum(self, nums: List[int], k: int) -> bool:
+        n = len(nums)
+        dp = [0]*n
+        dp[0] = nums[0]
+        for i in range(1, n):
+            dp[i] = dp[i-1] + nums[i]
+        for i in range(n-1):
+            for j in range(i+1, n):
+                sum_ = dp[j] - dp[i] + nums[i]
+                if sum_ == k or (k != 0 and sum_ % k == 0):
+                    return True
+        return False
diff --git a/copy-list-with-random-pointer.py b/copy-list-with-random-pointer.py
@@ -0,0 +1,33 @@
+# 138. Copy List with Random Pointer
+# https://leetcode.com/problems/copy-list-with-random-pointer/
+
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
+        self.val = int(x)
+        self.next = next
+        self.random = random
+"""
+class Solution:
+    def copyRandomList(self, head: 'Node') -> 'Node':
+        if not head:
+            return None
+        
+        p = head
+        mapping = dict()
+        
+        while p:
+            mapping[p] = Node(p.val)
+            p = p.next
+        
+        p = head
+        
+        while p:
+            aux = mapping[p]
+            aux.next = mapping.get(p.next, None)
+            aux.random = mapping.get(p.random, None)
+            
+            p = p.next
+            
+        return mapping[head]
diff --git a/decode-ways.py b/decode-ways.py
@@ -0,0 +1,22 @@
+# 91. Decode Ways
+# https://leetcode.com/problems/decode-ways/
+
+class Solution:
+    def numDecodings(self, s: str) -> int:
+        def aux(s, dp, i, n):
+            if i == n:
+                return 1
+            elif i > n:
+                return 0
+            if dp[i] == -1:
+                c = 0
+                if s[i] != 0:
+                    c += aux(s, dp, i+1, n)
+                if i+1 < n and (s[i] == 1 or (s[i] == 2 and s[i+1] < 7)):
+                    c += aux(s, dp, i+2, n)
+                dp[i] = c
+            return dp[i]
+        n = len(s)
+        dp = [-1]*n
+        nums = [int(x) for x in s]
+        return aux(nums, dp, 0, n)
diff --git a/find-first-and-last-position-of-element-in-sorted-array.py b/find-first-and-last-position-of-element-in-sorted-array.py
@@ -0,0 +1,25 @@
+# 34. Find First and Last Position of Element in Sorted Array
+# https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/
+
+class Solution:
+    def searchRange(self, nums: List[int], target: int) -> List[int]:
+        def binary_search_mod(start, end, target, nums, first):
+            ans = -1
+            while start < end:
+                m = start + (end-start)//2
+                if nums[m] == target:
+                    ans = m
+                    if first:
+                        end = m
+                    else:
+                        start = m+1
+                elif nums[m] < target:
+                    start = m+1
+                else:
+                    end = m
+            return ans
+
+        n = len(nums)
+        fst = binary_search_mod(0, n, target, nums, True)
+        snd = binary_search_mod(0, n, target, nums, False)
+        return [fst, snd]
diff --git a/find-the-duplicate-number.py b/find-the-duplicate-number.py
@@ -0,0 +1,10 @@
+# 287. Find the Duplicate Number
+# https://leetcode.com/problems/find-the-duplicate-number/
+
+class Solution:
+    def findDuplicate(self, nums: List[int]) -> int:
+        nums.sort()
+        for i in range(len(nums)-1):
+            if nums[i] == nums[i+1]:
+                return nums[i]
+        return -1
diff --git a/maximum-swap.py b/maximum-swap.py
@@ -0,0 +1,23 @@
+# 670. Maximum Swap
+# https://leetcode.com/problems/maximum-swap/
+
+class Solution:
+    def maximumSwap(self, num: int) -> int:
+        l = [int(x) for x in str(num)]
+        max_so_far = (-1, -1,)
+        candidate = (-1, -1,)
+        
+        for i in range(len(l)-1, -1, -1):
+            if l[i] > max_so_far[0]:
+                max_so_far = (l[i], i,)
+            elif l[i] < max_so_far[0]:
+                candidate = (max_so_far[1], i,)
+        
+        if candidate[0] == -1:
+            return num
+        
+        aux = l[candidate[0]]
+        l[candidate[0]] = l[candidate[1]]
+        l[candidate[1]] = aux
+        
+        return int(''.join(map(str, l)))
diff --git a/multiply-strings.py b/multiply-strings.py
@@ -0,0 +1,22 @@
+# 43. Multiply Strings
+# https://leetcode.com/problems/multiply-strings/
+
+class Solution:
+    def multiply(self, num1: str, num2: str) -> str:
+        n, m = len(num1), len(num2)
+        ans = [0]*(n+m)
+        for i in range(n-1, -1, -1):
+            for j in range(m-1, -1, -1):
+                prod = int(num1[i]) * int(num2[j])
+                sum_ = ans[i+j+1] + prod
+                carry = sum_ // 10
+                ans[i+j+1] = sum_%10
+                ans[i+j] += carry
+        s = ''
+        for x in ans:
+            if len(s) != 0 or x != 0:
+                s += str(x)
+        if len(s) == 0:
+            return '0'
+        else:
+            return s
diff --git a/number-of-1-bits.py b/number-of-1-bits.py
@@ -0,0 +1,13 @@
+# 191. Number of 1 Bits
+# https://leetcode.com/problems/number-of-1-bits/
+
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        mask = (1<<32)-1
+        flag = 1
+        ans = 0
+        for i in range(32):
+            if flag & n:
+                ans += 1
+            flag <<= 1
+        return ans
diff --git a/range-sum-query-2d-immutable.py b/range-sum-query-2d-immutable.py
@@ -0,0 +1,40 @@
+# 304. Range Sum Query 2D - Immutable
+# https://leetcode.com/problems/range-sum-query-2d-immutable/
+
+class NumMatrix:
+
+    def __init__(self, matrix: List[List[int]]):
+        if len(matrix) == 0:
+            return
+        self.m = matrix
+        
+        c, r = len(self.m), len(self.m[0])
+        
+        dp = [[0]*r for _ in range(c)]
+        dp[0][0] = self.m[0][0]
+        
+        for i in range(1, r):
+            dp[0][i] = dp[0][i-1] + self.m[0][i]
+        for i in range(1,c):
+            dp[i][0] = dp[i-1][0] + self.m[i][0]
+            
+        for i in range(1, c):
+            for j in range(1, r):
+                dp[i][j] = dp[i-1][j] + dp[i][j-1] - dp[i-1][j-1] + self.m[i][j]
+        
+        self.dp = dp
+
+    def sumRegion(self, row1: int, col1: int, row2: int, col2: int) -> int:
+        ans = self.dp[row2][col2]
+        if row1-1 >= 0 and col1-1 >= 0:
+            ans += self.dp[row1-1][col1-1]
+        if col1-1 >= 0:
+            ans -= self.dp[row2][col1-1]
+        if row1-1 >= 0:
+            ans -= self.dp[row1-1][col2]
+        return ans        
+
+
+# Your NumMatrix object will be instantiated and called as such:
+# obj = NumMatrix(matrix)
+# param_1 = obj.sumRegion(row1,col1,row2,col2)
diff --git a/read-n-characters-given-read4.py b/read-n-characters-given-read4.py
@@ -0,0 +1,40 @@
+# 157. Read N Characters Given Read4
+# https://leetcode.com/problems/read-n-characters-given-read4/
+
+"""
+The read4 API is already defined for you.
+
+    @param buf, a list of characters
+    @return an integer
+    def read4(buf):
+
+# Below is an example of how the read4 API can be called.
+file = File("abcdefghijk") # File is "abcdefghijk", initially file pointer (fp) points to 'a'
+buf = [' '] * 4 # Create buffer with enough space to store characters
+read4(buf) # read4 returns 4. Now buf = ['a','b','c','d'], fp points to 'e'
+read4(buf) # read4 returns 4. Now buf = ['e','f','g','h'], fp points to 'i'
+read4(buf) # read4 returns 3. Now buf = ['i','j','k',...], fp points to end of file
+"""
+class Solution:
+    def read(self, buf, n):
+        """
+        :type buf: Destination buffer (List[str])
+        :type n: Number of characters to read (int)
+        :rtype: The number of actual characters read (int)
+        """
+        # Pointer of the current position in `buf`
+        idx = 0
+        # Auxiliary array for storing the the characters read by read4
+        tmp_buffer = ['']*4
+        # While there are characters to read
+        while n > 0:
+            chars_read = read4(tmp_buffer)
+            # read4 function has not read anything
+            if chars_read == 0:
+                return idx
+            # Hold two cases, write the characters in buffer array or read up to n chars
+            for i in range(min(chars_read, n)):
+                buf[idx] = tmp_buffer[i]
+                idx += 1
+                n -= 1
+        return idx
diff --git a/serialize-and-deserialize-binary-tree.py b/serialize-and-deserialize-binary-tree.py
diff --git a/single-number.py b/single-number.py
diff --git a/string-to-integer-atoi.py b/string-to-integer-atoi.py
diff --git a/swap-nodes-in-pairs.py b/swap-nodes-in-pairs.py
