feat: refresh README files

Author: yanglbme

solution/0000-0099/0001.Two Sum/README.md

@@ -1,47 +1,36 @@
-# [1. 两数之和](https://leetcode-cn.com/problems/two-sum/)
+# [1. 两数之和](https://leetcode-cn.com/problems/two-sum)
 
 ## 题目描述
 <!-- 这里写题目描述 -->
+<p>给定一个整数数组 <code>nums</code>&nbsp;和一个目标值 <code>target</code>，请你在该数组中找出和为目标值的那&nbsp;<strong>两个</strong>&nbsp;整数，并返回他们的数组下标。</p>
 
-给定一个整数数组 `nums` 和一个目标值 `target`，请你在该数组中找出和为目标值的那**两个**整数，并返回他们的数组下标。
+<p>你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。</p>
 
-你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
+<p><strong>示例:</strong></p>
 
-**示例:**
+<pre>给定 nums = [2, 7, 11, 15], target = 9
+
+因为 nums[<strong>0</strong>] + nums[<strong>1</strong>] = 2 + 7 = 9
+所以返回 [<strong>0, 1</strong>]
+</pre>
 
-```
-给定 nums = [2, 7, 11, 15], target = 9
 
-因为 nums[0] + nums[1] = 2 + 7 = 9
-所以返回 [0, 1]
-```
 
 ## 解法
 <!-- 这里可写通用的实现逻辑 -->
-利用 HashMap 记录数组元素值和对应的下标，对于一个数 nums[i]，判断 `target - nums[i]` 是否存在 HashMap 中，存在的话，返回两个下标组成的数组。注意，已存在的元素下标在前，当前元素下标在后。
 
-### Java
+
+### Python3
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
-```java
-class Solution {
-    public int[] twoSum(int[] nums, int target) {
-        Map<Integer, Integer> map = new HashMap<>();
-        for (int i = 0; i < nums.length; ++i) {
-            if (map.containsKey(target - nums[i])) {
-                return new int[] {map.get(target - nums[i]), i};
-            }
-            map.put(nums[i], i);
-        }
-        return null;
-    }
-}
+```python
+
 ```
 
-### Python3
+### Java
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
-```python
+```java
 
 ```
 

solution/0000-0099/0002.Add Two Numbers/README.md

@@ -1,93 +1,41 @@
-# [2. 两数相加](https://leetcode-cn.com/problems/add-two-numbers/)
+# [2. 两数相加](https://leetcode-cn.com/problems/add-two-numbers)
 
 ## 题目描述
 <!-- 这里写题目描述 -->
-给出两个**非空**的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储**一位**数字。
+<p>给出两个&nbsp;<strong>非空</strong> 的链表用来表示两个非负的整数。其中，它们各自的位数是按照&nbsp;<strong>逆序</strong>&nbsp;的方式存储的，并且它们的每个节点只能存储&nbsp;<strong>一位</strong>&nbsp;数字。</p>
 
-如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
+<p>如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。</p>
 
-您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
+<p>您可以假设除了数字 0 之外，这两个数都不会以 0&nbsp;开头。</p>
+
+<p><strong>示例：</strong></p>
+
+<pre><strong>输入：</strong>(2 -&gt; 4 -&gt; 3) + (5 -&gt; 6 -&gt; 4)
+<strong>输出：</strong>7 -&gt; 0 -&gt; 8
+<strong>原因：</strong>342 + 465 = 807
+</pre>
 
-**示例：**
 
-```
-输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
-输出：7 -> 0 -> 8
-原因：342 + 465 = 807
-```
 
 ## 解法
 <!-- 这里可写通用的实现逻辑 -->
-同时遍历两个链表，对应值相加(还有 quotient)求余数得到值并赋给新创建的结点。而商则用 quotient 存储，供下次相加。
+
+
+### Python3
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```python
+
+```
 
 ### Java
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
-        ListNode res = new ListNode(-1);
-        ListNode cur = res;
-        int quotient = 0;
-        while (l1 != null || l2 != null || quotient != 0) {
-            int t = (l1 == null ? 0 : l1.val) + (l2 == null ? 0 : l2.val) + quotient;
-            quotient = t / 10;
-            ListNode node = new ListNode(t % 10);
-            cur.next = node;
-            cur = node;
-            l1 = (l1 == null) ? l1 : l1.next;
-            l2 = (l2 == null) ? l2 : l2.next;
-        }
-        return res.next;
-    }
-}
+
+```
+
+### ...
 ```
 
-### CPP
-```cpp
-class Solution {
-public:
-    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
-
-        ListNode *ans_l = new ListNode(0);
-        ListNode *head = ans_l;
-        int tmp = 0;
-        while(l1 != NULL && l2 != NULL){
-            tmp += l1->val + l2->val;
-            ans_l->next = new ListNode(tmp % 10);
-            tmp = tmp / 10;
-            ans_l = ans_l->next;
-            l1 = l1->next;
-            l2 = l2->next;
-        }
-        
-        while(l1 != NULL){
-            tmp += l1->val;
-            ans_l->next = new ListNode(tmp % 10);
-            tmp = tmp / 10;
-            ans_l = ans_l->next;
-            l1 = l1->next;  
-        }
-        
-        while(l2 != NULL){
-            tmp += l2->val;
-            ans_l->next = new ListNode(tmp % 10);
-            tmp = tmp / 10;
-            ans_l = ans_l->next;
-            l2 = l2->next;  
-        }
-        
-        if(tmp)ans_l->next = new ListNode(tmp);
-
-        return head->next;
-    }
-};
 ```

solution/0000-0099/0003.Longest Substring Without Repeating Characters/README.md

@@ -1,66 +1,49 @@
-# [3. 无重复字符的最长子串](https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/)
+# [3. 无重复字符的最长子串](https://leetcode-cn.com/problems/longest-substring-without-repeating-characters)
 
 ## 题目描述
 <!-- 这里写题目描述 -->
-给定一个字符串，请你找出其中不含有重复字符的**最长子串**的长度。
+<p>给定一个字符串，请你找出其中不含有重复字符的&nbsp;<strong>最长子串&nbsp;</strong>的长度。</p>
 
-**示例 1:**
+<p><strong>示例&nbsp;1:</strong></p>
 
-```
-输入: "abcabcbb"
-输出: 3 
-解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
-```
+<pre><strong>输入: </strong>&quot;abcabcbb&quot;
+<strong>输出: </strong>3 
+<strong>解释:</strong> 因为无重复字符的最长子串是 <code>&quot;abc&quot;，所以其</code>长度为 3。
+</pre>
 
-**示例 2:**
+<p><strong>示例 2:</strong></p>
 
-```
-输入: "bbbbb"
-输出: 1
-解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
-```
+<pre><strong>输入: </strong>&quot;bbbbb&quot;
+<strong>输出: </strong>1
+<strong>解释: </strong>因为无重复字符的最长子串是 <code>&quot;b&quot;</code>，所以其长度为 1。
+</pre>
+
+<p><strong>示例 3:</strong></p>
+
+<pre><strong>输入: </strong>&quot;pwwkew&quot;
+<strong>输出: </strong>3
+<strong>解释: </strong>因为无重复字符的最长子串是&nbsp;<code>&quot;wke&quot;</code>，所以其长度为 3。
+&nbsp;    请注意，你的答案必须是 <strong>子串 </strong>的长度，<code>&quot;pwke&quot;</code>&nbsp;是一个<em>子序列，</em>不是子串。
+</pre>
 
-**示例 3:**
 
-```
-输入: "pwwkew"
-输出: 3
-解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
-     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
-```
 
 ## 解法
 <!-- 这里可写通用的实现逻辑 -->
-利用指针 `p`, `q`，初始指向字符串开头。遍历字符串，`q` 向右移动，若指向的字符在 map 中，说明出现了重复字符，此时，`p` 要在出现**重复字符的下一个位置** `map.get(chars[q]) + 1` 和**当前位置** `p` 之间取较大值，防止 `p` 指针回溯。循环的过程中，要将 chars[q] 及对应位置放入 map 中，也需要不断计算出`max` 与 `q - p + 1` 的较大值，赋给 `max`。最后输出 `max` 即可。
+
+
+### Python3
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```python
+
+```
 
 ### Java
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-class Solution {
-    public int lengthOfLongestSubstring(String s) {
-        if (s == null || s.length() == 0) {
-            return 0;
-        }
-        char[] chars = s.toCharArray();
-        int len = chars.length;
-        int p = 0, q = 0;
-        int max = 0;
-        Map<Character, Integer> map = new HashMap<>();
-        while (q < len) {
-            if (map.containsKey(chars[q])) {
-                // 防止p指针回溯，导致计算到重复字符的长度
-                // eg. abba,当q指向最右的a时，若简单把p赋为map.get(chars[q] + 1)，则出现指针回溯
-                p = Math.max(p, map.get(chars[q]) + 1);
-            }
-            map.put(chars[q], q);
-            max = Math.max(max, q - p + 1);
-            ++q;
-        }
-        
-        return max;
-    }
-}
+
 ```
 
 ### ...