feat: add contest data

Author: yanglbme

.gitignore

@@ -3,6 +3,7 @@
 .vscode
 /node_modules
 /solution/result.json
+/solution/contest.json
 /solution/raw.json
 /lcof/lcof.json
 /lcof/lcof_list.json

basic/sorting/CountingSort/README.md

@@ -3,11 +3,12 @@
 计数排序是一个非基于比较的排序算法，是一种空间换时间的算法，是通过元素的值来确定元素的位置， 适用于非负整数的排序（如果负数需要排序，那么需要使所有元素都添加上 `0-min` 之后再减去该值）
 
 算法描述:
-- 给定原数组中元素值的范围 `[min, max]`
-- 创建一个新数组 `c` ，其长度是 `max-min+1`，其元素默认值都是 `0`
-- 遍历原数组中的元素，以原数组中的元素作为 `c` 数组的索引，以原数组中的元素出现次数作为 `c` 数组的元素值。
-- 创建结果数组 `r`，起始索引 `i`
-- 遍历数组 `c`，找出其中元素大于 `0` 的元素，将其对应的索引作为元素值填充到 `r` 数组中，每处理一次，`c` 中的元素值减 `1`，直到该元素值不大于 `0`，依次处理 `c` 中剩下的元素
+
+-   给定原数组中元素值的范围 `[min, max]`
+-   创建一个新数组 `c` ，其长度是 `max-min+1`，其元素默认值都是 `0`
+-   遍历原数组中的元素，以原数组中的元素作为 `c` 数组的索引，以原数组中的元素出现次数作为 `c` 数组的元素值。
+-   创建结果数组 `r`，起始索引 `i`
+-   遍历数组 `c`，找出其中元素大于 `0` 的元素，将其对应的索引作为元素值填充到 `r` 数组中，每处理一次，`c` 中的元素值减 `1`，直到该元素值不大于 `0`，依次处理 `c` 中剩下的元素
 
 ## 代码示例
 
@@ -68,6 +69,5 @@ func CountingSort(nums []int, min, max int) {
 
 ## 算法分析
 
-- 时间复杂度 `O(n+k)`， 其中 `n` 为排序数组长度，`k` 为排序数组中数值的取值范围，当 `k < n` 时，时间复杂度为 `O(n)`
-- 空间复杂度 `O(n+k)`， 其中 `n` 为排序数组长度，`k` 为排序数组中数值的取值范围，当 `k < n` 时，空间复杂度为 `O(n)`
-
+-   时间复杂度 `O(n+k)`， 其中 `n` 为排序数组长度，`k` 为排序数组中数值的取值范围，当 `k < n` 时，时间复杂度为 `O(n)`
+-   空间复杂度 `O(n+k)`， 其中 `n` 为排序数组长度，`k` 为排序数组中数值的取值范围，当 `k < n` 时，空间复杂度为 `O(n)`

basic/sorting/HeapSort/README.md

@@ -225,6 +225,7 @@ fn main() -> io::Result<()> {
 ```
 
 ### **Go**
+
 ```go
 package main
 

lcci/03.05.Sort of Stacks/README.md

@@ -160,33 +160,33 @@ class SortedStack {
 
 ```ts
 class SortedStack {
-    private stack: number[]
+    private stack: number[];
 
     constructor() {
-        this.stack = []
+        this.stack = [];
     }
 
     push(val: number): void {
         if (this.isEmpty() || this.peek() > val) {
-            this.stack.push(val)
-            return
+            this.stack.push(val);
+            return;
         }
 
-        const tmp = this.stack.pop()
+        const tmp = this.stack.pop();
         this.push(val);
         this.stack.push(tmp);
     }
 
     pop(): void {
-        this.stack.pop()
+        this.stack.pop();
     }
 
     peek(): number {
-        return this.stack[this.stack.length - 1] ?? -1
+        return this.stack[this.stack.length - 1] ?? -1;
     }
 
     isEmpty(): boolean {
-        return this.stack.length === 0
+        return this.stack.length === 0;
     }
 }
 

lcci/03.05.Sort of Stacks/README_EN.md

@@ -165,33 +165,33 @@ class SortedStack {
 
 ```ts
 class SortedStack {
-    private stack: number[]
+    private stack: number[];
 
     constructor() {
-        this.stack = []
+        this.stack = [];
     }
 
     push(val: number): void {
         if (this.isEmpty() || this.peek() > val) {
-            this.stack.push(val)
-            return
+            this.stack.push(val);
+            return;
         }
 
-        const tmp = this.stack.pop()
+        const tmp = this.stack.pop();
         this.push(val);
         this.stack.push(tmp);
     }
 
     pop(): void {
-        this.stack.pop()
+        this.stack.pop();
     }
 
     peek(): number {
-        return this.stack[this.stack.length - 1] ?? -1
+        return this.stack[this.stack.length - 1] ?? -1;
     }
 
     isEmpty(): boolean {
-        return this.stack.length === 0
+        return this.stack.length === 0;
     }
 }
 

lcci/04.06.Successor/README.md

@@ -37,8 +37,6 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-
-
 <!-- tabs:start -->
 
 ### **Python3**
@@ -225,17 +223,17 @@ func inorderSuccessor(root *TreeNode, p *TreeNode) *TreeNode {
  */
 var inorderSuccessor = function (root, p) {
     if (root == null) {
-        return root
+        return root;
     }
-    const { val, left, right } = root
-    const res = inorderSuccessor(left, p)
+    const { val, left, right } = root;
+    const res = inorderSuccessor(left, p);
     if (res != null) {
-        return res
+        return res;
     }
     if (val > p.val) {
-        return root
+        return root;
     }
-    return inorderSuccessor(right, p)
+    return inorderSuccessor(right, p);
 };
 ```
 

lcci/04.06.Successor/README_EN.md

@@ -236,17 +236,17 @@ func inorderSuccessor(root *TreeNode, p *TreeNode) *TreeNode {
  */
 var inorderSuccessor = function (root, p) {
     if (root == null) {
-        return root
+        return root;
     }
-    const { val, left, right } = root
-    const res = inorderSuccessor(left, p)
+    const { val, left, right } = root;
+    const res = inorderSuccessor(left, p);
     if (res != null) {
-        return res
+        return res;
     }
     if (val > p.val) {
-        return root
+        return root;
     }
-    return inorderSuccessor(right, p)
+    return inorderSuccessor(right, p);
 };
 ```
 

lcof/面试题13. 机器人的运动范围/README.md

@@ -39,8 +39,8 @@
 
 2. 根据公式判断 `(i, j)` 是否可进入：
 
-   - 可进入，并继续往右 `(i, j + 1)` 往下 `(i + 1, j)` 重新执行流程 2。
-   - 不可进入，退出结算。
+    - 可进入，并继续往右 `(i, j + 1)` 往下 `(i + 1, j)` 重新执行流程 2。
+    - 不可进入，退出结算。
 
 3. 计算可进入区域的数量，返回即可。
 

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

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

solution/0000-0099/0006.Zigzag Conversion/README.md

@@ -30,6 +30,7 @@ string convert(string s, int numRows);</pre>
 <strong>输入：</strong>s = "PAYPALISHIRING", numRows = 3
 <strong>输出：</strong>"PAHNAPLSIIGYIR"
 </pre>
+
 <strong>示例 2：</strong>
 
 <pre>
@@ -59,7 +60,6 @@ P     I
 	<li><code>1 <= numRows <= 1000</code></li>
 </ul>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->