🎨 Format files (🛠️ from Github Actions)

Author: Ahmad-A0

1-Two-Sum.py

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

10-Regular-Expression-Matching.py

@@ -3,43 +3,44 @@ class Solution:
     def isMatch(self, s: str, p: str) -> bool:
         cache = [[False] * (len(p) + 1) for i 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):
+            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]
-                    
+                    cache[i][j] = cache[i + 1][j + 1]
+
         return cache[0][0]
-        
-        
+
+
 # TOP DOWN MEMOIZATION
 class Solution:
     def isMatch(self, s: str, p: str) -> bool:
         cache = {}
-        
+
         def dfs(i, j):
             if (i, j) in cache:
                 return cache[(i, j)]
             if i >= len(s) and j >= len(p):
                 return True
             if j >= len(p):
                 return False
-            
+
             match = i < len(s) and (s[i] == p[j] or p[j] == ".")
             if (j + 1) < len(p) and p[j + 1] == "*":
-                cache[(i, j)] = (dfs(i, j + 2) or                # dont use *
-                                 (match and dfs(i + 1, j)))       # use *
+                cache[(i, j)] = dfs(i, j + 2) or (  # dont use *
+                    match and dfs(i + 1, j)
+                )  # use *
                 return cache[(i, j)]
             if match:
-                cache[(i,j)] = dfs(i + 1, j + 1)
-                return cache[(i,j)]
-            cache[(i,j)] = False
+                cache[(i, j)] = dfs(i + 1, j + 1)
+                return cache[(i, j)]
+            cache[(i, j)] = False
             return False
-        
+
         return dfs(0, 0)

100-Same-Tree.py

@@ -5,9 +5,12 @@
 #         self.left = None
 #         self.right = None
 
+
 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: 
+        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
+        else:
+            return False

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

@@ -5,19 +5,23 @@
 #         self.left = None
 #         self.right = None
 
+
 class Solution:
     def levelOrder(self, root: TreeNode) -> List[List[int]]:
         res = []
         q = collections.deque()
-        if root: q.append(root)
-            
+        if root:
+            q.append(root)
+
         while q:
             val = []
-            
+
             for i in range(len(q)):
                 node = q.popleft()
                 val.append(node.val)
-                if node.left: q.append(node.left)
-                if node.right: q.append(node.right)
+                if node.left:
+                    q.append(node.left)
+                if node.right:
+                    q.append(node.right)
             res.append(val)
         return res

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

@@ -3,34 +3,36 @@ class Solution:
     def maxDepth(self, root: TreeNode) -> int:
         if not root:
             return 0
-        
+
         return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))
 
-# ITERATIVE DFS   
+
+# 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])
                 stack.append([node.right, depth + 1])
         return res
 
+
 # BFS
 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)):
                 node = q.popleft()
                 if node.left:

1046-Last-Stone-Weight.py

@@ -2,12 +2,12 @@ class Solution:
     def lastStoneWeight(self, stones: List[int]) -> int:
         stones = [-s for s in stones]
         heapq.heapify(stones)
-        
+
         while len(stones) > 1:
             first = heapq.heappop(stones)
             second = heapq.heappop(stones)
             if second > first:
                 heapq.heappush(stones, first - second)
-        
+
         stones.append(0)
         return abs(stones[0])

105-Construct-Binary-Tree-from-Preorder-and-Inorder-Traversal.py

@@ -1,17 +1,19 @@
 class Solution:
     def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
         inorder_index_mapping = {}
-        for k,v in enumerate(inorder):
+        for k, v in enumerate(inorder):
             inorder_index_mapping[v] = k
         index = 0
-        def buildtree(left,right):
+
+        def buildtree(left, right):
             nonlocal index
-            if left>right:
+            if left > right:
                 return None
-            root_val=preorder[index]
+            root_val = preorder[index]
             root = TreeNode(root_val)
-            index+=1
-            root.left = buildtree(left, inorder_index_mapping[root_val]-1)
-            root.right = buildtree(inorder_index_mapping[root_val]+1, right)
+            index += 1
+            root.left = buildtree(left, inorder_index_mapping[root_val] - 1)
+            root.right = buildtree(inorder_index_mapping[root_val] + 1, right)
             return root
-        return buildtree(0, len(preorder)-1)
+
+        return buildtree(0, len(preorder) - 1)

11-Container-With-Most-Water.py

@@ -2,7 +2,7 @@ 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]:

110-Balanced-Binary-Tree.py

@@ -6,12 +6,12 @@
 #         self.right = right
 class Solution:
     def isBalanced(self, root: Optional[TreeNode]) -> bool:
-        
         def dfs(root):
-            if not root: return [True, 0]
-            
+            if not root:
+                return [True, 0]
+
             left, right = dfs(root.left), dfs(root.right)
-            balanced = (left[0] and right[0] and 
-                        abs(left[1] - right[1]) <= 1)
+            balanced = left[0] and right[0] and abs(left[1] - right[1]) <= 1
             return [balanced, 1 + max(left[1], right[1])]
+
         return dfs(root)[0]

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)]
-        
+
         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]