style: format code and documents

Author: yanglbme

README.md

@@ -107,7 +107,6 @@ impl Solution {
 }
 ```
 
-
 ### **...**
 
 ```

README_EN.md

@@ -149,7 +149,6 @@ impl Solution {
 }
 ```
 
-
 ### **...**
 
 ```

lcci/10.01.Sorted Merge/README_EN.md

@@ -30,11 +30,11 @@
     - 排序 `nums`，检查 `nums[i] == i`，返回条件不成立的 `i`。
     - 若全部符合条件，则返回 `nums.length`。
 2. 数学
-   - 遍历 `nums`，统计总和，并记录其中的最大值。
-   - 若最大值与 `nums.length` 一致，使用高斯算法（`(n + 1) * n / 2`）计算总和，与遍历总和相减，得到结果。
-   - 不一致，则缺失的就是 `nums.length`。
+    - 遍历 `nums`，统计总和，并记录其中的最大值。
+    - 若最大值与 `nums.length` 一致，使用高斯算法（`(n + 1) * n / 2`）计算总和，与遍历总和相减，得到结果。
+    - 不一致，则缺失的就是 `nums.length`。
 3. 位运算
-   - 利用异或的特性，`res = res ^ x ^ x`。对同一个值异或两次，结果等于它本身。最后异或的结果，就是只出现一次的数字，即数组中缺失的整数。
+    - 利用异或的特性，`res = res ^ x ^ x`。对同一个值异或两次，结果等于它本身。最后异或的结果，就是只出现一次的数字，即数组中缺失的整数。
 
 <!-- tabs:start -->
 

lcci/10.02.Group Anagrams/README_EN.md

@@ -1,6 +1,6 @@
 class Solution:
     def findClosest(self, words: List[str], word1: str, word2: str) -> int:
-        idx1, idx2, ans = 10**5, -10**5, 10**5
+        idx1, idx2, ans = 10**5, -(10**5), 10**5
         for i, word in enumerate(words):
             if word == word1:
                 idx1 = i

lcci/17.04.Missing Number/README.md

@@ -159,7 +159,7 @@ private:
 
 public:
     Trie() : children(26), idx(-1) {}
-    
+
     void insert(string word, int i) {
         Trie* node = this;
         for (char c : word)
@@ -170,7 +170,7 @@ public:
         }
         node->idx = i;
     }
-    
+
     vector<int> search(string word) {
         Trie* node = this;
         vector<int> res;

lcci/17.11.Find Closest/Solution.py

@@ -156,7 +156,7 @@ private:
 
 public:
     Trie() : children(26), idx(-1) {}
-    
+
     void insert(string word, int i) {
         Trie* node = this;
         for (char c : word)
@@ -167,7 +167,7 @@ public:
         }
         node->idx = i;
     }
-    
+
     vector<int> search(string word) {
         Trie* node = this;
         vector<int> res;

lcci/17.17.Multi Search/README.md

@@ -36,10 +36,10 @@
 -   存在，即 `return` 返回。
 -   不存在，记录元素，继续遍历。
 
-*复杂度*：
+_复杂度_：
 
--   时间 ***O(N)***
--   空间 ***O(N)***
+-   时间 **_O(N)_**
+-   空间 **_O(N)_**
 
 **双指针**
 
@@ -52,10 +52,10 @@
 
 > 因为数组是有序的，指针变动对值的影响可预测。
 
-*复杂度*：
+_复杂度_：
 
--   时间 ***O(N)***
--   空间 ***O(1)***
+-   时间 **_O(N)_**
+-   空间 **_O(1)_**
 
 ```txt
 TWO-SUM(A,t)

lcci/17.17.Multi Search/README_EN.md

@@ -122,7 +122,8 @@ function isAlienSorted(words: string[], order: string): boolean {
     function compare(str1: string, str2: string): boolean {
         const n = Math.min(str1.length, str2.length);
         for (let i = 0; i < n; i++) {
-            let k1 = str1[i], k2 = str2[i];
+            let k1 = str1[i],
+                k2 = str2[i];
             if (k1 != k2) return charMap.get(k1) < charMap.get(k2);
         }
         return n == str1.length;
@@ -131,7 +132,7 @@ function isAlienSorted(words: string[], order: string): boolean {
         if (!compare(words[i - 1], words[i])) return false;
     }
     return true;
-};
+}
 ```
 
 ### **C++**

lcof/面试题57. 和为s的两个数字/README.md

@@ -65,7 +65,9 @@ def pushdown(self, node):
 
 
 class Solution:
-    def bonus(self, n: int, leadership: List[List[int]], operations: List[List[int]]) -> List[int]:
+    def bonus(
+        self, n: int, leadership: List[List[int]], operations: List[List[int]]
+    ) -> List[int]:
         def dfs(u):
             nonlocal idx
             begin[u] = idx

lcof2/剑指 Offer II 034. 外星语言是否排序/README.md

@@ -53,13 +53,13 @@
 1. 对 `nums` 进行排序。
 2. 遍历数组，并以当前遍历位置作为分割线，在右侧数组当中（不包括分割元素在内），寻找两个可以组成 `0 - nums[i]` 的值，将该题转换为**两数之和**。
 
-> 更贴切的说，与 [剑指 Offer 57. 和为s的两个数字](https://leetcode-cn.com/problems/he-wei-sde-liang-ge-shu-zi-lcof/) 目标一致
+> 更贴切的说，与 [剑指 Offer 57. 和为 s 的两个数字](https://leetcode-cn.com/problems/he-wei-sde-liang-ge-shu-zi-lcof/) 目标一致
 
 **优化：**
 
-- 当 `nums[i] > 0` 时，其后续的数值都比 `nums[i]` 大，那么就不可能存在两个数值一起组合为 0，可以提前结束遍历。
-- 若当前遍历数值与上一个数值一致（`nums[i] == nums[i - 1]`），可直接跳过（去重复）。
-- 相比两数之和，与其不同的是：**目标数组是有序的**。可使用**二分查找**或**头尾指针**快速搜索目标。
+-   当 `nums[i] > 0` 时，其后续的数值都比 `nums[i]` 大，那么就不可能存在两个数值一起组合为 0，可以提前结束遍历。
+-   若当前遍历数值与上一个数值一致（`nums[i] == nums[i - 1]`），可直接跳过（去重复）。
+-   相比两数之和，与其不同的是：**目标数组是有序的**。可使用**二分查找**或**头尾指针**快速搜索目标。
 
 **重复问题：**
 

lcp/LCP 05. 发 LeetCoin/Solution.py

@@ -214,7 +214,7 @@ public class ThreeSumComparer: IEqualityComparer<IList<int>>
     {
         return left[0] == right[0] && left[1] == right[1] && left[2] == right[2];
     }
-    
+
     public int GetHashCode(IList<int> obj)
     {
         return (obj[0] ^ obj[1] ^ obj[2]).GetHashCode();
@@ -225,7 +225,7 @@ public class Solution {
     public IList<IList<int>> ThreeSum(int[] nums) {
         Array.Sort(nums);
         var results = new HashSet<IList<int>>(new ThreeSumComparer());
-        
+
         var cIndex = Array.BinarySearch(nums, 0);
         if (cIndex < 0) cIndex = ~cIndex;
         while (cIndex < nums.Length)
@@ -253,7 +253,7 @@ public class Solution {
                         step /= 2;
                     }
                 }
-                
+
                 if (nums[aIndex] + nums[bIndex] + c > 0)
                 {
                     var step = 1;
@@ -272,7 +272,7 @@ public class Solution {
                         step /= 2;
                     }
                 }
-                
+
                 if (nums[aIndex] + nums[bIndex] + c == 0)
                 {
                     var list = new List<int> { nums[aIndex], nums[bIndex], c };
@@ -291,7 +291,7 @@ public class Solution {
             }
             ++cIndex;
         }
-        
+
         return results.ToList();
     }
 }

solution/0000-0099/0015.3Sum/README.md

@@ -124,7 +124,7 @@ public:
  * @return {void} Do not return anything, modify matrix in-place instead.
  */
 var rotate = function (matrix) {
-    const n = matrix.length
+    const n = matrix.length;
     for (let i = 0; i < n; i++) {
         for (let j = 0; j <= i; j++) {
             [matrix[i][j], matrix[j][i]] = [matrix[j][i], matrix[i][j]];

solution/0000-0099/0015.3Sum/README_EN.md

@@ -201,7 +201,7 @@ impl Solution {
                     if n == 0 {
                         nums.swap(i, l);
                         l += 1;
-                    } 
+                    }
                     i += 1;
                 }
             }

solution/0000-0099/0048.Rotate Image/README.md

@@ -1,23 +1,23 @@
-class Solution:
-    def minWindow(self, s: str, t: str) -> str:
-        ans = ''
-        m, n = len(s), len(t)
-        if m < n:
-            return ans
-        need = Counter(t)
-        window = Counter()
-        i, cnt, mi = 0, 0, float('inf')
-        for j, c in enumerate(s):
-            window[c] += 1
-            if need[c] >= window[c]:
-                cnt += 1
-            while cnt == n:
-                if j - i + 1 < mi:
-                    mi = j - i + 1
-                    ans = s[i: j + 1]
-                c = s[i]
-                if need[c] >= window[c]:
-                    cnt -= 1
-                window[c] -= 1
-                i += 1
-        return ans
+class Solution:
+    def minWindow(self, s: str, t: str) -> str:
+        ans = ''
+        m, n = len(s), len(t)
+        if m < n:
+            return ans
+        need = Counter(t)
+        window = Counter()
+        i, cnt, mi = 0, 0, float('inf')
+        for j, c in enumerate(s):
+            window[c] += 1
+            if need[c] >= window[c]:
+                cnt += 1
+            while cnt == n:
+                if j - i + 1 < mi:
+                    mi = j - i + 1
+                    ans = s[i : j + 1]
+                c = s[i]
+                if need[c] >= window[c]:
+                    cnt -= 1
+                window[c] -= 1
+                i += 1
+        return ans

solution/0000-0099/0075.Sort Colors/README_EN.md

@@ -205,7 +205,7 @@ class LRUCache {
         head.next = tail;
         tail.prev = head;
     }
-    
+
     public int get(int key) {
         if (!cache.containsKey(key)) {
             return -1;
@@ -214,7 +214,7 @@ class LRUCache {
         moveToHead(node);
         return node.val;
     }
-    
+
     public void put(int key, int value) {
         if (cache.containsKey(key)) {
             Node node = cache.get(key);
@@ -486,14 +486,14 @@ public:
         head->next = tail;
         tail->prev = head;
     }
-    
+
     int get(int key) {
         if (!cache.count(key)) return -1;
         Node* node = cache[key];
         moveToHead(node);
         return node->v;
     }
-    
+
     void put(int key, int value) {
         if (cache.count(key))
         {

solution/0000-0099/0076.Minimum Window Substring/Solution.py

@@ -154,7 +154,7 @@ class LRUCache {
         head.next = tail;
         tail.prev = head;
     }
-    
+
     public int get(int key) {
         if (!cache.containsKey(key)) {
             return -1;
@@ -163,7 +163,7 @@ class LRUCache {
         moveToHead(node);
         return node.val;
     }
-    
+
     public void put(int key, int value) {
         if (cache.containsKey(key)) {
             Node node = cache.get(key);
@@ -435,14 +435,14 @@ public:
         head->next = tail;
         tail->prev = head;
     }
-    
+
     int get(int key) {
         if (!cache.count(key)) return -1;
         Node* node = cache[key];
         moveToHead(node);
         return node->v;
     }
-    
+
     void put(int key, int value) {
         if (cache.count(key))
         {