Sourcery refactored main branch

1-Two-Sum.py

@@ -1,7 +1,7 @@
 class Solution:
     def twoSum(self, nums: List[int], target: int) -> List[int]:
         prevMap = {} # val -> index
-        
+
         for i, n in enumerate(nums):
             diff = target - n
             if diff in prevMap:

10-Regular-Expression-Matching.py

@@ -1,20 +1,20 @@
 # BOTTOM-UP Dynamic Programming
 class Solution:
     def isMatch(self, s: str, p: str) -> bool:
-        cache = [[False] * (len(p) + 1) for i in range(len(s) + 1)]
+        cache = [[False] * (len(p) + 1) for _ in range(len(s) + 1)]
         cache[len(s)][len(p)] = True
-        
+
         for i in range(len(s), -1, -1):
             for j in range(len(p) - 1, -1 ,-1):
                 match = i < len(s) and (s[i] == p[j] or p[j] == ".")
-                
+
                 if (j + 1) < len(p) and p[j + 1] == "*":
                     cache[i][j] = cache[i][j + 2]
                     if match:
                         cache[i][j] = cache[i + 1][j] or cache[i][j]
                 elif match:
                     cache[i][j] = cache[i+1][j+1]
-                    
+
         return cache[0][0]
 
 

100-Same-Tree.py

@@ -7,7 +7,12 @@
 
 class Solution:
     def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
-        if not p and not q: return True
-        if p and q and p.val == q.val: 
-            return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
-        else: return False
+        if p or q:
+            return (
+                self.isSameTree(p.left, q.left)
+                and self.isSameTree(p.right, q.right)
+                if p and q and p.val == q.val
+                else False
+            )
+
+        else: return True

102-Binary-Tree-Level-Order-Traversal.py

@@ -10,11 +10,11 @@ def levelOrder(self, root: TreeNode) -> List[List[int]]:
         res = []
         q = collections.deque()
         if root: q.append(root)
-            
+
         while q:
             val = []
-            
-            for i in range(len(q)):
+
+            for _ in range(len(q)):
                 node = q.popleft()
                 val.append(node.val)
                 if node.left: q.append(node.left)

104-Maximum-Depth-of-Binary-Tree.py

@@ -1,20 +1,21 @@
 # RECURSIVE DFS
 class Solution:
     def maxDepth(self, root: TreeNode) -> int:
-        if not root:
-            return 0
-
-        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))
+        return (
+            1 + max(self.maxDepth(root.left), self.maxDepth(root.right))
+            if root
+            else 0
+        )
 
 # ITERATIVE DFS   
 class Solution:
     def maxDepth(self, root: TreeNode) -> int:
         stack = [[root, 1]]
         res = 0
-        
+
         while stack:
             node, depth = stack.pop()
-        
+
             if node:
                 res = max(res, depth)
                 stack.append([node.left, depth + 1])
@@ -26,12 +27,12 @@ class Solution:
     def maxDepth(self, root: TreeNode) -> int:
         if not root:
             return 0
-        
+
         level = 0
         q = deque([root])
         while q:
 
-            for i in range(len(q)):
+            for _ in range(len(q)):
                 node = q.popleft()
                 if node.left:
                     q.append(node.left)

11-Container-With-Most-Water.py

@@ -2,11 +2,11 @@ class Solution:
     def maxArea(self, height: List[int]) -> int:
         l, r = 0, len(height) - 1
         res = 0
-        
+
         while l < r:
             res = max(res, min(height[l], height[r]) * (r - l))
             if height[l] < height[r]:
                 l += 1
-            elif height[r] <= height[l]:
+            else:
                 r -= 1
         return res

1143-Longest-Common-Subsequence.py

@@ -1,12 +1,12 @@
 class Solution:
     def longestCommonSubsequence(self, text1: str, text2: str) -> int:
-        dp = [[0 for j in range(len(text2) + 1)] for i in range(len(text1) + 1)]
-        
+        dp = [[0 for _ in range(len(text2) + 1)] for _ in range(len(text1) + 1)]
+
         for i in range(len(text1) - 1, -1, -1):
             for j in range(len(text2) - 1, -1, -1):
                 if text1[i] == text2[j]:
                     dp[i][j] = 1 + dp[i + 1][j + 1]
                 else:
                     dp[i][j] = max(dp[i][j + 1], dp[i + 1][j])
-        
+
         return dp[0][0]

115-Distinct-Subsequences.py

@@ -1,12 +1,12 @@
 class Solution:
     def numDistinct(self, s: str, t: str) -> int:
         cache = {}
-        
+
         for i in range(len(s) + 1):
             cache[(i, len(t))] = 1
         for j in range(len(t)):
             cache[(len(s), j)] = 0
-        
+
         for i in range(len(s) - 1, -1, -1):
             for j in range(len(t) - 1, -1, -1):
                 if s[i] == t[j]:

121-Best-Time-To-Buy-and-Sell-Stock.py

@@ -1,7 +1,7 @@
 class Solution:
     def maxProfit(self, prices: List[int]) -> int:
         res = 0
-        
+
         l = 0
         for r in range(1, len(prices)):
             if prices[r] < prices[l]:

127-Word-Ladder.py

@@ -2,24 +2,24 @@ class Solution:
     def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
         if endWord not in wordList:
             return 0
-        
+
         nei = collections.defaultdict(list)
         wordList.append(beginWord)
         for word in wordList:
             for j in range(len(word)):
-                pattern = word[:j] + "*" + word[j + 1:]
+                pattern = f"{word[:j]}*{word[j + 1:]}"
                 nei[pattern].append(word)
-        
-        visit = set([beginWord])
+
+        visit = {beginWord}
         q = deque([beginWord])
         res = 1
         while q:
-            for i in range(len(q)):
+            for _ in range(len(q)):
                 word = q.popleft()
                 if word == endWord:
                     return res
                 for j in range(len(word)):
-                    pattern = word[:j] + "*" + word[j + 1:]
+                    pattern = f"{word[:j]}*{word[j + 1:]}"
                     for neiWord in nei[pattern]:
                         if neiWord not in visit:
                             visit.add(neiWord)

128-Longest-consecutive-sequence.py

@@ -2,7 +2,7 @@ class Solution:
     def longestConsecutive(self, nums: List[int]) -> int:
         numSet = set(nums)
         longest = 0
-        
+
         for n in nums:
             # check if its the start of a sequence
             if (n - 1) not in numSet:

138-Copy-List-With-Random-Pointer.py

@@ -10,7 +10,7 @@ def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
 class Solution:
     def copyRandomList(self, head: 'Node') -> 'Node':
         oldToCopy = { None : None }
-        
+
         cur = head
         while cur:
             copy = Node(cur.val)

141-Linked-List-Cycle.py

@@ -7,7 +7,7 @@
 class Solution:
     def hasCycle(self, head: ListNode) -> bool:
         slow, fast = head, head
-        
+
         while fast and fast.next:
             slow = slow.next
             fast = fast.next.next

146-LRU-Cache.py

@@ -8,7 +8,7 @@ class LRUCache:
     def __init__(self, capacity: int):
         self.cap = capacity
         self.cache = {} # map key to node
-        
+
         self.left, self.right = Node(0, 0), Node(0, 0)
         self.left.next, self.right.prev = self.right, self.left
 

15-3Sum.py

@@ -2,11 +2,11 @@ class Solution:
     def threeSum(self, nums: List[int]) -> List[List[int]]:
         res = []
         nums.sort()
-        
+
         for i, a in enumerate(nums):
             if i > 0 and a == nums[i - 1]:
                 continue
-            
+
             l, r = i + 1, len(nums) - 1
             while l < r:
                 threeSum = a + nums[l] + nums[r]

150-Evaluate-Reverse-Polish-Notation.py

@@ -2,13 +2,13 @@ class Solution:
     def evalRPN(self, tokens: List[str]) -> int:
         stack = []
         for c in tokens:
-            if c == "+":
+            if c == "*":
+                stack.append(stack.pop() * stack.pop())
+            elif c == "+":
                 stack.append(stack.pop() + stack.pop())
             elif c == "-":
                 a, b = stack.pop(), stack.pop()
                 stack.append(b - a)
-            elif c == "*":
-                stack.append(stack.pop() * stack.pop())
             elif c == "/":
                 a, b = stack.pop(), stack.pop()
                 stack.append(int(b / a))

152-Maximum-Product-Subarray.py

@@ -3,9 +3,9 @@ def maxProduct(self, nums: List[int]) -> int:
         # O(n)/O(1) : Time/Memory
         res = max(nums)
         curMin, curMax = 1, 1
-        
+
         for n in nums:
-            
+
             tmp = curMax * n
             curMax = max(n * curMax, n * curMin, n) 
             curMin = min(tmp, n * curMin, n)

1584-Min-Cost-to-Connect-all-Points.py

@@ -9,7 +9,7 @@ def minCostConnectPoints(self, points: List[List[int]]) -> int:
                 dist = abs(x1 - x2) + abs(y1 - y2)
                 adj[i].append([dist, j])
                 adj[j].append([dist, i])
-        
+
         # Prim's
         res = 0
         visit = set()

1851-Minimum-Interval-to-Include-Each-Query.py

@@ -9,7 +9,7 @@ def minInterval(self, intervals: List[List[int]], queries: List[int]) -> List[in
                 l, r = intervals[i]
                 heapq.heappush(minHeap, (r - l + 1, r))
                 i += 1
-            
+
             while minHeap and minHeap[0][1] < q:
                 heapq.heappop(minHeap)
             res[q] = minHeap[0][0] if minHeap else -1

199-Binary-Tree-Right-Side-View.py

@@ -8,17 +8,16 @@ class Solution:
     def rightSideView(self, root: TreeNode) -> List[int]:
         res = []
         q = collections.deque([root])
-        
+
         while q:
             rightSide = None
             qLen = len(q)
-
-            for i in range(qLen):
-                node = q.popleft()
-                if node:
+
+            for _ in range(qLen):
+                if node := q.popleft():
                     rightSide = node
                     q.append(node.left)
                     q.append(node.right)
             if rightSide:
-                res.append(rightSide.val) 
+                res.append(rightSide.val)
         return res

2-Add-Two-Numbers.py

@@ -7,18 +7,18 @@ class Solution:
     def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
         dummy = ListNode()
         cur = dummy
-        
+
         carry = 0
         while l1 or l2 or carry:
             v1 = l1.val if l1 else 0
             v2 = l2.val if l2 else 0
-            
+
             # new digit
             val = v1 + v2 + carry
             carry = val // 10
             val = val % 10
             cur.next = ListNode(val)
-            
+
             # update ptrs
             cur = cur.next
             l1 = l1.next if l1 else None

20-Valid-Parentheses.py

@@ -2,13 +2,13 @@ class Solution:
     def isValid(self, s: str) -> bool:
         Map = { ")":"(", "]":"[", "}":"{" }
         stack = []
-        
+
         for c in s:
             if c not in Map:
                 stack.append(c)
                 continue    
             if not stack or stack[-1] != Map[c]:
                 return False
             stack.pop()
-            
+
         return not stack

202-Happy-Number.py

@@ -1,13 +1,13 @@
 class Solution:
     def isHappy(self, n: int) -> bool:
         slow, fast = n, self.sumSquareDigits(n)
-        
+
         while slow != fast:
             fast = self.sumSquareDigits(fast)
             fast = self.sumSquareDigits(fast)
             slow = self.sumSquareDigits(slow)
 
-        return True if fast == 1 else False
+        return fast == 1
 
     def sumSquareDigits(self, n):
         output = 0

208-Implement-Trie.py

@@ -19,7 +19,7 @@ def insert(self, word: str) -> None:
         curr = self.root
         for c in word:
             i = ord(c)-ord("a")
-            if curr.children[i] == None:
+            if curr.children[i] is None:
                 curr.children[i] = TrieNode()
             curr = curr.children[i]
         curr.end = True
@@ -31,7 +31,7 @@ def search(self, word: str) -> bool:
         curr = self.root
         for c in word:
             i = ord(c)-ord("a")
-            if curr.children[i] == None:
+            if curr.children[i] is None:
                 return False
             curr = curr.children[i]
         return curr.end
@@ -43,7 +43,7 @@ def startsWith(self, prefix: str) -> bool:
         curr = self.root
         for c in prefix:
             i = ord(c)-ord("a")
-            if curr.children[i] == None:
+            if curr.children[i] is None:
                 return False
             curr = curr.children[i]
         return True