style: reformat python code using black

* black -S .

Author: yanglbme

basic/sorting/MergeSort/Main.py

@@ -23,7 +23,7 @@ def merge_sort(nums, left, right):
     while j <= right:
         tmp.append(nums[j])
         j += 1
-    
+
     j = 0
     for i in range(left, right + 1):
         nums[i] = tmp[j]

lcci/01.01.Is Unique/Solution.py

@@ -5,5 +5,5 @@ def isUnique(self, astr: str) -> bool:
             pos = ord(c) - ord('a')
             if (bitmap & (1 << pos)) != 0:
                 return False
-            bitmap |= (1 << pos)
+            bitmap |= 1 << pos
         return True

lcci/01.06.Compress String/Solution.py

@@ -6,8 +6,8 @@ def compressString(self, S: str) -> str:
         res = ''
         while q < len(S):
             if S[p] != S[q]:
-                res += (S[p] + str(q - p))
+                res += S[p] + str(q - p)
                 p = q
             q += 1
-        res += (S[p] + str(q - p))
-        return res if len(res) < len(S) else S
+        res += S[p] + str(q - p)
+        return res if len(res) < len(S) else S

lcci/01.08.Zero Matrix/Solution.py

@@ -10,13 +10,13 @@ def setZeroes(self, matrix: List[List[int]]) -> None:
                 if matrix[i][j] == 0:
                     zero_rows.add(i)
                     zero_cols.add(j)
-        
+
         for i in zero_rows:
             for j in range(cols):
                 matrix[i][j] = 0
-        
+
         for j in zero_cols:
             for i in range(rows):
                 matrix[i][j] = 0
-        
+
         return matrix

lcci/02.01.Remove Duplicate Node/Solution.py

@@ -4,6 +4,7 @@
 #         self.val = x
 #         self.next = None
 
+
 class Solution:
     def removeDuplicateNodes(self, head: ListNode) -> ListNode:
         if head is None or head.next is None:
@@ -18,4 +19,4 @@ def removeDuplicateNodes(self, head: ListNode) -> ListNode:
                 cache.add(p.val)
             p = p.next
         cur.next = None
-        return head
+        return head

lcci/02.02.Kth Node From End of List/Solution.py

@@ -4,6 +4,7 @@
 #         self.val = x
 #         self.next = None
 
+
 class Solution:
     def kthToLast(self, head: ListNode, k: int) -> int:
         slow = fast = head

lcci/02.03.Delete Middle Node/Solution.py

@@ -4,11 +4,12 @@
 #         self.val = x
 #         self.next = None
 
+
 class Solution:
     def deleteNode(self, node):
         """
         :type node: ListNode
         :rtype: void Do not return anything, modify node in-place instead.
         """
         node.val = node.next.val
-        node.next = node.next.next
+        node.next = node.next.next

lcci/02.04.Partition List/Solution.py

@@ -4,6 +4,7 @@
 #         self.val = x
 #         self.next = None
 
+
 class Solution:
     def partition(self, head: ListNode, x: int) -> ListNode:
         l1, l2 = ListNode(0), ListNode(0)

lcci/02.05.Sum Lists/Solution.py

@@ -4,6 +4,7 @@
 #         self.val = x
 #         self.next = None
 
+
 class Solution:
     def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
         carry = 0
@@ -16,4 +17,4 @@ def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
             cur = cur.next
             l1 = None if not l1 else l1.next
             l2 = None if not l2 else l2.next
-        return dummy.next
+        return dummy.next

lcci/02.06.Palindrome Linked List/Solution.py

@@ -19,4 +19,4 @@ def isPalindrome(self, head: ListNode) -> bool:
             if pre.val != head.val:
                 return False
             pre, head = pre.next, head.next
-        return True
+        return True

lcci/02.07.Intersection of Two Linked Lists/Solution.py

@@ -4,6 +4,7 @@
 #         self.val = x
 #         self.next = None
 
+
 class Solution:
     def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
         cur1, cur2 = headA, headB

lcci/02.08.Linked List Cycle/Solution.py

@@ -4,6 +4,7 @@
 #         self.val = x
 #         self.next = None
 
+
 class Solution:
     def detectCycle(self, head: ListNode) -> ListNode:
         slow = fast = head

lcci/03.01.Three in One/Solution.py

@@ -1,5 +1,4 @@
 class TripleInOne:
-
     def __init__(self, stackSize: int):
         self._capacity = stackSize
         self._s = [[], [], []]

lcci/03.02.Min Stack/Solution.py

@@ -1,5 +1,4 @@
 class MinStack:
-
     def __init__(self):
         """
         initialize your data structure here.
@@ -27,4 +26,4 @@ def getMin(self) -> int:
 # obj.push(val)
 # obj.pop()
 # param_3 = obj.top()
-# param_4 = obj.getMin()
+# param_4 = obj.getMin()

lcci/03.04.Implement Queue using Stacks/Solution.py

@@ -1,5 +1,4 @@
 class MyQueue:
-
     def __init__(self):
         """
         Initialize your data structure here.

lcci/03.05.Sort of Stacks/Solution.py

@@ -1,5 +1,4 @@
 class SortedStack:
-
     def __init__(self):
         self.s = []
 

lcci/03.06.Animal Shelter/Solution.py

@@ -1,5 +1,4 @@
 class AnimalShelf:
-
     def __init__(self):
         self.cats = []
         self.dogs = []

lcci/04.02.Minimum Height Tree/Solution.py

@@ -5,6 +5,7 @@
 #         self.left = None
 #         self.right = None
 
+
 class Solution:
     def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
         def dfs(i, j):

lcci/04.04.Check Balance/Solution.py

@@ -11,7 +11,11 @@ def isBalanced(self, root: TreeNode) -> bool:
         if not root:
             return True
         l, r = self._height(root.left), self._height(root.right)
-        return abs(l - r) < 2 and self.isBalanced(root.left) and self.isBalanced(root.right)
+        return (
+            abs(l - r) < 2
+            and self.isBalanced(root.left)
+            and self.isBalanced(root.right)
+        )
 
     def _height(self, node):
         if not node:

lcci/04.05.Legal Binary Search Tree/Solution.py

@@ -5,8 +5,10 @@
 #         self.left = None
 #         self.right = None
 
+
 class Solution:
     res, t = True, None
+
     def isValidBST(self, root: TreeNode) -> bool:
         self.isValid(root)
         return self.res
@@ -20,4 +22,4 @@ def isValid(self, root):
         else:
             self.res = False
             return
-        self.isValid(root.right)
+        self.isValid(root.right)

lcci/04.06.Successor/Solution.py

@@ -5,6 +5,7 @@
 #         self.left = None
 #         self.right = None
 
+
 class Solution:
     def inorderSuccessor(self, root: TreeNode, p: TreeNode) -> TreeNode:
         def dfs(root):

lcci/04.08.First Common Ancestor/Solution.py

@@ -5,10 +5,13 @@
 #         self.left = None
 #         self.right = None
 
+
 class Solution:
-    def lowestCommonAncestor(self, root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:
+    def lowestCommonAncestor(
+        self, root: TreeNode, p: TreeNode, q: TreeNode
+    ) -> TreeNode:
         if root is None or root == p or root == q:
             return root
         left = self.lowestCommonAncestor(root.left, p, q)
         right = self.lowestCommonAncestor(root.right, p, q)
-        return right if left is None else (left if right is None else root)
+        return right if left is None else (left if right is None else root)

lcci/04.10.Check SubTree/Solution.py

@@ -5,6 +5,7 @@
 #         self.left = None
 #         self.right = None
 
+
 class Solution:
     def checkSubTree(self, t1: TreeNode, t2: TreeNode) -> bool:
         def dfs(t1, t2):

lcci/04.12.Paths with Sum/Solution.py

@@ -4,16 +4,16 @@ def dfs(root, sum, flag):
             nonlocal ans
             if not root:
                 return 0
-            if sum-root.val == 0:
+            if sum - root.val == 0:
                 ans += 1
             if flag == 0:
                 dfs(root.left, sum, 0)
                 dfs(root.right, sum, 0)
-            dfs(root.left, sum-root.val, 1)
-            dfs(root.right, sum-root.val, 1)
-        
+            dfs(root.left, sum - root.val, 1)
+            dfs(root.right, sum - root.val, 1)
+
         if not root:
             return 0
         ans = 0
         dfs(root, sum, 0)
-        return ans
+        return ans

lcci/08.01.Three Steps Problem/Solution.py

@@ -5,4 +5,4 @@ def waysToStep(self, n: int) -> int:
         a, b, c = 1, 2, 4
         for _ in range(4, n + 1):
             a, b, c = b, c, (a + b + c) % 1000000007
-        return c
+        return c

lcci/08.10.Color Fill/Solution.py

@@ -1,7 +1,16 @@
 class Solution:
-    def floodFill(self, image: List[List[int]], sr: int, sc: int, newColor: int) -> List[List[int]]:
+    def floodFill(
+        self, image: List[List[int]], sr: int, sc: int, newColor: int
+    ) -> List[List[int]]:
         def dfs(i, j, oc, nc):
-            if i < 0 or i >= len(image) or j < 0 or j >= len(image[0]) or image[i][j] != oc or image[i][j] == nc:
+            if (
+                i < 0
+                or i >= len(image)
+                or j < 0
+                or j >= len(image[0])
+                or image[i][j] != oc
+                or image[i][j] == nc
+            ):
                 return
             image[i][j] = nc
             for x, y in [[0, 1], [0, -1], [1, 0], [-1, 0]]:

lcci/08.12.Eight Queens/Solution.py

@@ -17,6 +17,6 @@ def dfs(u):
                     dfs(u + 1)
                     g[u][i] = '.'
                     col[i] = dg[u + i] = udg[n - u + i] = False
-        
+
         dfs(0)
         return res

lcci/16.02.Words Frequency/Solution.py

@@ -1,11 +1,11 @@
 class WordsFrequency:
-
     def __init__(self, book: List[str]):
         self.counter = Counter(book)
 
     def get(self, word: str) -> int:
         return self.counter[word]
 
+
 # Your WordsFrequency object will be instantiated and called as such:
 # obj = WordsFrequency(book)
 # param_1 = obj.get(word)

lcci/16.10.Living People/Solution.py

@@ -12,4 +12,4 @@ def maxAliveYear(self, birth: List[int], death: List[int]) -> int:
             if years[i] > max_v:
                 max_v = years[i]
                 res = i
-        return 1900 + res
+        return 1900 + res

lcci/16.25.LRU Cache/Solution.py

@@ -5,8 +5,8 @@ def __init__(self, key=0, value=0):
         self.prev = None
         self.next = None
 
-class LRUCache:
 
+class LRUCache:
     def __init__(self, capacity: int):
         self.cache = {}
         self.head = Node()
@@ -37,15 +37,15 @@ def put(self, key: int, value: int) -> None:
                 node = self.remove_tail()
                 self.cache.pop(node.key)
                 self.size -= 1
-    
+
     def move_to_head(self, node):
         self.remove_node(node)
         self.add_to_head(node)
-    
+
     def remove_node(self, node):
         node.prev.next = node.next
         node.next.prev = node.prev
-    
+
     def add_to_head(self, node):
         node.next = self.head.next
         self.head.next.prev = node
@@ -61,4 +61,4 @@ def remove_tail(self):
 # Your LRUCache object will be instantiated and called as such:
 # obj = LRUCache(capacity)
 # param_1 = obj.get(key)
-# obj.put(key,value)
+# obj.put(key,value)

lcci/17.05.Find Longest Subarray/Solution.py

@@ -8,7 +8,7 @@ def findLongestSubarray(self, array: List[str]) -> List[str]:
             if t in seen:
                 if mx < i - seen[t]:
                     mx = i - seen[t]
-                    ans = array[seen[t] + 1: i + 1]
+                    ans = array[seen[t] + 1 : i + 1]
             else:
                 seen[t] = i
         return ans

lcci/17.07.Baby Names/Solution.py

@@ -21,19 +21,19 @@ def union(a, b):
 
         for e in names:
             idx = e.find("(")
-            name, w = e[: idx], int(e[idx + 1: -1])
+            name, w = e[:idx], int(e[idx + 1 : -1])
             mp[name] = w
             p[name] = name
         for e in synonyms:
             idx = e.find(",")
-            name1, name2 = e[1: idx], e[idx + 1: -1]
+            name1, name2 = e[1:idx], e[idx + 1 : -1]
             mp[name1] += 0
             mp[name2] += 0
             p[name1] = name1
             p[name2] = name2
 
         for e in synonyms:
             idx = e.find(",")
-            name1, name2 = e[1: idx], e[idx + 1: -1]
+            name1, name2 = e[1:idx], e[idx + 1 : -1]
             union(name1, name2)
         return [f'{name}({mp[name]})' for name, w in mp.items() if name == find(name)]

lcci/17.10.Find Majority Element/Solution.py

@@ -4,5 +4,5 @@ def majorityElement(self, nums: List[int]) -> int:
         for num in nums:
             if cnt == 0:
                 candidate = num
-            cnt += (1 if candidate == num else -1)
+            cnt += 1 if candidate == num else -1
         return candidate if nums.count(candidate) > len(nums) / 2 else -1

lcci/17.12.BiNode/Solution.py

@@ -5,6 +5,7 @@
 #         self.left = None
 #         self.right = None
 
+
 class Solution:
     def convertBiNode(self, root: TreeNode) -> TreeNode:
         if root is None: