style: format code using prettier and black

* prettier --write "**/*.md"
* black -S .

Author: yanglbme

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:
         dummy = cur = ListNode(0)

lcci/10.10.Rank from Stream/Solution.py

@@ -21,7 +21,6 @@ def query(self, x):
 
 
 class StreamRank:
-
     def __init__(self):
         self.tree = BinaryIndexedTree(50010)
 

lcs/LCS 03. 主题空间/Solution.py

@@ -16,7 +16,17 @@ def find(x):
                 else:
                     for a, b in dirs:
                         x, y = i + a, j + b
-                        if (grid[x][y] == '0' or grid[i][j] == grid[x][y]) and find(x * n + y) != find(i * n + j):
+                        if (grid[x][y] == '0' or grid[i][j] == grid[x][y]) and find(
+                            x * n + y
+                        ) != find(i * n + j):
                             size[find(x * n + y)] += size[find(i * n + j)]
                             p[find(i * n + j)] = find(x * n + y)
-        return max([size[i * n + j] for i in range(m) for j in range(n) if find(i * n + j) != find(m * n)], default=0)
+        return max(
+            [
+                size[i * n + j]
+                for i in range(m)
+                for j in range(n)
+                if find(i * n + j) != find(m * n)
+            ],
+            default=0,
+        )

solution/0000-0099/0079.Word Search/Solution.py

@@ -3,7 +3,14 @@ def exist(self, board: List[List[str]], word: str) -> bool:
         def dfs(i, j, cur):
             if cur == len(word):
                 return True
-            if i < 0 or i >= m or j < 0 or j >= n or board[i][j] == '0' or word[cur] != board[i][j]:
+            if (
+                i < 0
+                or i >= m
+                or j < 0
+                or j >= n
+                or board[i][j] == '0'
+                or word[cur] != board[i][j]
+            ):
                 return False
             t = board[i][j]
             board[i][j] = '0'

solution/0000-0099/0090.Subsets II/Solution.py

@@ -8,7 +8,7 @@ def dfs(u, t):
                 t.append(nums[i])
                 dfs(i + 1, t)
                 t.pop()
-        
+
         ans = []
         nums.sort()
         dfs(0, [])

solution/0100-0199/0126.Word Ladder II/Solution.py

@@ -1,5 +1,7 @@
 class Solution:
-    def findLadders(self, beginWord: str, endWord: str, wordList: List[str]) -> List[List[str]]:
+    def findLadders(
+        self, beginWord: str, endWord: str, wordList: List[str]
+    ) -> List[List[str]]:
         def dfs(path, cur):
             if cur == beginWord:
                 ans.append(path[::-1])

solution/0100-0199/0127.Word Ladder/Solution.py

@@ -25,8 +25,7 @@ def extend(m1, m2, q):
         q1, q2 = deque([beginWord]), deque([endWord])
         m1, m2 = {beginWord: 0}, {endWord: 0}
         while q1 and q2:
-            t = extend(m1, m2, q1) if len(q1) <= len(
-                q2) else extend(m2, m1, q2)
+            t = extend(m1, m2, q1) if len(q1) <= len(q2) else extend(m2, m1, q2)
             if t != -1:
                 return t + 1
         return 0

solution/0100-0199/0130.Surrounded Regions/Solution.py

@@ -3,6 +3,7 @@ def solve(self, board: List[List[str]]) -> None:
         """
         Do not return anything, modify board in-place instead.
         """
+
         def dfs(i, j):
             board[i][j] = '.'
             for a, b in [[0, -1], [0, 1], [1, 0], [-1, 0]]:
@@ -13,7 +14,9 @@ def dfs(i, j):
         m, n = len(board), len(board[0])
         for i in range(m):
             for j in range(n):
-                if board[i][j] == 'O' and (i == 0 or i == m - 1 or j == 0 or j == n - 1):
+                if board[i][j] == 'O' and (
+                    i == 0 or i == m - 1 or j == 0 or j == n - 1
+                ):
                     dfs(i, j)
         for i in range(m):
             for j in range(n):

solution/0300-0399/0307.Range Sum Query - Mutable/Solution.py

@@ -21,7 +21,6 @@ def query(self, x):
 
 
 class NumArray:
-
     def __init__(self, nums: List[int]):
         self.tree = BinaryIndexedTree(len(nums))
         for i, v in enumerate(nums, 1):

solution/0300-0399/0308.Range Sum Query 2D - Mutable/Solution.py

@@ -21,7 +21,6 @@ def query(self, x):
 
 
 class NumMatrix:
-
     def __init__(self, matrix: List[List[int]]):
         self.trees = []
         n = len(matrix[0])
@@ -37,7 +36,10 @@ def update(self, row: int, col: int, val: int) -> None:
         tree.update(col + 1, val - prev)
 
     def sumRegion(self, row1: int, col1: int, row2: int, col2: int) -> int:
-        return sum(tree.query(col2 + 1) - tree.query(col1) for tree in self.trees[row1: row2 + 1])
+        return sum(
+            tree.query(col2 + 1) - tree.query(col1)
+            for tree in self.trees[row1 : row2 + 1]
+        )
 
 
 # Your NumMatrix object will be instantiated and called as such:

solution/0300-0399/0399.Evaluate Division/Solution.py

@@ -1,5 +1,7 @@
 class Solution:
-    def calcEquation(self, equations: List[List[str]], values: List[float], queries: List[List[str]]) -> List[float]:
+    def calcEquation(
+        self, equations: List[List[str]], values: List[float], queries: List[List[str]]
+    ) -> List[float]:
         def find(x):
             if p[x] != x:
                 origin = p[x]
@@ -18,4 +20,7 @@ def find(x):
                 continue
             p[pa] = pb
             w[pa] = w[b] * v / w[a]
-        return [-1 if c not in p or d not in p or find(c) != find(d) else w[c] / w[d] for c, d in queries]
+        return [
+            -1 if c not in p or d not in p or find(c) != find(d) else w[c] / w[d]
+            for c, d in queries
+        ]

solution/0500-0599/0552.Student Attendance Record II/Solution.py

@@ -16,7 +16,9 @@ def checkRecord(self, n: int) -> int:
             dp[i][1][2] = dp[i - 1][1][1]
             # P
             dp[i][0][0] = (dp[i - 1][0][0] + dp[i - 1][0][1] + dp[i - 1][0][2]) % mod
-            dp[i][1][0] = (dp[i][1][0] + dp[i - 1][1][0] + dp[i - 1][1][1] + dp[i - 1][1][2]) % mod
+            dp[i][1][0] = (
+                dp[i][1][0] + dp[i - 1][1][0] + dp[i - 1][1][1] + dp[i - 1][1][2]
+            ) % mod
 
         ans = 0
         for j in range(2):

solution/0500-0599/0564.Find the Closest Palindrome/Solution.py

@@ -2,8 +2,8 @@ class Solution:
     def nearestPalindromic(self, n: str) -> str:
         x = int(n)
         l = len(n)
-        res = {10 ** (l - 1) - 1, 10 ** l + 1}
-        left = int(n[:(l + 1) >> 1])
+        res = {10 ** (l - 1) - 1, 10**l + 1}
+        left = int(n[: (l + 1) >> 1])
         for i in range(left - 1, left + 2):
             j = i if l % 2 == 0 else i // 10
             while j:
@@ -14,6 +14,10 @@ def nearestPalindromic(self, n: str) -> str:
 
         ans = -1
         for t in res:
-            if ans == -1 or abs(t - x) < abs(ans - x) or (abs(t - x) == abs(ans - x) and t < ans):
+            if (
+                ans == -1
+                or abs(t - x) < abs(ans - x)
+                or (abs(t - x) == abs(ans - x) and t < ans)
+            ):
                 ans = t
         return str(ans)

solution/0600-0699/0675.Cut Off Trees for Golf Event/Solution.py

@@ -16,13 +16,13 @@ def bfs(i, j, x, y):
                     if 0 <= c < m and 0 <= d < n and forest[c][d] > 0:
                         if c * n + d not in dist or dist[c * n + d] > step + 1:
                             dist[c * n + d] = step + 1
-                            heapq.heappush(
-                                q, (dist[c * n + d] + f(c, d, x, y), c, d))
+                            heapq.heappush(q, (dist[c * n + d] + f(c, d, x, y), c, d))
             return -1
 
         m, n = len(forest), len(forest[0])
-        trees = [(forest[i][j], i, j) for i in range(m)
-                 for j in range(n) if forest[i][j] > 1]
+        trees = [
+            (forest[i][j], i, j) for i in range(m) for j in range(n) if forest[i][j] > 1
+        ]
         trees.sort()
         i = j = 0
         ans = 0

solution/0600-0699/0683.K Empty Slots/Solution.py

@@ -11,22 +11,31 @@ def update(self, x, delta):
         while x <= self.n:
             self.c[x] += delta
             x += BinaryIndexedTree.lowbit(x)
-    
+
     def query(self, x):
         s = 0
         while x > 0:
             s += self.c[x]
             x -= BinaryIndexedTree.lowbit(x)
         return s
 
+
 class Solution:
     def kEmptySlots(self, bulbs: List[int], k: int) -> int:
         n = len(bulbs)
         tree = BinaryIndexedTree(n)
         for i, x in enumerate(bulbs, 1):
             tree.update(x, 1)
-            case1 = x - k - 1 > 0 and tree.query(x - k - 1) - tree.query(x - k - 2) == 1 and tree.query(x - 1) - tree.query(x - k - 1) == 0
-            case2 = x + k + 1 <= n and tree.query(x + k + 1) - tree.query(x + k) == 1 and tree.query(x + k) - tree.query(x) == 0
+            case1 = (
+                x - k - 1 > 0
+                and tree.query(x - k - 1) - tree.query(x - k - 2) == 1
+                and tree.query(x - 1) - tree.query(x - k - 1) == 0
+            )
+            case2 = (
+                x + k + 1 <= n
+                and tree.query(x + k + 1) - tree.query(x + k) == 1
+                and tree.query(x + k) - tree.query(x) == 0
+            )
             if case1 or case2:
                 return i
         return -1

solution/0600-0699/0688.Knight Probability in Chessboard/Solution.py

@@ -7,7 +7,16 @@ def knightProbability(self, n: int, k: int, row: int, column: int) -> float:
                     if l == 0:
                         dp[l][i][j] = 1
                     else:
-                        for a, b in ((-2, -1), (-2, 1), (2, -1), (2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2)):
+                        for a, b in (
+                            (-2, -1),
+                            (-2, 1),
+                            (2, -1),
+                            (2, 1),
+                            (-1, -2),
+                            (-1, 2),
+                            (1, -2),
+                            (1, 2),
+                        ):
                             x, y = i + a, j + b
                             if 0 <= x < n and 0 <= y < n:
                                 dp[l][i][j] += dp[l - 1][x][y] / 8

solution/0700-0799/0752.Open the Lock/Solution.py

@@ -11,7 +11,7 @@ def next(s):
                 res.append(''.join(s))
                 s[i] = c
             return res
-        
+
         def extend(m1, m2, q):
             for _ in range(len(q), 0, -1):
                 p = q.popleft()
@@ -24,7 +24,7 @@ def extend(m1, m2, q):
                     m1[t] = step + 1
                     q.append(t)
             return -1
-        
+
         def bfs():
             m1, m2 = {"0000": 0}, {target: 0}
             q1, q2 = deque([('0000')]), deque([(target)])
@@ -33,10 +33,10 @@ def bfs():
                 if t != -1:
                     return t
             return -1
-        
+
         if target == '0000':
             return 0
         s = set(deadends)
         if '0000' in s:
             return -1
-        return bfs()
+        return bfs()

solution/0900-0999/0928.Minimize Malware Spread II/Solution.py

@@ -4,13 +4,13 @@ def find(x):
             if p[x] != x:
                 p[x] = find(p[x])
             return p[x]
-        
+
         def union(a, b):
             pa, pb = find(a), find(b)
             if pa != pb:
                 size[pb] += size[pa]
                 p[pa] = pb
-        
+
         n = len(graph)
         p = list(range(n))
         size = [1] * n
@@ -30,10 +30,10 @@ def union(a, b):
             for root in s:
                 cnt[root] += 1
             mp[i] = s
-        
+
         mx, ans = -1, 0
         for i, s in mp.items():
             t = sum(size[root] for root in s if cnt[root] == 1)
             if mx < t or mx == t and i < ans:
                 mx, ans = t, i
-        return ans
+        return ans

solution/0900-0999/0930.Binary Subarrays With Sum/README_EN.md

@@ -218,22 +218,22 @@ func numSubarraysWithSum(nums []int, goal int) int {
  * @return {number}
  */
 var numSubarraysWithSum = function (nums, goal) {
-  let i1 = 0,
-    i2 = 0,
-    s1 = 0,
-    s2 = 0,
-    j = 0,
-    ans = 0;
-  const n = nums.length;
-  while (j < n) {
-    s1 += nums[j];
-    s2 += nums[j];
-    while (i1 <= j && s1 > goal) s1 -= nums[i1++];
-    while (i2 <= j && s2 >= goal) s2 -= nums[i2++];
-    ans += i2 - i1;
-    ++j;
-  }
-  return ans;
+    let i1 = 0,
+        i2 = 0,
+        s1 = 0,
+        s2 = 0,
+        j = 0,
+        ans = 0;
+    const n = nums.length;
+    while (j < n) {
+        s1 += nums[j];
+        s2 += nums[j];
+        while (i1 <= j && s1 > goal) s1 -= nums[i1++];
+        while (i2 <= j && s2 >= goal) s2 -= nums[i2++];
+        ans += i2 - i1;
+        ++j;
+    }
+    return ans;
 };
 ```
 

solution/1000-1099/1031.Maximum Sum of Two Non-Overlapping Subarrays/Solution.py

@@ -11,4 +11,4 @@ def maxSumTwoNoOverlap(self, nums: List[int], firstLen: int, secondLen: int) ->
         for i in range(n - firstLen - secondLen + 1):
             sm = max(sm, s[i + secondLen] - s[i])
             ans2 = max(sm + s[i + firstLen + secondLen] - s[i + secondLen], ans2)
-        return max(ans1, ans2)
+        return max(ans1, ans2)

solution/1000-1099/1091.Shortest Path in Binary Matrix/Solution.py

@@ -17,4 +17,4 @@ def shortestPathBinaryMatrix(self, grid: List[List[int]]) -> int:
                         if 0 <= x < n and 0 <= y < n and grid[x][y] == 0:
                             q.append((x, y))
                             grid[x][y] = 1
-        return -1
+        return -1

solution/1100-1199/1108.Defanging an IP Address/README_EN.md

@@ -59,7 +59,7 @@ class Solution {
 
 ```ts
 function defangIPaddr(address: string): string {
-  return address.split(".").join("[.]");
+    return address.split('.').join('[.]');
 }
 ```