();
+ while (i < s.length()) {
+ c = s.charAt(i);
+ for (int j = 0; j <= 2; j++) {
+ if (c == parentheses[j]) {
+ top.push(j);
+ sum[j]++;
+ } else if (c == parentheses[j + 3]) {
+ if (top.size() == 0 || top.peek() != j) {
+ return false;
+ }
+ top.pop();
+ sum[j]--;
+ } else {
+ }
+ }
+ i++;
+ }
+ for (int j = 0; j <= 2; j++) {
+ if (sum[j] != 0) {
+ return false;
+ }
+ }
+ return true;
+ }
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/29.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/29.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..f5d58b062ca129b563d5d560f8b9450fcfbaf7ea
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/29.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-4f3c7b15887f459a9f5ed357a5a2d2c5",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/29.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/29.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..64e8d20b404a2aff742b2606efa93adde2f275b1
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/29.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "9ac3287c096a477da064f21a23419fa9"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/29.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/29.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..7db8a0debe9464eb7a58db9219707711b68016b4
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/29.exercises/solution.md"
@@ -0,0 +1,85 @@
+# 合并两个有序链表
+
+将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：
输入：l1 = [], l2 = []
输出：[]
示例 3：
输入：l1 = [], l2 = [0]
输出：[0]
提示：
- 两个链表的节点数目范围是
[0, 50] -100 <= Node.val <= 100l1 和 l2 均按 非递减顺序 排列
+
+## template
+
+```python
+class ListNode:
+ def __init__(self, val=0, next=None):
+ self.val = val
+ self.next = next
+class LinkList:
+ def __init__(self):
+ self.head=None
+ def initList(self, data):
+ self.head = ListNode(data[0])
+ r=self.head
+ p = self.head
+ for i in data[1:]:
+ node = ListNode(i)
+ p.next = node
+ p = p.next
+ return r
+ def convert_list(self,head):
+ ret = []
+ if head == None:
+ return
+ node = head
+ while node != None:
+ ret.append(node.val)
+ node = node.next
+ return ret
+class Solution:
+ def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
+ h = ListNode(0, None)
+ p = h
+ while l1 and l2:
+ if l1.val < l2.val:
+ p.next = l1
+ p = l1
+ l1 = l1.next
+ else:
+ p.next = l2
+ p = l2
+ l2 = l2.next
+ if l1:
+ p.next = l1
+ else:
+ p.next = l2
+ return h.next
+# %%
+l = LinkList()
+list1 = [1,2,4]
+list2 = [1,3,4]
+l1 = l.initList(list1)
+l2 = l.initList(list2)
+s = Solution()
+print(l.convert_list(s.mergeTwoLists(l1, l2)))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/30.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/30.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..c009f8f087a771a76c70123505f3617ac3e37af4
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/30.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-00bfb01d3da44cca9cfe76a6531eac76",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/30.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/30.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..5463d84c453b247d4282c7bcc1c7843c9905f2a4
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/30.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/qiyuangong/leetcode",
+ "source": "solution.md",
+ "exercise_id": "3261b48810d048e987bcc2fcbb159bb2"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/30.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/30.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2f9e69d9b057d343e45301fff8be25238a641ead
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/30.exercises/solution.md"
@@ -0,0 +1,51 @@
+# 最后一个单词的长度
+
+给你一个字符串 s，由若干单词组成，单词之间用空格隔开。返回字符串中最后一个单词的长度。如果不存在最后一个单词，请返回 0 。
单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
示例 1：
输入：s = "Hello World"
输出：5
示例 2：
输入：s = " "
输出：0
提示：
1 <= s.length <= 104s 仅有英文字母和空格 ' ' 组成
+
+## template
+
+```python
+class Solution(object):
+ def lengthOfLastWord(self, s):
+ """
+ :type s: str
+ :rtype: int
+ """
+ if len(s) == 0:
+ return 0
+ temp = s.split(' ')
+ temp = [t for t in temp if len(t) > 0]
+ if len(temp) == 0:
+ return 0
+ else:
+ return len(temp[-1])
+# %%
+s = Solution()
+print(s.lengthOfLastWord(s = "Hello World"))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/31.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/31.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..aa6a828dbf9a414cbc7833e9553962c4a5de2172
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/31.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-7956ce00cccd4a3999c0d9cfde90dbbe",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/31.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/31.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..0f4dc7aa9340cd45cedb1fe0421febedf3e8e4f6
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/31.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/qiyuangong/leetcode",
+ "source": "solution.md",
+ "exercise_id": "2ff1b7903a4b48cb8575ce8793869078"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/31.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/31.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f722fa51af297a1d9ba2874da4fa3d57198fa99b
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/31.exercises/solution.md"
@@ -0,0 +1,76 @@
+# 删除排序链表中的重复元素
+
+存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素 只出现一次 。
返回同样按升序排列的结果链表。
示例 1：
输入：head = [1,1,2]
输出：[1,2]
示例 2：
输入：head = [1,1,2,3,3]
输出：[1,2,3]
提示：
- 链表中节点数目在范围
[0, 300] 内 -100 <= Node.val <= 100- 题目数据保证链表已经按升序排列
+
+## template
+
+```python
+class ListNode(object):
+ def __init__(self, x):
+ self.val = x
+ self.next = None
+class LinkList:
+ def __init__(self):
+ self.head=None
+ def initList(self, data):
+ self.head = ListNode(data[0])
+ r=self.head
+ p = self.head
+ for i in data[1:]:
+ node = ListNode(i)
+ p.next = node
+ p = p.next
+ return r
+ def convert_list(self,head):
+ ret = []
+ if head == None:
+ return
+ node = head
+ while node != None:
+ ret.append(node.val)
+ node = node.next
+ return ret
+class Solution(object):
+ def deleteDuplicates(self, head):
+ if head is None:
+ return None
+ pos = head
+ while pos is not None and pos.next is not None:
+ if pos.val == pos.next.val:
+ pos.next = pos.next.next
+ else:
+ pos = pos.next
+ return head
+# %%
+l = LinkList()
+list1 = [1,1,2]
+l1 = l.initList(list1)
+s = Solution()
+print(l.convert_list(s.deleteDuplicates(l1)))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/32.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/32.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..42201c9d8529ee633985a802306609e978715e2e
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/32.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-001f31de7edb42d78c8846370eb347c4",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/32.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/32.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..f03b258635f68c437aeba662d46fb80bc0755df1
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/32.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "30e3695ecdfc42c4a6f6bd6280d31976"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/32.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/32.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6ef63f9bf7ada853bed44c6f7ce1d87e3e7bebdc
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/32.exercises/solution.md"
@@ -0,0 +1,52 @@
+# 整数反转
+
+给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。
假设环境不允许存储 64 位整数（有符号或无符号）。
示例 1：
输入：x = 123
输出：321
示例 2：
输入：x = -123
输出：-321
示例 3：
输入：x = 120
输出：21
示例 4：
输入：x = 0
输出：0
提示：
+
+## template
+
+```python
+import math
+class Solution:
+ def reverse(self, x: int) -> int:
+ r = 0
+ y = 0
+ abs_x = abs(x)
+ negative = x < 0
+ while abs_x != 0:
+ r = abs_x % 10
+ y = y*10+r
+ abs_x = int(math.floor(abs_x/10))
+ if negative:
+ y = -y
+ return 0 if (y > 2147483647 or y < -2147483648) else y
+# %%
+s = Solution()
+print(s.reverse(x = 123))
+print(s.reverse(x = -123))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/33.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/33.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..32c57aeb2c02601e7b008593a3bdfa5e4c3aec28
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/33.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-1de916c760364a33ade2a9c1f9fa16e4",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/33.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/33.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..fc4870184050a074657db58ce639d675f2cab7ce
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/33.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/qiyuangong/leetcode",
+ "source": "solution.md",
+ "exercise_id": "d590d2be2d394bb1a5f628b86d61d2ca"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/33.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/33.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..78b7525a4efe6dc8b21da521508a4ef3a8ed0e39
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/33.exercises/solution.md"
@@ -0,0 +1,60 @@
+# 相同的树
+
+给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
示例 1：
输入：p = [1,2,3], q = [1,2,3]
输出：true
示例 2：
输入：p = [1,2], q = [1,null,2]
输出：false
示例 3：
输入：p = [1,2,1], q = [1,1,2]
输出：false
提示：
- 两棵树上的节点数目都在范围
[0, 100] 内 -104 <= Node.val <= 104
+
+## template
+
+```python
+class TreeNode(object):
+ def __init__(self, x):
+ self.val = x
+ self.left = None
+ self.right = None
+class Solution(object):
+ def isSameTree(self, p, q):
+ """
+ :type p: TreeNode
+ :type q: TreeNode
+ :rtype: bool
+ """
+ if p == q:
+ return True
+ try:
+ left = right = True
+ if p.val == q.val:
+ left = self.isSameTree(p.left, q.left)
+ right = self.isSameTree(p.right, q.right)
+ return (left and right)
+ except:
+ return False
+ return False
+# %%
+s = Solution()
+print(s.isSameTree(p = [1,2,3], q = [1,2,3]))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/34.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/34.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..a63fda450260d7aa5833f246134e2a56620717a5
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/34.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-204407449dbf419887a4a1fdd5c2b289",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/34.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/34.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..6de04884cde41229d748601b3087a53e5a5b1bd3
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/34.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "c407b9a49c674f908dc63e4faf454a74"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/34.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/34.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..b979030a6fed5a499ea0a3832318cf8cb27c857e
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/34.exercises/solution.md"
@@ -0,0 +1,48 @@
+# 两数之和
+
+给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]
提示：
2 <= nums.length <= 103-109 <= nums[i] <= 109-109 <= target <= 109- 只会存在一个有效答案
+
+## template
+
+```python
+def twoSum(nums, target):
+ cache = {}
+ i = 0
+ while i < len(nums):
+ right = target-nums[i]
+ if cache.get(right) is not None:
+ return [cache[right], i]
+ else:
+ cache[nums[i]] = i
+ i += 1
+ return []
+# %%
+print(twoSum([2,7,11,15], 9))
+print(twoSum([3,2,4], 6))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/35.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/35.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..49630a88ce57095c99fecfe1741a1d2b71bee29f
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/35.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-5e8ca5819d1c488cb2bad8b6555eff46",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/35.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/35.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..cb8fc01a0b7c1b04c136d1497922a533a6b34c7f
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/35.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/qiyuangong/leetcode",
+ "source": "solution.md",
+ "exercise_id": "f2791852919f44519b1a39e3a9ffbed5"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/35.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/35.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..7265bb72bff35b6cd8d3c9ac64732c743b28559c
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/35.exercises/solution.md"
@@ -0,0 +1,106 @@
+# 移除元素
+
+
+
给你一个数组 nums 和一个值 val，你需要 原地
+ 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
+
+
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
+
+
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
+
+
+
+
说明:
+
+
为什么返回数值是整数，但输出的答案是数组呢?
+
+
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
+
+
你可以想象内部操作如下:
+
+
// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
+int len = removeElement(nums, val);
+
+// 在函数里修改输入数组对于调用者是可见的。
+// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
+for (int i = 0; i < len; i++) {
+ print(nums[i]);
+}
+
+
+
+
+
示例 1：
+
+
输入：nums = [3,2,2,3], val = 3
+
输出：2, nums = [2,2]
+
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。
+
+
+
示例 2：
+
+
输入：nums = [0,1,2,2,3,0,4,2], val = 2
+
输出：5, nums = [0,1,4,0,3]
+
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
+
+
+
+
+
提示：
+
+
+ 0 <= nums.length <= 1000 <= nums[i] <= 500 <= val <= 100
+
给你两个二进制字符串，返回它们的和（用二进制表示）。
输入为 非空 字符串且只包含数字 1 和 0。
示例 1:
输入: a = "11", b = "1"
输出: "100"
示例 2:
输入: a = "1010", b = "1011"
输出: "10101"
提示：
- 每个字符串仅由字符
'0' 或 '1' 组成。 1 <= a.length, b.length <= 10^4- 字符串如果不是
"0" ，就都不含前导零。
+
+## template
+
+```python
+class Solution(object):
+ def addBinary(self, a, b):
+ res = ''
+ lsa, lsb = len(a), len(b)
+ pos, plus, curr = -1, 0, 0
+ while (lsa + pos) >= 0 or (lsb + pos) >= 0:
+ if (lsa + pos) >= 0:
+ curr += int(a[pos])
+ if (lsb + pos) >= 0:
+ curr += int(b[pos])
+ res = str(curr % 2) + res
+ curr //= 2
+ pos -= 1
+ if curr == 1:
+ res = '1' + res
+ return res
+# %%
+s = Solution()
+print(s.addBinary(a = "1010", b = "1011"))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/37.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/37.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..5f8ce838455d97cfae65a05e06f3c30ee7868b39
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/37.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-18a0ca8bcade419ba764e62293cbdc1b",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/37.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/37.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..23add5f1ef7fb9d1a767ead3b4ef60ebd11dcfce
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/37.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/qiyuangong/leetcode",
+ "source": "solution.md",
+ "exercise_id": "2f70ab6ca0624535856442ef72276287"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/37.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/37.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..a14cb25ea894637a29b4914b4dabd9cf2c206555
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/37.exercises/solution.md"
@@ -0,0 +1,101 @@
+# 二叉树的中序遍历
+
+给定一个二叉树的根节点 root ，返回它的 中序 遍历。
示例 1：
输入：root = [1,null,2,3]
输出：[1,3,2]
示例 2：
输入：root = []
输出：[]
示例 3：
输入：root = [1]
输出：[1]
示例 4：
输入：root = [1,2]
输出：[2,1]
示例 5：
输入：root = [1,null,2]
输出：[1,2]
提示：
- 树中节点数目在范围
[0, 100] 内 -100 <= Node.val <= 100
进阶: 递归算法很简单，你可以通过迭代算法完成吗？
+
+## template
+
+```python
+class TreeNode(object):
+ def __init__(self, x):
+ self.val = x
+ self.left = None
+ self.right = None
+class List2Tree(object):
+ def __init__(self, nums: list):
+ self.nums = nums
+ self.queue = []
+ if len(nums) == 1:
+ self.root = TreeNode(self.nums.pop(0))
+ else:
+ a = self.nums.pop(0)
+ b = self.nums.pop(0)
+ c = self.nums.pop(0)
+ self.root = TreeNode(a)
+ if b is not None:
+ self.root.left = TreeNode(b)
+ else:
+ self.root.left = b
+ if c is not None:
+ self.root.right = TreeNode(c)
+ else:
+ self.root.right = c
+ self.queue.append(self.root.left)
+ self.queue.append(self.root.right)
+ def convert(self):
+ while len(self.nums) > 0 and len(self.queue)> 0:
+ node = self.queue.pop(0)
+ if node is not None:
+ num= self.nums.pop(0)
+ if num is not None:
+ node.left = TreeNode(num)
+ else:
+ node.left = num
+ if len(self.nums) > 0:
+ num = self.nums.pop(0)
+ else:
+ num = None
+ if num is not None:
+ node.right = TreeNode(num)
+ else:
+ node.right = num
+ self.queue.append(node.left)
+ self.queue.append(node.right)
+ return self.root
+class Solution(object):
+ def inorderTraversal(self, root):
+ if root is None:
+ return []
+ root = List2Tree(root).convert()
+ res = []
+ stack = [root]
+ while len(stack) > 0:
+ curr = stack.pop()
+ if not isinstance(curr, TreeNode):
+ res.append(curr)
+ continue
+ if curr.right is not None:
+ stack.append(curr.right)
+ stack.append(curr.val)
+ if curr.left is not None:
+ stack.append(curr.left)
+ return res
+# %%
+s = Solution()
+print(s.inorderTraversal(root = [1,None,2,3]))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/38.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/38.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..de9304fac20c7f3356e8f0e07c6dc87b8fc50164
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/38.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-b4b61470dce44ff38498ca9b9ad4d0a6",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/38.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/38.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..650545a921c08224a00f15fac9c3335bf569281c
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/38.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/qiyuangong/leetcode",
+ "source": "solution.md",
+ "exercise_id": "31603bf0cd9940eaba90854ce5a386be"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/38.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/38.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..58e00d2bfce57b93290b7f67fa2c3884ebba8749
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/38.exercises/solution.md"
@@ -0,0 +1,45 @@
+# 爬楼梯
+
+假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
示例 1：
输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。1. 1 阶 + 1 阶2. 2 阶
示例 2：
输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。1. 1 阶 + 1 阶 + 1 阶2. 1 阶 + 2 阶3. 2 阶 + 1 阶
+
+## template
+
+```python
+class Solution(object):
+ def climbStairs(self, n):
+ if n <= 1:
+ return 1
+ dp = [1] * 2
+ for i in range(2, n + 1):
+ dp[1], dp[0] = dp[1] + dp[0], dp[1]
+ return dp[1]
+# %%
+s = Solution()
+print(s.climbStairs(2))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/39.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/39.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..462fb550061d81904f26ab280e569d5f867ae7fd
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/39.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-09a8f5ced6c9482da440800ce5e1f566",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/39.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/39.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..e1cf338146cdc5ba7df2b41829ecfde21f51322d
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/39.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "31aeaffaae294a77bd8036cd3ae7b48d"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/39.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/39.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d9aae195f0727d5de5417bccbd6360b439ec0c53
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/39.exercises/solution.md"
@@ -0,0 +1,136 @@
+# 罗马数字转整数
+
+
+
罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。
+
+
+
字符 数值
+I 1
+V 5
+X 10
+L 50
+C 100
+D 500
+M 1000
+
+
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12
+ 写做 XII ，即为 X + II 。 27
+ 写做 XXVII,
+ 即为 XX + V + II 。
+
+
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5
+ 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
+
+
+ I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。X 可以放在 L (50) 和 C (100) 的左边，来表示 40
+ 和 90。 C 可以放在 D (500) 和 M (1000) 的左边，来表示 400
+ 和 900。
+
+
给你一个整数，将其转为罗马数字。
+
+
+
+
示例 1:
+
+
输入: num = 3
+
输出: "III"
+
+
示例 2:
+
+
输入: num = 4
+
输出: "IV"
+
+
示例 3:
+
+
输入: num = 9
+
输出: "IX"
+
+
示例 4:
+
+
输入: num = 58
+
输出: "LVIII"
+
解释: L = 50, V = 5, III = 3.
+
+
+
示例 5:
+
+
输入: num = 1994
+
输出: "MCMXCIV"
+
解释: M = 1000, CM = 900, XC = 90, IV = 4.
+
+
+
+
提示：
+
+
+
给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 1：
输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。
示例 2：
输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。
示例 3：
输入：digits = [0]
输出：[1]
提示：
1 <= digits.length <= 1000 <= digits[i] <= 9
+
+## template
+
+```python
+class Solution(object):
+ def plusOne(self, digits):
+ ls = len(digits)
+ for index in reversed(range(ls)):
+ if digits[index] < 9:
+ digits[index] += 1
+ return digits
+ else:
+ digits[index] = 0
+ digits.insert(0, 1)
+ return digits
+# %%
+s = Solution()
+print(s.plusOne(digits = [1,2,3]))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/41.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/41.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..8b437b43e24816be6f0b3520f3d8c652479db1cd
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/41.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-4c6bf3ab14be4b04976c103c08a46cfe",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/41.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/41.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..81b4fc96c46b1e068129075a7391568a0fd3b1b3
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/41.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/qiyuangong/leetcode",
+ "source": "solution.md",
+ "exercise_id": "e066a6c1e2824ca7921dac06541efb00"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/41.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/41.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d6ed9a3ebc672fb7b9f3efc9857314ade6d1160c
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/41.exercises/solution.md"
@@ -0,0 +1,102 @@
+# 删除有序数组中的重复项
+
+
+
给你一个有序数组 nums ，请你
+ 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
+
+
不要使用额外的数组空间，你必须在 原地
+ 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
+
+
+
+
说明:
+
+
为什么返回数值是整数，但输出的答案是数组呢?
+
+
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
+
+
你可以想象内部操作如下:
+
+
// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
+int len = removeDuplicates(nums);
+
+// 在函数里修改输入数组对于调用者是可见的。
+// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
+for (int i = 0; i < len; i++) {
+ print(nums[i]);
+}
+
+
+
+
示例 1：
+
+
输入：nums = [1,1,2]
+
输出：2, nums = [1,2]
+
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
+
+
+
示例 2：
+
+
输入：nums = [0,0,1,1,1,2,2,3,3,4]
+
输出：5, nums = [0,1,2,3,4]
+
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
+
+
+
+
+
提示：
+
+
+ 0 <= nums.length <= 3 * 104-104 <= nums[i] <= 104nums 已按升序排列
+
+
+
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 ""。
示例 1：
输入：strs = ["flower","flow","flight"]
输出："fl"
示例 2：
输入：strs = ["dog","racecar","car"]
输出：""
解释：输入不存在公共前缀。
提示：
0 <= strs.length <= 2000 <= strs[i].length <= 200strs[i] 仅由小写英文字母组成
+
+## template
+
+```python
+from typing import List
+class Solution:
+ def longestCommonPrefix(self, strs: List[str]) -> str:
+ if len(strs) == 0:
+ return ''
+ i = 0
+ lcp = []
+ while True:
+ done = False
+ if i >= len(strs[0]):
+ break
+ j = 0
+ while j < len(strs):
+ if i < len(strs[j]):
+ if strs[j][i] != strs[0][i]:
+ done = True
+ break
+ else:
+ done = True
+ break
+ j += 1
+ if not done:
+ lcp.append(strs[0][i])
+ i += 1
+ else:
+ break
+ return ''.join(lcp)
+# %%
+s = Solution()
+print(s.longestCommonPrefix(strs = ["flower","flow","flight"]))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/43.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/43.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..4b251a38c0897e13343300f30428945def3cd1ff
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/43.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-2ece2e38afba49ff90a4608ad37c820e",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/43.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/43.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..df7b626d8632d223bacbd204debd38b11f9333de
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/43.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/qiyuangong/leetcode",
+ "source": "solution.md",
+ "exercise_id": "6cf30522972249b1998cdbff69d7937f"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/43.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/43.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9ea9d2c19a1c115e0503a7da00194278afa1b62e
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/43.exercises/solution.md"
@@ -0,0 +1,44 @@
+# 最大子序和
+
+给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
示例 1：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
示例 2：
输入：nums = [1]
输出：1
示例 3：
输入：nums = [0]
输出：0
示例 4：
输入：nums = [-1]
输出：-1
示例 5：
输入：nums = [-100000]
输出：-100000
提示：
1 <= nums.length <= 3 * 104-105 <= nums[i] <= 105
进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。
+
+## template
+
+```python
+class Solution(object):
+ def maxSubArray(self, nums):
+ maxEndingHere = maxSofFar = nums[0]
+ for i in range(1, len(nums)):
+ maxEndingHere = max(maxEndingHere + nums[i], nums[i])
+ maxSofFar = max(maxEndingHere, maxSofFar)
+ return maxSofFar
+# %%
+s = Solution()
+print(s.maxSubArray(nums = [-2,1,-3,4,-1,2,1,-5,4]))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/44.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/44.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..8c88860474aff4cda3b63ed3cd087770214097c2
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/44.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-15d3636528c242ffa88a424c545b62fa",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/44.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/44.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..50136e497cc988070dd15203ad7f8189c62e574d
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/44.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/qiyuangong/leetcode",
+ "source": "solution.md",
+ "exercise_id": "af61d928fa1d4e3abaebdc4f31e82491"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/44.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/44.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..4efdc3e0b60bacd69113b0a617e821ea4f5791e6
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/44.exercises/solution.md"
@@ -0,0 +1,53 @@
+# x 的平方根
+
+实现 int sqrt(int x) 函数。
+计算并返回 x 的平方根，其中 x 是非负整数。
+由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
+示例 1:
+输入: 4
输出: 2
+示例 2:
+输入: 8
输出: 2
说明: 8 的平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。
+
+## template
+
+```python
+class Solution:
+ def mySqrt(self, x):
+ if x == 0:
+ return 0
+ if x < 4:
+ return 1
+ res = 2 * self.mySqrt(x / 4)
+ if (res + 1) * (res + 1) <= x and (res + 1) * (res + 1) >= 0:
+ return res + 1
+ return res
+# %%
+s = Solution()
+print(s.mySqrt(4))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/45.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/45.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..dd53d4adebd0127b5aab20c8e08945b93287a547
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/45.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-b0eaa36ecf6b4283a1816a7af434be8f",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/45.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/45.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d0d9e00e58c34ec36f2e1fb5b49fd0f8d7612f21
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/45.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/qiyuangong/leetcode",
+ "source": "solution.md",
+ "exercise_id": "08ebef8b6e194a40af8a496863fd133b"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/45.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/45.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c75db96d49951054aaed30119dd8c0f8ad74c840
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/45.exercises/solution.md"
@@ -0,0 +1,61 @@
+# 合并两个有序数组
+
+给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。
初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间大小等于 m + n，这样它就有足够的空间保存来自 nums2 的元素。
示例 1：
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
示例 2：
输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
提示：
nums1.length == m + nnums2.length == n0 <= m, n <= 2001 <= m + n <= 200-109 <= nums1[i], nums2[i] <= 109
+
+## template
+
+```python
+class Solution(object):
+ def merge(self, nums1, m, nums2, n):
+ """
+ :type nums1: List[int]
+ :type m: int
+ :type nums2: List[int]
+ :type n: int
+ :rtype: void Do not return anything, modify nums1 in-place instead.
+ """
+ p1, p2 = m - 1, n - 1
+ pos = m + n - 1
+ while p1 >= 0 and p2 >= 0:
+ if nums1[p1] >= nums2[p2]:
+ nums1[pos] = nums1[p1]
+ p1 -= 1
+ else:
+ nums1[pos] = nums2[p2]
+ p2 -= 1
+ pos -= 1
+ while p2 >= 0:
+ nums1[pos] = nums2[p2]
+ p2 -= 1
+ pos -= 1
+ return nums1
+# %%
+s = Solution()
+print(s.merge(nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/46.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/46.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..a317864a9a532c083d9442e1cdbd5dfb8fb672e7
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/46.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-45af9780672b457dbe082fbe45f84648",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/46.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/46.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..79f261e743fde5ff481050253bfbd49562f71000
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/46.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/qiyuangong/leetcode",
+ "source": "solution.md",
+ "exercise_id": "48c33d365de549de901a6fd1c89721b4"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/46.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/46.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..11c890f5389b36b4581241aa9357d27a46aed3c2
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/46.exercises/solution.md"
@@ -0,0 +1,49 @@
+# 搜索插入位置
+
+给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5
输出: 2
示例 2:
输入: [1,3,5,6], 2
输出: 1
示例 3:
输入: [1,3,5,6], 7
输出: 4
示例 4:
输入: [1,3,5,6], 0
输出: 0
+
+## template
+
+```python
+class Solution:
+ def searchInsert(self, nums, target):
+ l, r = int(0), len(nums) - 1
+ while l < r:
+ mid = int((l + r) / 2)
+ if nums[mid] < target:
+ l = mid + 1
+ else:
+ r = mid
+ if nums[l] < target:
+ return l + 1
+ return l
+if __name__ == '__main__':
+ s = Solution()
+ print (s.searchInsert([1,3,5,6],5))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/47.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/47.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..7cd34431d73ee7ead0eec759f546de695ed9655c
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/47.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-caacbea4ef72485bb69a4ccb76b38add",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/47.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/47.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..9afec6b13733e3eebafe766e6dc6a2df63f6cc89
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/47.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "50473072072a428383f918538f4dab36"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/47.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/47.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..47619fdb1a112e9d315a4dfa663502aa1a892db3
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/47.exercises/solution.md"
@@ -0,0 +1,47 @@
+# 回文数
+
+给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。
示例 1：
输入：x = 121
输出：true
示例 2：
输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3：
输入：x = 10
输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数。
示例 4：
输入：x = -101
输出：false
提示：
进阶：你能不将整数转为字符串来解决这个问题吗？
+
+## template
+
+```python
+import math
+class Solution:
+ def isPalindrome(self, x: int) -> bool:
+ o = x
+ y = 0
+ while x > 0:
+ r = x % 10
+ y = y*10+r
+ x = int(math.floor(x/10))
+ return y == o
+# %%
+s = Solution()
+print(s.isPalindrome(x = 121))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/48.exercises/config.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/48.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..bbce88ffb99aa78e940b74f984e9f32b8daa3403
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/48.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-faea9649ace444d8becd03ed79d8e758",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/48.exercises/solution.json" "b/data/1.dailycode\345\210\235\351\230\266/3.python/48.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..c3266421bd6c333c9b14edd997ce0d4203e45241
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/48.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "ef130924f9d34936a921870237cb7337"
+}
\ No newline at end of file
diff --git "a/data/1.dailycode\345\210\235\351\230\266/3.python/48.exercises/solution.md" "b/data/1.dailycode\345\210\235\351\230\266/3.python/48.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0ef2aed035b2f6e8c94cfaf111374c210e70d37b
--- /dev/null
+++ "b/data/1.dailycode\345\210\235\351\230\266/3.python/48.exercises/solution.md"
@@ -0,0 +1,64 @@
+# 有效的括号
+
+给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
- 左括号必须用相同类型的右括号闭合。
- 左括号必须以正确的顺序闭合。
示例 1：
输入：s = "()"
输出：true
示例 2：
输入：s = "()[]{}"
输出：true示例 3：
输入：s = "(]"
输出：false
示例 4：
输入：s = "([)]"
输出：false
示例 5：
输入：s = "{[]}"
输出：true
提示：
1 <= s.length <= 104s 仅由括号 '()[]{}' 组成
+
+## template
+
+```python
+class Solution:
+ def isValid(self, s: str) -> bool:
+ parentheses = [
+ '(', '[', '{',
+ ')', ']', '}'
+ ]
+ i = 0
+ sum = [0, 0, 0]
+ top = []
+ while i < len(s):
+ c = s[i]
+ j = 0
+ while j <= 2:
+ if c == parentheses[j]:
+ top.append(j)
+ sum[j] += 1
+ elif c == parentheses[j+3]:
+ if len(top) == 0 or top[len(top)-1] != j:
+ return False
+ top.pop()
+ sum[j] -= 1
+ j += 1
+ i += 1
+ if sum[0] != 0 or sum[1] != 0 or sum[2] != 0:
+ return False
+ else:
+ return True
+# %%
+s = Solution()
+print(s.isValid(s = "()[]{}"))
+```
+
+## 答案
+
+```python
+
+```
+
+## 选项
+
+### A
+
+```python
+
+```
+
+### B
+
+```python
+
+```
+
+### C
+
+```python
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/29.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/29.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..f92b84b97589f4a38a8ac038ec89d1fbe680b88d
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/29.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-276245dff1aa4411ac4f234d25a197c2",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/29.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/29.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..31d69d5c921eb998c936e2bc21ed34a2b6cf696c
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/29.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "fbe4ad5122b34be0bd9bec8212abd8f6"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/29.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/29.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..5f1deb351a9c5c477bf223ca314f2783c3a6acf8
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/29.exercises/solution.md"
@@ -0,0 +1,83 @@
+# 恢复二叉搜索树
+
+给你二叉搜索树的根节点 root ，该树中的两个节点被错误地交换。请在不改变其结构的情况下，恢复这棵树。
进阶：使用 O(n) 空间复杂度的解法很容易实现。你能想出一个只使用常数空间的解决方案吗？
示例 1：
输入：root = [1,3,null,null,2]
输出：[3,1,null,null,2]
解释：3 不能是 1 左孩子，因为 3 > 1 。交换 1 和 3 使二叉搜索树有效。
示例 2：
输入：root = [3,1,4,null,null,2]
输出：[2,1,4,null,null,3]
解释：2 不能在 3 的右子树中，因为 2 < 3 。交换 2 和 3 使二叉搜索树有效。
提示：
- 树上节点的数目在范围
[2, 1000] 内 -231 <= Node.val <= 231 - 1
+
+## template
+
+```cpp
+#include
+using namespace std;
+struct TreeNode
+{
+ int val;
+ TreeNode *left;
+ TreeNode *right;
+ TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+};
+class Solution
+{
+public:
+ void recoverTree(TreeNode *root)
+ {
+ dfs(root);
+ int tmp = p0_->val;
+ p0_->val = p1_->val;
+ p1_->val = tmp;
+ }
+private:
+ int wrong_ = 0;
+ TreeNode *prev_ = nullptr;
+ TreeNode *p0_ = nullptr;
+ TreeNode *p1_ = nullptr;
+ void dfs(TreeNode *root)
+ {
+ if (root == nullptr || wrong_ == 2)
+ {
+ return;
+ }
+ dfs(root->left);
+ if (prev_ != nullptr && prev_->val > root->val)
+ {
+ if (++wrong_ == 1)
+ {
+ p0_ = prev_;
+ p1_ = root;
+ }
+ else if (wrong_ == 2)
+ {
+ p1_ = root;
+ }
+ }
+ prev_ = root;
+ dfs(root->right);
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/30.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/30.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..b961cd8fdada1562a8853ae3c28119e51db1e788
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/30.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-0b6297d3889e4ff4ad745ba952b661fd",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/30.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/30.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..331043c85587f93e5d133db63b23401c41e73415
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/30.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "f1e21c54bf394f01929948edff768447"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/30.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/30.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..655c0a40bdedee82ecc04bf4837de9a853df77fe
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/30.exercises/solution.md"
@@ -0,0 +1,58 @@
+# 子集
+
+给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
示例 1：
输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
示例 2：
输入：nums = [0]
输出：[[],[0]]
提示：
1 <= nums.length <= 10-10 <= nums[i] <= 10nums 中的所有元素 互不相同
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ vector> subsets(vector &nums)
+ {
+ vector> res;
+ dfs(nums, 0, res);
+ return res;
+ }
+private:
+ vector stack;
+ void dfs(vector &nums, int start, vector> &res)
+ {
+ res.push_back(stack);
+ for (int i = start; i < nums.size(); i++)
+ {
+ stack.push_back(nums[i]);
+ dfs(nums, i + 1, res);
+ stack.pop_back();
+ }
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/31.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/31.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d9ee80fa8cc7bedfb115963c4f77e30523b4d4a2
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/31.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-e54a55862bdd4ec38996b20ec307ee4d",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/31.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/31.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..451b5a3a94df9f35a92e0505e475b17a09559c28
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/31.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "192a675b38e04d5bb25ab7dbb27a5ae9"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/31.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/31.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..65b86e62902cf463b2506b4023a487c32caee289
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/31.exercises/solution.md"
@@ -0,0 +1,85 @@
+# 不同路径
+
+一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
+机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
+问总共有多少条不同的路径？
+
+示例 1：
+输入：m = 3, n = 7
输出：28
+示例 2：
+输入：m = 3, n = 2
输出：3
解释：从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下
+示例 3：
+输入：m = 7, n = 3
输出：28
+示例 4：
+输入：m = 3, n = 3
输出：6
+
+提示：
+
+ 1 <= m, n <= 100- 题目数据保证答案小于等于
2 * 109
+
+
+## template
+
+```cpp
+#include
+#include
+static int uniquePaths(int m, int n)
+{
+ int row, col;
+ int *grids = malloc(m * n * sizeof(int));
+ for (col = 0; col < m; col++)
+ {
+ grids[col] = 1;
+ }
+ for (row = 0; row < n; row++)
+ {
+ grids[row * m] = 1;
+ }
+ for (row = 1; row < n; row++)
+ {
+ for (col = 1; col < m; col++)
+ {
+ grids[row * m + col] = grids[row * m + col - 1] + grids[(row - 1) * m + col];
+ }
+ }
+ return grids[m * n - 1];
+}
+int main(int argc, char **argv)
+{
+ if (argc != 3)
+ {
+ fprintf(stderr, "Usage: ./test m n\n");
+ exit(-1);
+ }
+ printf("%d\n", uniquePaths(atoi(argv[1]), atoi(argv[2])));
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/32.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/32.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..46fba09c913458664f086d5fb057f3c2da2ba2eb
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/32.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-c8e4de98cd7d4adaa3289c2e2f530120",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/32.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/32.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..f604b4ac3d20c68eff86f280d5b6a4af2e9805f2
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/32.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "9b3da2e42b6046e684c9f5f9f499fb03"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/32.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/32.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f1b9d8e4333bd66bc9300eb3b41ea272d20a2f48
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/32.exercises/solution.md"
@@ -0,0 +1,86 @@
+# 电话号码的字母组合
+
+给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
示例 1：
输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]
示例 2：
输入：digits = ""
输出：[]
示例 3：
输入：digits = "2"
输出：["a","b","c"]
提示：
0 <= digits.length <= 4digits[i] 是范围 ['2', '9'] 的一个数字。
+
+## template
+
+```cpp
+class Solution
+{
+public:
+ vector letterCombinations(string digits)
+ {
+ vector nummap({" ",
+ "",
+ "abc",
+ "def",
+ "ghi",
+ "jkl",
+ "mno",
+ "pqrs",
+ "tuv",
+ "wxyz"});
+ vector rs;
+ vector empty;
+ if (digits.size() == 0)
+ return empty;
+ for (auto d : digits)
+ {
+ if (d == '0')
+ return empty;
+ if (d == '1')
+ return empty;
+ auto &s = nummap[d - '0'];
+ if (s.size() == 0)
+ continue;
+ if (rs.size() == 0)
+ for (auto c : s)
+ {
+ string t;
+ t.push_back(c);
+ rs.emplace_back(t);
+ }
+ else
+ {
+ vector rn;
+ for (auto c : s)
+ {
+ for (auto r : rs)
+ {
+ r.push_back(c);
+ rn.emplace_back(std::move(r));
+ }
+ }
+ std::swap(rs, rn);
+ }
+ }
+ return rs;
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/33.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/33.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..f17683b5ad6aeba5fe5d778c0309bf5ccf195e3a
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/33.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-2c69030fc9f444ddbcd886ad9a0548a7",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/33.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/33.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..5175e9c3e9afcc9ea362fc06fb124dc1cb97b3b1
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/33.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "91ebaa372a4547c48625658aca52610f"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/33.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/33.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0815bca91c8652e472a72b3530151e2d431caa74
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/33.exercises/solution.md"
@@ -0,0 +1,172 @@
+# 不同的二叉搜索树 II
+
+
+
给你一个整数 n ，请你生成并返回所有由 n 个节点组成且节点值从 1 到 n 互不相同的不同
+ 二叉搜索树 。可以按 任意顺序 返回答案。
+
+
+
+
+
+
+
示例 1：
+
+
输入：n = 3
+输出：[[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]
+
+
+
示例 2：
+
+
输入：n = 1
+输出：[[1]]
+
+
+
+
+
提示：
+
+
+
+
+
+
请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。
+
+
函数 myAtoi(string s) 的算法如下：
+
+
+ - 读入字符串并丢弃无用的前导空格
+ - 检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
+ - 读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
+ - 将前面步骤读入的这些数字转换为整数（即，"123" -> 123， "0032" -> 32）。如果没有读入数字，则整数为
0 。必要时更改符号（从步骤 2 开始）。
+ - 如果整数数超过 32 位有符号整数范围
[−231, 231 − 1]
+ ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于
+ 231 − 1 的整数应该被固定为 231 − 1 。
+
+ - 返回整数作为最终结果。
+
+
+
注意：
+
+
+ - 本题中的空白字符只包括空格字符
' ' 。
+ - 除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。
+
+
+
+
+
示例 1：
+
+
输入：s = "42"
+输出：42
+解释：加粗的字符串为已经读入的字符，插入符号是当前读取的字符。
+第 1 步："42"（当前没有读入字符，因为没有前导空格）
+ ^
+第 2 步："42"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
+ ^
+第 3 步："42"（读入 "42"）
+ ^
+解析得到整数 42 。
+由于 "42" 在范围 [-231, 231 - 1] 内，最终结果为 42 。
+
+
示例 2：
+
+
输入：s = " -42"
+输出：-42
+解释：
+第 1 步：" -42"（读入前导空格，但忽视掉）
+ ^
+第 2 步：" -42"（读入 '-' 字符，所以结果应该是负数）
+ ^
+第 3 步：" -42"（读入 "42"）
+ ^
+解析得到整数 -42 。
+由于 "-42" 在范围 [-231, 231 - 1] 内，最终结果为 -42 。
+
+
+
示例 3：
+
+
输入：s = "4193 with words"
+输出：4193
+解释：
+第 1 步："4193 with words"（当前没有读入字符，因为没有前导空格）
+ ^
+第 2 步："4193 with words"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
+ ^
+第 3 步："4193 with words"（读入 "4193"；由于下一个字符不是一个数字，所以读入停止）
+ ^
+解析得到整数 4193 。
+由于 "4193" 在范围 [-231, 231 - 1] 内，最终结果为 4193 。
+
+
+
示例 4：
+
+
输入：s = "words and 987"
+输出：0
+解释：
+第 1 步："words and 987"（当前没有读入字符，因为没有前导空格）
+ ^
+第 2 步："words and 987"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
+ ^
+第 3 步："words and 987"（由于当前字符 'w' 不是一个数字，所以读入停止）
+ ^
+解析得到整数 0 ，因为没有读入任何数字。
+由于 0 在范围 [-231, 231 - 1] 内，最终结果为 0 。
+
+
示例 5：
+
+
输入：s = "-91283472332"
+输出：-2147483648
+解释：
+第 1 步："-91283472332"（当前没有读入字符，因为没有前导空格）
+ ^
+第 2 步："-91283472332"（读入 '-' 字符，所以结果应该是负数）
+ ^
+第 3 步："-91283472332"（读入 "91283472332"）
+ ^
+解析得到整数 -91283472332 。
+由于 -91283472332 小于范围 [-231, 231 - 1] 的下界，最终结果被截断为 -231 = -2147483648 。
+
+
+
+
提示：
+
+
+ 0 <= s.length <= 200s 由英文字母（大写和小写）、数字（0-9）、' '、'+'、'-' 和
+ '.' 组成
+
+
+
给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树
+ 有多少种？返回满足题意的二叉搜索树的种数。
+
+
+
+
示例 1：
+
+
输入：n = 3
+输出：5
+
+
+
示例 2：
+
+
输入：n = 1
+输出：1
+
+
+
+
+
提示：
+
+
+
给你一个 无重叠的 ，按照区间起始端点排序的区间列表。
+在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。
+
+示例 1：
+输入：intervals = [[1,3],[6,9]], newInterval = [2,5]
输出：[[1,5],[6,9]]
+示例 2：
+输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
输出：[[1,2],[3,10],[12,16]]
解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。
+示例 3：
+输入：intervals = [], newInterval = [5,7]
输出：[[5,7]]
+示例 4：
+输入：intervals = [[1,5]], newInterval = [2,3]
输出：[[1,5]]
+示例 5：
+输入：intervals = [[1,5]], newInterval = [2,7]
输出：[[1,7]]
+
+提示：
+
+ 0 <= intervals.length <= 104intervals[i].length == 20 <= intervals[i][0] <= intervals[i][1] <= 105intervals 根据 intervals[i][0] 按 升序 排列newInterval.length == 20 <= newInterval[0] <= newInterval[1] <= 105
+
+## template
+
+```cpp
+#include
+#include
+static int compare(const void *a, const void *b)
+{
+ return ((int *)a)[0] - ((int *)b)[0];
+}
+int **insert(int **intervals, int intervalsSize, int *intervalsColSize, int *newInterval,
+ int newIntervalSize, int *returnSize, int **returnColumnSizes)
+{
+ int i, len = 0;
+ int *tmp = malloc((intervalsSize + 1) * 2 * sizeof(int));
+ for (i = 0; i < intervalsSize; i++)
+ {
+ tmp[i * 2] = intervals[i][0];
+ tmp[i * 2 + 1] = intervals[i][1];
+ }
+ tmp[i * 2] = newInterval[0];
+ tmp[i * 2 + 1] = newInterval[1];
+ qsort(tmp, intervalsSize + 1, 2 * sizeof(int), compare);
+ int **results = malloc((intervalsSize + 1) * sizeof(int *));
+ results[0] = malloc(2 * sizeof(int));
+ results[0][0] = tmp[0];
+ results[0][1] = tmp[1];
+ for (i = 1; i < intervalsSize + 1; i++)
+ {
+ results[i] = malloc(2 * sizeof(int));
+ if (tmp[i * 2] > results[len][1])
+ {
+ len++;
+ results[len][0] = tmp[i * 2];
+ results[len][1] = tmp[i * 2 + 1];
+ }
+ else if (tmp[i * 2 + 1] > results[len][1])
+ {
+ results[len][1] = tmp[i * 2 + 1];
+ }
+ }
+ len += 1;
+ *returnSize = len;
+ *returnColumnSizes = malloc(len * sizeof(int));
+ for (i = 0; i < len; i++)
+ {
+ (*returnColumnSizes)[i] = 2;
+ }
+ return results;
+}
+int main(int argc, char **argv)
+{
+ if (argc < 3 || argc % 2 == 0)
+ {
+ fprintf(stderr, "Usage: ./test new_s new_e s0 e0 s1 e1...");
+ exit(-1);
+ }
+ int new_interv[2];
+ new_interv[0] = atoi(argv[1]);
+ new_interv[1] = atoi(argv[2]);
+ int i, count = 0;
+ int *size = malloc((argc - 3) / 2 * sizeof(int));
+ int **intervals = malloc((argc - 3) / 2 * sizeof(int *));
+ for (i = 0; i < (argc - 3) / 2; i++)
+ {
+ intervals[i] = malloc(2 * sizeof(int));
+ intervals[i][0] = atoi(argv[i * 2 + 3]);
+ intervals[i][1] = atoi(argv[i * 2 + 4]);
+ }
+ int *col_sizes;
+ int **results = insert(intervals, (argc - 3) / 2, size, new_interv, 2, &count, &col_sizes);
+ for (i = 0; i < count; i++)
+ {
+ printf("[%d,%d]\n", results[i][0], results[i][1]);
+ }
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/37.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/37.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..68d4fc402e1e81806a4560aa85e62ba607ad6c78
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/37.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-212af846610b43c289eefa3509db2bfd",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/37.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/37.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..5cbd2e8269802ae8b6646bbf6a1b81d94c41ec32
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/37.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "5e28030ec2ce423d959793def8556046"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/37.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/37.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..641be4fa70952b9dcee505df5a168980ba2fd928
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/37.exercises/solution.md"
@@ -0,0 +1,75 @@
+# 四数之和
+
+给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：答案中不可以包含重复的四元组。
示例 1：
输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例 2：
输入：nums = [], target = 0
输出：[]
提示：
0 <= nums.length <= 200-109 <= nums[i] <= 109-109 <= target <= 109
+
+## template
+
+```cpp
+class Solution
+{
+public:
+ vector> fourSum(vector &nums, int target)
+ {
+ long long l_target = target;
+ sort(nums.begin(), nums.end());
+ vector> results;
+ int N = nums.size();
+ for (int i = 0; i < N - 3; i++)
+ {
+ if (i > 0 && nums[i] == nums[i - 1])
+ continue;
+ for (int j = i + 1; j < N - 2; j++)
+ {
+ if (j > i + 1 && nums[j] == nums[j - 1])
+ continue;
+ for (int k = j + 1, l = N - 1; k < l; k++)
+ {
+ if (k > j + 1 && nums[k] == nums[k - 1])
+ continue;
+ while (k < l &&
+ (l_target - nums[i] - nums[j] - nums[k] - nums[l]) < 0)
+ {
+ l--;
+ }
+ if (k >= l)
+ {
+ break;
+ }
+ if ((target - nums[i] - nums[j] - nums[k] - nums[l]) == 0)
+ {
+ results.emplace_back(
+ vector({nums[i], nums[j], nums[k], nums[l]}));
+ }
+ }
+ }
+ }
+ return results;
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/38.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/38.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..bb0b0ed8d206cc376ec9323f85aaaa2c42770475
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/38.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-de5fcdf4ae694c9faa792da822161ac5",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/38.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/38.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..68b037983cc5252665eebf969157d8525f6b02de
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/38.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "ef3012b1b938467686270795dc5139f1"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/38.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/38.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..7bf0f15dac4428bb7f4b24a67ba3e9874c876b3e
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/38.exercises/solution.md"
@@ -0,0 +1,169 @@
+# 外观数列
+
+
+
给定一个正整数 n ，输出外观数列的第 n 项。
+
+
「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。
+
+
你可以将其视作是由递归公式定义的数字字符串序列：
+
+
+ countAndSay(1) = "1"countAndSay(n) 是对 countAndSay(n-1) 的描述，然后转换成另一个数字字符串。
+
+
前五项如下：
+
+
+ 1. 1
+ 2. 11
+ 3. 21
+ 4. 1211
+ 5. 111221
+ 第一项是数字 1
+ 描述前一项，这个数是 1 即 “ 一 个 1 ”，记作 "11"
+ 描述前一项，这个数是 11 即 “ 二 个 1 ” ，记作 "21"
+ 描述前一项，这个数是 21 即 “ 一 个 2 + 一 个 1 ” ，记作 "1211"
+ 描述前一项，这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ，记作 "111221"
+
+
+
要 描述 一个数字字符串，首先要将字符串分割为 最小 数量的组，每个组都由连续的最多 相同字符
+ 组成。然后对于每个组，先描述字符的数量，然后描述字符，形成一个描述组。要将描述转换为数字字符串，先将每组中的字符数量用数字替换，再将所有描述组连接起来。
+
+
例如，数字字符串 "3322251" 的描述如下图：
+
+
+
+
+
+
示例 1：
+
+
输入：n = 1
+输出："1"
+解释：这是一个基本样例。
+
+
+
示例 2：
+
+
输入：n = 4
+输出："1211"
+解释：
+countAndSay(1) = "1"
+countAndSay(2) = 读 "1" = 一 个 1 = "11"
+countAndSay(3) = 读 "11" = 二 个 1 = "21"
+countAndSay(4) = 读 "21" = 一 个 2 + 一 个 1 = "12" + "11" = "1211"
+
+
+
+
+
提示：
+
+
+
给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。
示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[4,5,1,2,3]
示例 2：
输入：head = [0,1,2], k = 4
输出：[2,0,1]
提示：
- 链表中节点的数目在范围
[0, 500] 内 -100 <= Node.val <= 1000 <= k <= 2 * 109
+
+## template
+
+```cpp
+#include
+using namespace std;
+struct ListNode
+{
+ int val;
+ ListNode *next;
+ ListNode() : val(0), next(nullptr) {}
+ ListNode(int x) : val(x), next(nullptr) {}
+ ListNode(int x, ListNode *next) : val(x), next(next) {}
+};
+class Solution
+{
+public:
+ ListNode *rotateRight(ListNode *head, int k)
+ {
+ if (head == nullptr)
+ {
+ return head;
+ }
+ int len = 0;
+ ListNode dummy;
+ dummy.next = head;
+ ListNode *tail = &dummy;
+ while (tail->next != nullptr)
+ {
+ len++;
+ tail = tail->next;
+ }
+ ListNode *prev = &dummy;
+ ListNode *p = head;
+ k = k % len;
+ for (int i = 0; i < len - k; i++)
+ {
+ prev = p;
+ p = p->next;
+ }
+ if (p != nullptr)
+ {
+ prev->next = tail->next;
+ tail->next = head;
+ head = p;
+ }
+ return head;
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/40.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/40.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..efedca2813d76efc6802d019a5a936a5d4385bdd
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/40.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-b747b501547c4c33a615b1c426f41f8d",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/40.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/40.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..389f50ba029467e4cf54fb4bf2a93c722715c66c
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/40.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "e76d20bc167a43eda623d873cff44fdd"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/40.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/40.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..27bc5a602818c49650076e7bbc113377c134cc3a
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/40.exercises/solution.md"
@@ -0,0 +1,66 @@
+# 组合
+
+给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。
+示例:
+输入: n = 4, k = 2
输出:[[2,4],[3,4],[2,3],[1,2],[1,3],[1,4],]
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ vector> combine(int n, int k)
+ {
+ vector> res;
+ dfs(n, k, 1, res);
+ return res;
+ }
+private:
+ vector stack;
+ void dfs(int n, int k, int start, vector> &res)
+ {
+ if (stack.size() == k)
+ {
+ res.push_back(stack);
+ }
+ else
+ {
+ for (int i = start; i <= n; i++)
+ {
+ stack.push_back(i);
+ dfs(n, k, i + 1, res);
+ stack.pop_back();
+ }
+ }
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/41.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/41.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..060f915ae9dbe32f2580f92cea9c4bc84abe84d5
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/41.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-b8e1807615a649e0bf801138606aea6c",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/41.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/41.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..5f1e2d930b119f1d656a18b7158f58f75d73a1f3
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/41.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "b034be7db3cc4b088019e7f1bc39928e"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/41.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/41.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..b9645095ea163e2588c9a31e9dc1f5c7f97262a9
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/41.exercises/solution.md"
@@ -0,0 +1,69 @@
+# 括号生成
+
+数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
示例 1：
输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]
示例 2：
输入：n = 1
输出：["()"]
提示：
+
+## template
+
+```cpp
+class Solution
+{
+public:
+ void gen(string &p, int lc, int rc, vector &r, int n)
+ {
+ if (lc > n)
+ return;
+ if (lc == n && rc == n)
+ {
+ r.push_back(p);
+ return;
+ }
+ p.push_back('(');
+ lc++;
+ gen(p, lc, rc, r, n);
+ p.pop_back();
+ lc--;
+ if (lc > rc)
+ {
+ p.push_back(')');
+ rc++;
+ gen(p, lc, rc, r, n);
+ p.pop_back();
+ rc--;
+ }
+ }
+ vector generateParenthesis(int n)
+ {
+ string p;
+ int lc = 0, rc = 0;
+ vector r;
+ gen(p, lc, rc, r, n);
+ return r;
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/42.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/42.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..a7a7d84cdda976a4df948ecce6f677889c5ab816
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/42.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-7f83ccbcde5f4ec7902d76fe98f43624",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/42.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/42.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..2bec08e41e315d24ad113fbdba2efa1e38c47037
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/42.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "bd5fb0c1343a4a268467dae5c5a37565"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/42.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/42.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..8953283626bffb2352d7995095c0b56205801457
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/42.exercises/solution.md"
@@ -0,0 +1,56 @@
+# 旋转图像
+
+给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。
你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[7,4,1],[8,5,2],[9,6,3]]
示例 2：
输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
输出：[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]
示例 3：
输入：matrix = [[1]]
输出：[[1]]
示例 4：
输入：matrix = [[1,2],[3,4]]
输出：[[3,1],[4,2]]
提示：
matrix.length == nmatrix[i].length == n1 <= n <= 20-1000 <= matrix[i][j] <= 1000
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ void rotate(vector> &matrix)
+ {
+ int size = matrix.size();
+ for (int i = 0; i < size / 2; i++)
+ {
+ int low = i, high = size - i - 1;
+ for (int j = low; j < high; j++)
+ {
+ int tmp = matrix[i][j];
+ matrix[i][j] = matrix[size - 1 - j][i];
+ matrix[size - 1 - j][i] = matrix[size - 1 - i][size - 1 - j];
+ matrix[size - 1 - i][size - 1 - j] = matrix[j][size - 1 - i];
+ matrix[j][size - 1 - i] = tmp;
+ }
+ }
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/43.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/43.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..0bdeb95e695bdf1d8d789778362e90577a4f1b8a
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/43.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-84b4b0d336d94b62ba1d797acc3baa15",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/43.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/43.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..e9d4d7019d7ea92654a34dc1e8b984aa5dcd2056
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/43.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "2d4b0e8669e5447dbfe1d80ba8c37bb9"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/43.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/43.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..1f592737744276305cc7ee4e988d783f409b6746
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/43.exercises/solution.md"
@@ -0,0 +1,52 @@
+# 盛最多水的容器
+
+给你 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
说明：你不能倾斜容器。
示例 1：
输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
示例 2：
输入：height = [1,1]
输出：1
示例 3：
输入：height = [4,3,2,1,4]
输出：16
示例 4：
输入：height = [1,2,1]
输出：2
提示：
n = height.length2 <= n <= 3 * 1040 <= height[i] <= 3 * 104
+
+## template
+
+```cpp
+#define MAX(a, b) (((a) < (b)) ? (b) : (a))
+#define MIN(a, b) (((a) > (b)) ? (b) : (a))
+int maxArea(int *height, int heightSize)
+{
+ int max = 0;
+ int i = 0, j = heightSize - 1;
+ int a;
+ while (i < j)
+ {
+ a = MIN(height[i], height[j]) * (j - i);
+ max = MAX(max, a);
+ if (height[i] > height[j])
+ --j;
+ else
+ ++i;
+ }
+ return max;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/44.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/44.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..4427b6d7c507876b60c30a5be69269e942791ba5
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/44.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-fd8c8c1c423746668bd05dbacae2ebf3",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/44.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/44.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..8c3cf962b77a4ab567463740dd39632d272a5a65
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/44.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "47174537a938405ebfa1778b36b1eb1f"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/44.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/44.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..61fd5994530c8c20b915fdc3b56d6f887b74ea03
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/44.exercises/solution.md"
@@ -0,0 +1,121 @@
+# 复原 IP 地址
+
+给定一个只包含数字的字符串，用以表示一个 IP 地址，返回所有可能从 s 获得的 有效 IP 地址 。你可以按任何顺序返回答案。
有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。
例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。
示例 1：
输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]
示例 2：
输入：s = "0000"
输出：["0.0.0.0"]
示例 3：
输入：s = "1111"
输出：["1.1.1.1"]
示例 4：
输入：s = "010010"
输出：["0.10.0.10","0.100.1.0"]
示例 5：
输入：s = "101023"
输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]
提示：
0 <= s.length <= 3000s 仅由数字组成
+
+## template
+
+```cpp
+#include
+#include
+#include
+#include
+static bool valid(char *ip, int len)
+{
+ if (len > 1 && ip[0] == '0')
+ {
+ return false;
+ }
+ if (len == 3)
+ {
+ int n = (ip[0] - '0') * 100 + (ip[1] - '0') * 10 + (ip[2] - '0');
+ if (n > 255)
+ {
+ return false;
+ }
+ }
+ return true;
+}
+#define WIDTH 4
+static void dfs(char *s, int start, char *stack, int num, char **results, int *count)
+{
+ int i, j;
+ if (num == 4)
+ {
+ if (s[start] == '\0')
+ {
+ results[*count] = malloc(3 * 4 + 3 + 1);
+ char *p = results[*count];
+ for (j = 0; j < num; j++)
+ {
+ char *q = stack + j * WIDTH;
+ while ((*p++ = *q++) != '\0')
+ {
+ }
+ if (j != 3)
+ {
+ *(p - 1) = '.';
+ }
+ }
+ (*count)++;
+ }
+ }
+ else
+ {
+ char *p = stack + num * WIDTH;
+ char *q = p;
+ for (i = start; s[i] != '\0' && i < start + 3; i++)
+ {
+ *q++ = s[i];
+ *q = '\0';
+ if (!valid(p, q - p))
+ {
+ return;
+ }
+ dfs(s, i + 1, stack, num + 1, results, count);
+ if (num + 1 < 4)
+ {
+ memset(stack + (num + 1) * WIDTH, 0, WIDTH);
+ }
+ }
+ }
+}
+static char **restoreIpAddresses(char *s, int *returnSize)
+{
+ int count = 0;
+ char **results = malloc(100 * sizeof(char *));
+ char addr[16] = {'\0'};
+ dfs(s, 0, addr, 0, results, &count);
+ *returnSize = count;
+ return results;
+}
+int main(int argc, char **argv)
+{
+ if (argc != 2)
+ {
+ fprintf(stderr, "Usage: ./test num\n");
+ exit(-1);
+ }
+ int i, count = 0;
+ char **list = restoreIpAddresses(argv[1], &count);
+ for (i = 0; i < count; i++)
+ {
+ printf("%s\n", list[i]);
+ }
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/45.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/45.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..4a7e01a9f068622164a11099318c5c053103841d
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/45.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-51619e0a715f40458c8e536cf1ef034f",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/45.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/45.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..148bd2a80023325c3fa14cefe17a0fb530018c07
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/45.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "23ea1b3a9fde45e098ddded74e88b722"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/45.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/45.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c10601abb0ebef6fd1555a6b29b8e18cdf0dc178
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/45.exercises/solution.md"
@@ -0,0 +1,74 @@
+# 格雷编码
+
+格雷编码是一个二进制数字系统，在该系统中，两个连续的数值仅有一个位数的差异。
+给定一个代表编码总位数的非负整数 n，打印其格雷编码序列。即使有多个不同答案，你也只需要返回其中一种。
+格雷编码序列必须以 0 开头。
+
+示例 1:
+输入: 2
输出: [0,1,3,2]
解释:00 - 001 - 111 - 310 - 2对于给定的 n，其格雷编码序列并不唯一。例如，[0,2,3,1] 也是一个有效的格雷编码序列。00 - 010 - 211 - 301 - 1
+示例 2:
+输入: 0
输出: [0]
解释: 我们定义格雷编码序列必须以 0 开头。给定编码总位数为 n 的格雷编码序列，其长度为 2n。当 n = 0 时，长度为 20 = 1。因此，当 n = 0 时，其格雷编码序列为 [0]。
+
+## template
+
+```cpp
+#include
+#include
+int *grayCode(int n, int *returnSize)
+{
+ if (n < 0)
+ {
+ return NULL;
+ }
+ int i, count = 1 << n;
+ int *codes = malloc(count * sizeof(int));
+ for (i = 0; i < count; i++)
+ {
+ codes[i] = (i >> 1) ^ i;
+ }
+ *returnSize = 1 << n;
+ return codes;
+}
+int main(int argc, char **argv)
+{
+ if (argc != 2)
+ {
+ fprintf(stderr, "Usage: ./test n\n");
+ exit(-1);
+ }
+ int i, count;
+ int *list = grayCode(atoi(argv[1]), &count);
+ for (i = 0; i < count; i++)
+ {
+ printf("%d ", list[i]);
+ }
+ printf("\n");
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/46.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/46.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..b53dee15359e090550ecda10c82fd0af9a2045fd
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/46.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-9b7485d651084adc90eaeca0d1dda61c",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/46.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/46.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..15dfcd05ab6b70910f62e061c5900f19d5c20f28
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/46.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "5705e480b1c847a28c814667896686b4"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/46.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/46.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..602191f9b4dcc8243d4721d34d64dcea41e8f054
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/46.exercises/solution.md"
@@ -0,0 +1,62 @@
+# 下一个排列
+
+实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。
如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
必须 原地 修改，只允许使用额外常数空间。
示例 1：
输入：nums = [1,2,3]
输出：[1,3,2]
示例 2：
输入：nums = [3,2,1]
输出：[1,2,3]
示例 3：
输入：nums = [1,1,5]
输出：[1,5,1]
示例 4：
输入：nums = [1]
输出：[1]
提示：
1 <= nums.length <= 1000 <= nums[i] <= 100
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ void nextPermutation(vector &nums)
+ {
+ if (nums.size() < 2)
+ {
+ return;
+ }
+ int i = nums.size() - 2;
+ while (i >= 0 && nums[i] >= nums[i + 1])
+ {
+ i--;
+ }
+ if (i >= 0)
+ {
+ int j = nums.size() - 1;
+ while (j >= 0 && nums[j] >= nums[i])
+ {
+ j--;
+ }
+ swap(nums.begin() + i, nums.begin() + j);
+ }
+ reverse(nums.begin() + i + 1, nums.end());
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/47.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/47.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..b0c17c2a452f834a2f5ccca8f82412ef5bd47ab1
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/47.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-1f951e2415de4a9e88c8c83b6d087d09",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/47.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/47.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..221b79378a7f56ed6813098fb04d795a74cc9801
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/47.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "885f94ac40214c9d8ace1cdbf1601f30"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/47.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/47.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2b74d69fb38b8608a825a3bf74b7f15ba98b8d16
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/47.exercises/solution.md"
@@ -0,0 +1,64 @@
+# 子集 II
+
+给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。
示例 1：
输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]
示例 2：
输入：nums = [0]
输出：[[],[0]]
提示：
1 <= nums.length <= 10-10 <= nums[i] <= 10
给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格 绝对路径 （以 '/' 开头），请你将其转化为更加简洁的规范路径。
在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （..） 表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。任意多个连续的斜杠（即，'//'）都被视为单个斜杠 '/' 。 对于此问题，任何其他格式的点（例如，'...'）均被视为文件/目录名称。
请注意，返回的 规范路径 必须遵循下述格式：
- 始终以斜杠
'/' 开头。 - 两个目录名之间必须只有一个斜杠
'/' 。 - 最后一个目录名（如果存在）不能 以
'/' 结尾。 - 此外，路径仅包含从根目录到目标文件或目录的路径上的目录（即，不含
'.' 或 '..'）。
返回简化后得到的 规范路径 。
示例 1：
输入：path = "/home/"
输出："/home"
解释：注意，最后一个目录名后面没有斜杠。
示例 2：
输入：path = "/../"
输出："/"
解释：从根目录向上一级是不可行的，因为根目录是你可以到达的最高级。
示例 3：
输入：path = "/home//foo/"
输出："/home/foo"
解释：在规范路径中，多个连续斜杠需要用一个斜杠替换。
示例 4：
输入：path = "/a/./b/../../c/"
输出："/c"
提示：
1 <= path.length <= 3000path 由英文字母，数字，'.'，'/' 或 '_' 组成。path 是一个有效的 Unix 风格绝对路径。
+
+## template
+
+```cpp
+#include
+#include
+#include
+static char *simplifyPath(char *path)
+{
+ int len = strlen(path);
+ if (len == 0)
+ {
+ return path;
+ }
+ char *p = path;
+ int *indexes = malloc(len * sizeof(int));
+ int depth = 0;
+ int name_start = 1;
+ while (*p != '\0')
+ {
+ if (*p == '/')
+ {
+ if (p > path && *(p - 1) != '/' && *(p - 1) != '.')
+ {
+ name_start = 1;
+ }
+ }
+ else if (*p == '.')
+ {
+ if (*(p + 1) == '\0' || *(p + 1) == '/')
+ {
+ p += 1;
+ }
+ else if (*(p + 1) == '.' && (*(p + 2) == '\0' || *(p + 2) == '/'))
+ {
+ if (depth > 0)
+ {
+ depth--;
+ name_start = 1;
+ }
+ p += 2;
+ }
+ else
+ {
+ indexes[depth++] = p - path;
+ while (*p != '/' && *p != '\0')
+ {
+ p++;
+ }
+ }
+ if (*p == '\0')
+ {
+ break;
+ }
+ }
+ else
+ {
+ if (name_start && depth >= 0)
+ {
+ indexes[depth++] = p - path;
+ name_start = 0;
+ }
+ }
+ p++;
+ }
+ int i;
+ char *result = malloc(len + 1);
+ char *q = result;
+ if (depth <= 0)
+ {
+ *q++ = '/';
+ }
+ else
+ {
+ for (i = 0; i < depth; i++)
+ {
+ p = path + indexes[i];
+ *q++ = '/';
+ while (*p != '/')
+ {
+ *q++ = *p++;
+ }
+ }
+ }
+ *q = '\0';
+ return result;
+}
+int main(int argc, char **argv)
+{
+ if (argc != 2)
+ {
+ fprintf(stderr, "Usage: ./test path\n");
+ exit(-1);
+ }
+ printf("%s\n", simplifyPath(argv[1]));
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/49.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/49.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..9c9244e358c7f3403cd1124dd6edac857500d095
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/49.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-928c6b0794724b70bc3dc240e8733cff",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/49.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/49.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..8afe0aab23f55be93b3c1982ff4986fd14c5db38
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/49.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "1028764173774a40a773e47eba18d5e6"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/49.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/49.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..06da7723b930721d860250609f8cc214abc92bc2
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/49.exercises/solution.md"
@@ -0,0 +1,84 @@
+# 两数相加
+
+给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例 1：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
提示：
- 每个链表中的节点数在范围
[1, 100] 内 0 <= Node.val <= 9- 题目数据保证列表表示的数字不含前导零
+
+## template
+
+```cpp
+struct ListNode
+{
+ int val;
+ struct ListNode *next;
+};
+struct ListNode *addTwoNumbers(struct ListNode *l1, struct ListNode *l2)
+{
+ struct ListNode *pp = NULL, *p = l1;
+ struct ListNode *qp = NULL, *q = l2;
+ int carry = 0;
+ while (p != NULL && q != NULL)
+ {
+ p->val += q->val + carry;
+ carry = 0;
+ if (p->val >= 10)
+ {
+ carry = 1;
+ p->val -= 10;
+ }
+ pp = p;
+ p = p->next;
+ qp = q;
+ q = q->next;
+ }
+ if (q)
+ {
+ pp->next = p = q;
+ qp->next = NULL;
+ }
+ while (carry && p)
+ {
+ p->val += carry;
+ carry = 0;
+ if (p->val >= 10)
+ {
+ carry = 1;
+ p->val -= 10;
+ }
+ pp = p;
+ p = p->next;
+ }
+ if (carry)
+ {
+ struct ListNode *n = (struct ListNode *)malloc(sizeof(struct ListNode));
+ n->val = 1;
+ n->next = NULL;
+ pp->next = n;
+ }
+ return l1;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/50.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/50.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..c8533ddc7ff6a7dcd7aa81711b220d891f16eaca
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/50.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-cf91b72dc8c348aba6f4a67ec2bdc3d4",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/50.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/50.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..f3307c7e896b33a2784e611b9e58c43f56a72ef3
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/50.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "d88d359a403742f58ef43ed77f9d6f07"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/50.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/50.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..919bbf9ad7639910e187eaba8159a718032b6633
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/50.exercises/solution.md"
@@ -0,0 +1,110 @@
+# 分隔链表
+
+给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。
你应当 保留 两个分区中每个节点的初始相对位置。
示例 1：
输入：head = [1,4,3,2,5,2], x = 3
输出：[1,2,2,4,3,5]
示例 2：
输入：head = [2,1], x = 2
输出：[1,2]
提示：
- 链表中节点的数目在范围
[0, 200] 内 -100 <= Node.val <= 100-200 <= x <= 200
+
+## template
+
+```cpp
+#include
+#include
+struct ListNode
+{
+ int val;
+ struct ListNode *next;
+};
+struct ListNode *partition(struct ListNode *head, int x)
+{
+ struct ListNode dummy;
+ struct ListNode *prev1 = &dummy, *pivot;
+ dummy.next = head;
+ for (pivot = head; pivot != NULL; pivot = pivot->next)
+ {
+ if (pivot->val >= x)
+ {
+ break;
+ }
+ prev1 = pivot;
+ }
+ struct ListNode *p = pivot->next;
+ struct ListNode *prev2 = pivot;
+ while (p != NULL)
+ {
+ if (p->val < x)
+ {
+ prev2->next = p->next;
+ p->next = prev1->next;
+ prev1->next = p;
+ prev1 = p;
+ p = prev2->next;
+ }
+ else
+ {
+ prev2 = p;
+ p = p->next;
+ }
+ }
+ return dummy.next;
+}
+int main(int argc, char **argv)
+{
+ if (argc < 2)
+ {
+ fprintf(stderr, "Usage: ./test target n1 n2 n3...\n");
+ exit(-1);
+ }
+ int i, target = atoi(argv[1]);
+ struct ListNode *head = NULL;
+ struct ListNode *prev = NULL;
+ struct ListNode *p;
+ for (i = 0; i < argc - 2; i++)
+ {
+ p = malloc(sizeof(*p));
+ p->val = atoi(argv[i + 2]);
+ p->next = NULL;
+ if (head == NULL)
+ {
+ head = p;
+ prev = head;
+ }
+ else
+ {
+ prev->next = p;
+ prev = p;
+ }
+ }
+ p = partition(head, target);
+ while (p != NULL)
+ {
+ printf("%d ", p->val);
+ p = p->next;
+ }
+ printf("\n");
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/51.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/51.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d4e1376a5b6c6b876b6776454908eb5ccc19dbd9
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/51.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-8373188349fb4a47bf7ad57840dde54e",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/51.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/51.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..a6b24694223fad7563e9c3e5b18c19eb77a5cb2f
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/51.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "02a5a650f836419aa1368f3eab1f7b53"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/51.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/51.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..1c98e39f490d2f21f1a760260efc10162d92c9e4
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/51.exercises/solution.md"
@@ -0,0 +1,141 @@
+# 整数转罗马数字
+
+
+
罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。
+
+
+
字符 数值
+I 1
+V 5
+X 10
+L 50
+C 100
+D 500
+M 1000
+
+
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12
+ 写做 XII ，即为 X + II 。 27
+ 写做 XXVII,
+ 即为 XX + V + II 。
+
+
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5
+ 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
+
+
+ I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。X 可以放在 L (50) 和 C (100) 的左边，来表示 40
+ 和 90。 C 可以放在 D (500) 和 M (1000) 的左边，来表示 400
+ 和 900。
+
+
给你一个整数，将其转为罗马数字。
+
+
+
+
示例 1:
+
+
输入: num = 3
+
输出: "III"
+
+
示例 2:
+
+
输入: num = 4
+
输出: "IV"
+
+
示例 3:
+
+
输入: num = 9
+
输出: "IX"
+
+
示例 4:
+
+
输入: num = 58
+
输出: "LVIII"
+
解释: L = 50, V = 5, III = 3.
+
+
+
示例 5:
+
+
输入: num = 1994
+
输出: "MCMXCIV"
+
解释: M = 1000, CM = 900, XC = 90, IV = 4.
+
+
+
+
提示：
+
+
+
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
示例 1：
输入：nums = [1,1,2]
输出：[[1,1,2], [1,2,1], [2,1,1]]
示例 2：
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
提示：
1 <= nums.length <= 8-10 <= nums[i] <= 10
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ vector> permuteUnique(vector &nums)
+ {
+ vector> res;
+ vector used(nums.size());
+ sort(nums.begin(), nums.end());
+ dfs(nums, used, res);
+ return res;
+ }
+private:
+ vector stack;
+ void dfs(vector &nums, vector &used, vector> &res)
+ {
+ if (stack.size() == nums.size())
+ {
+ res.push_back(stack);
+ }
+ else
+ {
+ for (int i = 0; i < nums.size(); i++)
+ {
+ if (!used[i])
+ {
+ if (i > 0 && !used[i - 1] && nums[i - 1] == nums[i])
+ {
+ continue;
+ }
+ stack.push_back(nums[i]);
+ used[i] = true;
+ dfs(nums, used, res);
+ stack.pop_back();
+ used[i] = false;
+ }
+ }
+ }
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/53.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/53.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..7979efed33c6439e1e45f5da4792396d5b0d219d
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/53.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-3cb01d219ea94075aa818ffdb924eafc",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/53.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/53.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..bdbe0f748c3c2fdbce6e8ece428d0079309b30c5
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/53.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "659e43e9c9834c6ebcbea71d52dc8700"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/53.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/53.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9bcad532dd31bb66baacf70980a5e5f6e54599bb
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/53.exercises/solution.md"
@@ -0,0 +1,49 @@
+# 无重复字符的最长子串
+
+给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
+请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
示例 4:
输入: s = ""
输出: 0
提示：
0 <= s.length <= 5 * 104s 由英文字母、数字、符号和空格组成
+
+## template
+
+```cpp
+int hset[128];
+int lengthOfLongestSubstring(char *s)
+{
+ int i = 0, j = 0;
+ int m = 0;
+ memset(hset, 0, sizeof hset);
+ for (; s[j]; j++)
+ {
+ i = hset[s[j]] > i ? hset[s[j]] : i;
+ m = m > j - i + 1 ? m : j - i + 1;
+ hset[s[j]] = j + 1;
+ }
+ return m;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/54.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/54.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..3c6f0e04b63d0f4d3a1a8037778780f7098faebf
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/54.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-ea4fd5babea7407aa08f1126f8513d6a",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/54.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/54.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..db2cf310c6808116b6bd97cedb90d2315552c859
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/54.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "319e83085f474d9faba6d4c57cb750ab"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/54.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/54.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ce47e902e3166a16f7b2c6a305ac9183dceb90a6
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/54.exercises/solution.md"
@@ -0,0 +1,96 @@
+# 解码方法
+
+一条包含字母 A-Z 的消息通过以下映射进行了 编码 ：
+'A' -> 1'B' -> 2...'Z' -> 26
+要 解码 已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，"11106" 可以映射为：
+
+ "AAJF" ，将消息分组为 (1 1 10 6)"KJF" ，将消息分组为 (11 10 6)
+注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和
+ "06" 在映射中并不等价。
+
+给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。
+题目数据保证答案肯定是一个 32 位 的整数。
+
+示例 1：
+输入：s = "12"
输出：2
解释：它可以解码为 "AB"（1 2）或者 "L"（12）。
+示例 2：
+输入：s = "226"
输出：3
解释：它可以解码为 "BZ" (2 26), "VF" (22 6), 或者 "BBF" (2 2 6) 。
+示例 3：
+输入：s = "0"
输出：0
解释：没有字符映射到以 0 开头的数字。含有 0 的有效映射是 'J' -> "10" 和 'T'-> "20" 。由于没有字符，因此没有有效的方法对此进行解码，因为所有数字都需要映射。
+示例 4：
+输入：s = "06"
输出：0
解释："06" 不能映射到 "F" ，因为字符串含有前导 0（"6" 和 "06" 在映射中并不等价）。
+
+提示：
+
+ 1 <= s.length <= 100s 只包含数字，并且可能包含前导零。
+
+## template
+
+```cpp
+#include
+#include
+#include
+static int numDecodings(char *s)
+{
+ int len = strlen(s);
+ if (len == 0)
+ {
+ return 0;
+ }
+ int a = 1;
+ int b = s[0] == '0' ? 0 : a;
+ int c = b;
+ for (int i = 2; i <= len; i++)
+ {
+ c = s[i - 1] == '0' ? 0 : b;
+ int num = (s[i - 2] - '0') * 10 + (s[i - 1] - '0');
+ if (num >= 10 && num <= 26)
+ {
+ c += a;
+ }
+ a = b;
+ b = c;
+ }
+ return c;
+}
+int main(int argc, char **argv)
+{
+ if (argc != 2)
+ {
+ fprintf(stderr, "Usage: ./test number\n");
+ exit(-1);
+ }
+ printf("%d\n", numDecodings(argv[1]));
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/55.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/55.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..ff60a2704fe958dbf4f9785d69a6e632bf37c65f
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/55.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-f7829033277c41ff91ba6c0cd74e8b2d",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/55.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/55.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..745c583bd6bbbab4e38df19d7f873b59b6011f5b
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/55.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "90bc4ad92b1b410892f344b0947ad1a6"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/55.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/55.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f6b2abf3351e0e836dc42b185bab23a50c764fd7
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/55.exercises/solution.md"
@@ -0,0 +1,79 @@
+# 两数相除
+
+给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。
返回被除数 dividend 除以除数 divisor 得到的商。
整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2
示例 1:
输入: dividend = 10, divisor = 3
输出: 3
解释: 10/3 = truncate(3.33333..) = truncate(3) = 3
示例 2:
输入: dividend = 7, divisor = -3
输出: -2
解释: 7/-3 = truncate(-2.33333..) = -2
提示：
- 被除数和除数均为 32 位有符号整数。
- 除数不为 0。
- 假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−231, 231 − 1]。本题中，如果除法结果溢出，则返回 231 − 1。
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ int divide(int dividend, int divisor)
+ {
+ int signal = 1;
+ unsigned int dvd = dividend;
+ if (dividend < 0)
+ {
+ signal *= -1;
+ dvd = ~dvd + 1;
+ }
+ unsigned int dvs = divisor;
+ if (divisor < 0)
+ {
+ signal *= -1;
+ dvs = ~dvs + 1;
+ }
+ int shift = 0;
+ while (dvd > dvs << shift)
+ {
+ shift++;
+ }
+ unsigned int res = 0;
+ while (dvd >= dvs)
+ {
+ while (dvd < dvs << shift)
+ {
+ shift--;
+ }
+ res |= (unsigned int)1 << shift;
+ dvd -= dvs << shift;
+ }
+ if (signal == 1 && res >= INT_MAX)
+ {
+ return INT_MAX;
+ }
+ else
+ {
+ return res * signal;
+ }
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/56.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/56.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d639eb06b877c588d9ed0226e88c53e9021b4f27
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/56.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-bf307c2ca5f5441da2ef689a1defa3d5",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/56.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/56.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..e62b494c74546338f48a24befdd2eb770d7f4cf6
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/56.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "187f2a49ad424c6dac4fae50290eb29f"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/56.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/56.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f4e37b081aac84b331a11a9b3f1ef47d3334bff0
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/56.exercises/solution.md"
@@ -0,0 +1,88 @@
+# 螺旋矩阵
+
+给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：
输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]
提示：
m == matrix.lengthn == matrix[i].length1 <= m, n <= 10-100 <= matrix[i][j] <= 100
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ vector spiralOrder(vector> &matrix)
+ {
+ vector res;
+ int hor_top = 0;
+ int hor_bottom = matrix.size() - 1;
+ int ver_left = 0;
+ int ver_right = matrix[0].size() - 1;
+ int direction = 0;
+ while (hor_top <= hor_bottom && ver_left <= ver_right)
+ {
+ switch (direction)
+ {
+ case 0:
+ for (int i = ver_left; i <= ver_right; i++)
+ {
+ res.push_back(matrix[hor_top][i]);
+ }
+ hor_top++;
+ break;
+ case 1:
+ for (int i = hor_top; i <= hor_bottom; i++)
+ {
+ res.push_back(matrix[i][ver_right]);
+ }
+ ver_right--;
+ break;
+ case 2:
+ for (int i = ver_right; i >= ver_left; i--)
+ {
+ res.push_back(matrix[hor_bottom][i]);
+ }
+ hor_bottom--;
+ break;
+ case 3:
+ for (int i = hor_bottom; i >= hor_top; i--)
+ {
+ res.push_back(matrix[i][ver_left]);
+ }
+ ver_left++;
+ break;
+ default:
+ break;
+ }
+ direction++;
+ direction %= 4;
+ }
+ return res;
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/57.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/57.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..67258e38be3803a2fd10682b1a1470eb71fe4e2f
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/57.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-80598659b17144ad9da321739cc45bd3",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/57.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/57.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..86effe30477b804207a785bd3ac9b51801ecfb65
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/57.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "4984a5949e9b456b8d2c3e4647e2a3ac"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/57.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/57.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..5e1f20b607e7d28bf5dd4dcd342ba2ff7d5a3dd1
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/57.exercises/solution.md"
@@ -0,0 +1,70 @@
+# 全排列
+
+给定一个 没有重复 数字的序列，返回其所有可能的全排列。
示例:
输入: [1,2,3]
输出:[ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]]
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ vector> permute(vector &nums)
+ {
+ vector> res;
+ vector used(nums.size());
+ dfs(nums, used, res);
+ return res;
+ }
+private:
+ vector stack;
+ void dfs(vector &nums, vector &used, vector> &res)
+ {
+ if (stack.size() == nums.size())
+ {
+ res.push_back(stack);
+ }
+ else
+ {
+ for (int i = 0; i < nums.size(); i++)
+ {
+ if (!used[i])
+ {
+ used[i] = true;
+ stack.push_back(nums[i]);
+ dfs(nums, used, res);
+ stack.pop_back();
+ used[i] = false;
+ }
+ }
+ }
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/58.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/58.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..680b83e6d2c86f716d3a0c40fff084f093d4727f
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/58.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-bdf3f551b3894151b170852c30440ad0",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/58.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/58.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..b0fa06788ba64d4849b6496f1d780ac2fd079745
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/58.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "e064adbef94341589c7a189c0cdced7d"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/58.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/58.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2d7053c4a40197414bd88ccdb757cc45e8e52bdf
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/58.exercises/solution.md"
@@ -0,0 +1,101 @@
+# 搜索旋转排序数组
+
+整数数组 nums 按升序排列，数组中的值 互不相同 。
+在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为
+ [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始
+ 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
+
+给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值
+ target ，则返回它的下标，否则返回 -1 。
+
+
+示例 1：
+输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4
+示例 2：
+输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1
+示例 3：
+输入：nums = [1], target = 0
输出：-1
+
+提示：
+
+ 1 <= nums.length <= 5000-10^4 <= nums[i] <= 10^4nums 中的每个值都 独一无二- 题目数据保证
nums 在预先未知的某个下标上进行了旋转
+ -10^4 <= target <= 10^4
+
+进阶：你可以设计一个时间复杂度为 O(log n) 的解决方案吗？
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ int search(vector &nums, int target)
+ {
+ int lo = 0;
+ int hi = nums.size() - 1;
+ for (lo <= hi)
+ {
+ int mid = lo + (hi - lo) / 2;
+ if (nums[mid] == target)
+ {
+ return mid;
+ }
+ if (nums[lo] <= nums[mid])
+ {
+ if (nums[lo] <= target && target < nums[mid])
+ {
+ hi = mid - 1;
+ }
+ else
+ {
+ lo = mid + 1;
+ }
+ }
+ else
+ {
+ if (nums[mid] < target && target <= nums[hi])
+ {
+ lo = mid + 1;
+ }
+ else
+ {
+ hi = mid - 1;
+ }
+ }
+ }
+ return -1;
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/59.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/59.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..7903a8bfdc2b9a8e6911e804a160b0c40eed5f91
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/59.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-f88b0f4c34bd4cc8bb4ed8bff872eea2",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/59.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/59.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..e30087990a19bc1580a735a073707a6e08814e50
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/59.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "3ddcdae838f24548950e8152dbc8ef5d"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/59.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/59.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..28e467904269723a214837b3acc9aff674d91c27
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/59.exercises/solution.md"
@@ -0,0 +1,125 @@
+# 搜索二维矩阵
+
+编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：
- 每行中的整数从左到右按升序排列。
- 每行的第一个整数大于前一行的最后一个整数。
示例 1：
输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
输出：true
示例 2：
输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
输出：false
提示：
m == matrix.lengthn == matrix[i].length1 <= m, n <= 100-104 <= matrix[i][j], target <= 104
+
+## template
+
+```cpp
+#include
+#include
+#include
+static int binary_search(int *nums, int len, int target)
+{
+ int low = -1;
+ int high = len;
+ while (low + 1 < high)
+ {
+ int mid = low + (high - low) / 2;
+ if (target > nums[mid])
+ {
+ low = mid;
+ }
+ else
+ {
+ high = mid;
+ }
+ }
+ if (high == len || nums[high] != target)
+ {
+ return -high - 1;
+ }
+ else
+ {
+ return high;
+ }
+}
+static bool searchMatrix(int **matrix, int matrixRowSize, int matrixColSize, int target)
+{
+ if (matrixRowSize == 0 || matrixColSize == 0)
+ {
+ return false;
+ }
+ if (target < matrix[0][0] || target > matrix[matrixRowSize - 1][matrixColSize - 1])
+ {
+ return false;
+ }
+ int row = 0;
+ int *nums = NULL;
+ if (matrixRowSize > 0)
+ {
+ nums = malloc(matrixRowSize * sizeof(int));
+ for (row = 0; row < matrixRowSize; row++)
+ {
+ nums[row] = matrix[row][0];
+ }
+ row = binary_search(nums, matrixRowSize, target);
+ if (row >= 0)
+ {
+ return true;
+ }
+ else
+ {
+ row = -row - 1;
+ if (row == 0)
+ {
+ return false;
+ }
+ else
+ {
+ row--;
+ }
+ }
+ }
+ int col = binary_search(matrix[row], matrixColSize, target);
+ return col >= 0;
+}
+int main(int argc, char **argv)
+{
+ int row = 3;
+ int col = 4;
+ int **mat = malloc(row * sizeof(int *));
+ mat[0] = malloc(col * sizeof(int));
+ mat[0][0] = 1;
+ mat[0][1] = 3;
+ mat[0][2] = 5;
+ mat[0][3] = 7;
+ mat[1] = malloc(col * sizeof(int));
+ mat[1][0] = 10;
+ mat[1][1] = 11;
+ mat[1][2] = 16;
+ mat[1][3] = 20;
+ mat[2] = malloc(col * sizeof(int));
+ mat[2][0] = 23;
+ mat[2][1] = 30;
+ mat[2][2] = 34;
+ mat[2][3] = 50;
+ printf("%s\n", searchMatrix(mat, row, col, atoi(argv[1])) ? "true" : "false");
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/60.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/60.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..079f898bb0746d1b1a1da07c01684561da684b4c
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/60.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-ec4d5b7bf8324d3cbaaab556e3dcd2c6",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/60.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/60.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..402bf0aae69f987c7b9c776daeb4cf97a08ea98f
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/60.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "a3a7e6dbce284af5a886e41dc168e68d"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/60.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/60.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..68d0b45ce516bbb6461f43f0fa474d0d8d26d2e9
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/60.exercises/solution.md"
@@ -0,0 +1,69 @@
+# Pow(x, n)
+
+实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。
示例 1：
输入：x = 2.00000, n = 10
输出：1024.00000
示例 2：
输入：x = 2.10000, n = 3
输出：9.26100
示例 3：
输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25
提示：
-100.0 < x < 100.0-231 <= n <= 231-1-104 <= xn <= 104
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ double myPow(double x, int n)
+ {
+ if (n == INT_MIN)
+ {
+ double t = dfs(x, -(n / 2));
+ return 1 / t * 1 / t;
+ }
+ else
+ {
+ return n < 0 ? 1 / dfs(x, -n) : dfs(x, n);
+ }
+ }
+private:
+ double dfs(double x, int n)
+ {
+ if (n == 0)
+ {
+ return 1;
+ }
+ else if (n == 1)
+ {
+ return x;
+ }
+ else
+ {
+ double t = dfs(x, n / 2);
+ return (n % 2) ? (x * t * t) : (t * t);
+ }
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/61.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/61.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..b57a7a76c09f4ae0aa78ccb19804e566487a3505
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/61.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-d0eb65c248e441d6af43e9d3a69232d0",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/61.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/61.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..1182b28948b88896b71099d698ad275653518f49
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/61.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "d8cc99ee4afc43b09b1f974be33bfb98"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/61.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/61.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..8b514eca174daab96af6374baf23e142c3a3f23f
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/61.exercises/solution.md"
@@ -0,0 +1,72 @@
+# 字母异位词分组
+
+给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。
+示例:
+输入:[eat", "tea", "tan", "ate", "nat", "bat"]
输出:[[ate","eat","tea"],["nat","tan"],["bat"]]
+说明：
+
+ - 所有输入均为小写字母。
+ - 不考虑答案输出的顺序。
+
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ vector> groupAnagrams(vector &strs)
+ {
+ vector> res;
+ unordered_map> ht;
+ for (const auto &str : strs)
+ {
+ int counts[26] = {0};
+ for (char c : str)
+ {
+ counts[c - 'a']++;
+ }
+ string key;
+ for (int i : counts)
+ {
+ key.push_back('#');
+ key.push_back(i + '0');
+ }
+ ht[key].push_back(str);
+ }
+ for (const auto &t : ht)
+ {
+ res.push_back(t.second);
+ }
+ return res;
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/62.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/62.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..19d79bb910aa91e3638eff211b42c376b69970c8
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/62.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-2d76c5623b5f412f811d07ad8fa0afa2",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/62.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/62.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..4c85f5cbdf9bf798eefe09a75f07d96fa0725d2d
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/62.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "4846f615a38143eab13aff6f861bfd91"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/62.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/62.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..561e95a62a4e52780ddee404e0987a68baf6c7a7
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/62.exercises/solution.md"
@@ -0,0 +1,85 @@
+# 矩阵置零
+
+给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。
进阶：
- 一个直观的解决方案是使用
O(mn) 的额外空间，但这并不是一个好的解决方案。 - 一个简单的改进方案是使用
O(m + n) 的额外空间，但这仍然不是最好的解决方案。 - 你能想出一个仅使用常量空间的解决方案吗？
示例 1：
输入：matrix = [[1,1,1],[1,0,1],[1,1,1]]
输出：[[1,0,1],[0,0,0],[1,0,1]]
示例 2：
输入：matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
输出：[[0,0,0,0],[0,4,5,0],[0,3,1,0]]
提示：
m == matrix.lengthn == matrix[0].length1 <= m, n <= 200-231 <= matrix[i][j] <= 231 - 1
+
+## template
+
+```cpp
+#include
+using namespace std;
+public:
+void setZeroes(vector> &matrix)
+{
+ bool bRow = false, bCol = false;
+ for (int row = 0; row < matrix.size(); row++)
+ {
+ for (int col = 0; col < matrix[row].size(); col++)
+ {
+ if (matrix[row][col] == 0)
+ {
+ if (row == 0)
+ {
+ bRow = true;
+ }
+ if (col == 0)
+ {
+ bCol = true;
+ }
+ matrix[0][col] = matrix[row][0] = 0;
+ }
+ }
+ }
+ for (int row = 1; row < matrix.size(); row++)
+ {
+ for (int col = 1; col < matrix[row].size(); col++)
+ {
+ if (matrix[0][col] == 0 || matrix[row][0] == 0)
+ {
+ matrix[row][col] = 0;
+ }
+ }
+ }
+ if (bRow)
+ {
+ for (auto &m : matrix[0])
+ {
+ m = 0;
+ }
+ }
+ if (bCol)
+ {
+ for (int row = 0; row < matrix.size(); row++)
+ {
+ matrix[row][0] = 0;
+ }
+ }
+}
+}
+;
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/63.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/63.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..314061160883dc70016086dc40b3eb64e21ab969
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/63.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-3f77a681904f4599aa76fe9d85baac80",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/63.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/63.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..4170ec135e950bf9c4c061d34de3c97ddb257a9d
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/63.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "19fafe8645294fe4b4d20c1122482404"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/63.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/63.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..a9dd4649e051374a506341e08c19cc7d6485d7bf
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/63.exercises/solution.md"
@@ -0,0 +1,118 @@
+# 在排序数组中查找元素的第一个和最后一个位置
+
+给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
+如果数组中不存在目标值 target，返回 [-1, -1]。
+进阶：
+
+ - 你可以设计并实现时间复杂度为
O(log n) 的算法解决此问题吗？
+
+
+示例 1：
+输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]
+示例 2：
+输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]
+示例 3：
+输入：nums = [], target = 0
输出：[-1,-1]
+
+提示：
+
+ 0 <= nums.length <= 105-109 <= nums[i] <= 109nums 是一个非递减数组-109 <= target <= 109
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ vector searchRange(vector &nums, int target)
+ {
+ vector res;
+ res.push_back(binary_search_begin(nums, target));
+ res.push_back(binary_search_end(nums, target));
+ return res;
+ }
+private:
+ int binary_search_begin(vector nums, int target)
+ {
+ int lo = -1;
+ int hi = nums.size();
+ while (lo + 1 < hi)
+ {
+ int mid = lo + (hi - lo) / 2;
+ if (target > nums[mid])
+ {
+ lo = mid;
+ }
+ else
+ {
+ hi = mid;
+ }
+ }
+ if (hi == nums.size() || nums[hi] != target)
+ {
+ return -1;
+ }
+ else
+ {
+ return hi;
+ }
+ }
+ int binary_search_end(vector nums, int target)
+ {
+ int lo = -1;
+ int hi = nums.size();
+ while (lo + 1 < hi)
+ {
+ int mid = lo + (hi - lo) / 2;
+ if (target < nums[mid])
+ {
+ hi = mid;
+ }
+ else
+ {
+ lo = mid;
+ }
+ }
+ if (lo == -1 || nums[lo] != target)
+ {
+ return -1;
+ }
+ else
+ {
+ return lo;
+ }
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/64.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/64.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..37488922b2dea07c52257d48f4a9512a11df58da
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/64.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-8819f23a2aa64fbfa2222cd407056311",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/64.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/64.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..acec684b6cf3d556cc8b7a1f905770b67e89823f
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/64.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "ba53f24875754536aa23cb21d995c1de"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/64.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/64.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..bc92a5fe460c6388128bbf13ca8ea01c31bd9c80
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/64.exercises/solution.md"
@@ -0,0 +1,63 @@
+# 跳跃游戏 II
+
+给定一个非负整数数组，你最初位于数组的第一个位置。
+数组中的每个元素代表你在该位置可以跳跃的最大长度。
+你的目标是使用最少的跳跃次数到达数组的最后一个位置。
+示例:
+输入: [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
+说明:
+假设你总是可以到达数组的最后一个位置。
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ int jump(vector &nums)
+ {
+ int steps = 0;
+ int lo = 0, hi = 0;
+ while (hi < nums.size() - 1)
+ {
+ int right = 0;
+ for (int i = lo; i <= hi; i++)
+ {
+ right = max(i + nums[i], right);
+ }
+ lo = hi + 1;
+ hi = right;
+ steps++;
+ }
+ return steps;
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/65.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/65.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..9b4a3ad14f9a92a3b6ada32399a03126cc8db92c
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/65.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-7956f8daa342400bba061dafb6fd3178",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/65.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/65.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d24c3814a6c71840037ebf79c9f8119d3e68861b
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/65.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "b167b3dbf557410caad7dc7c9dc7adc2"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/65.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/65.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..8a2e15e425c912b4dc0338212dbcf0051cb353f1
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/65.exercises/solution.md"
@@ -0,0 +1,90 @@
+# 反转链表 II
+
+给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。
示例 1：
输入：head = [1,2,3,4,5], left = 2, right = 4
输出：[1,4,3,2,5]
示例 2：
输入：head = [5], left = 1, right = 1
输出：[5]
提示：
- 链表中节点数目为
n 1 <= n <= 500-500 <= Node.val <= 5001 <= left <= right <= n
进阶： 你可以使用一趟扫描完成反转吗？
+
+## template
+
+```cpp
+#include
+#include
+struct ListNode
+{
+ int val;
+ struct ListNode *next;
+};
+static struct ListNode *reverseBetween(struct ListNode *head, int m, int n)
+{
+ int i;
+ struct ListNode dummy;
+ struct ListNode *prev = &dummy;
+ prev->next = head;
+ for (i = 1; i < m; i++)
+ {
+ prev = prev->next;
+ }
+ struct ListNode *p = prev->next;
+ for (i = m; i < n; i++)
+ {
+ struct ListNode *q = p->next;
+ p->next = q->next;
+ q->next = prev->next;
+ prev->next = q;
+ }
+ return dummy.next;
+}
+int main(int argc, char **argv)
+{
+ if (argc < 3)
+ {
+ fprintf(stderr, "Usage: ./test m n 1 2 3...\n");
+ exit(-1);
+ }
+ int i, count = argc - 3;
+ struct ListNode dummy;
+ struct ListNode *prev = &dummy;
+ struct ListNode *p;
+ for (i = 0; i < count; i++)
+ {
+ p = malloc(sizeof(*p));
+ p->val = atoi(argv[i + 3]);
+ p->next = NULL;
+ prev->next = p;
+ prev = p;
+ }
+ int m = atoi(argv[1]);
+ int n = atoi(argv[2]);
+ struct ListNode *head = reverseBetween(dummy.next, m, n);
+ for (p = head; p != NULL; p = p->next)
+ {
+ printf("%d ", p->val);
+ }
+ printf("\n");
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/66.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/66.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..2a4efd751253dd4f94bfd8d19ca111e8ec1e5131
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/66.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-c4a5876d768c49afa16411eea23221fc",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/66.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/66.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..6a11f7880d143239e1d32bdb7782d3ad88853cff
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/66.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "f4ad8e3fdc974d09ad0afb1c8775ae12"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/66.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/66.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ba67794ae4bf01396d7bbb093839a5891e9bd4d1
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/66.exercises/solution.md"
@@ -0,0 +1,90 @@
+# 最小路径和
+
+给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。
示例 1：
输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
输出：7
解释：因为路径 1→3→1→1→1 的总和最小。
示例 2：
输入：grid = [[1,2,3],[4,5,6]]
输出：12
提示：
m == grid.lengthn == grid[i].length1 <= m, n <= 2000 <= grid[i][j] <= 100
+
+## template
+
+```cpp
+#include
+#include
+#include
+static inline int min(int a, int b)
+{
+ return a < b ? a : b;
+}
+int minPathSum(int **grid, int gridRowSize, int gridColSize)
+{
+ int i, j;
+ int **dp = malloc(gridRowSize * sizeof(int *));
+ for (i = 0; i < gridRowSize; i++)
+ {
+ dp[i] = malloc(gridColSize * sizeof(int));
+ }
+ dp[0][0] = grid[0][0];
+ int sum = dp[0][0];
+ for (i = 1; i < gridRowSize; i++)
+ {
+ sum += grid[i][0];
+ dp[i][0] = sum;
+ }
+ sum = dp[0][0];
+ for (i = 1; i < gridColSize; i++)
+ {
+ sum += grid[0][i];
+ dp[0][i] = sum;
+ }
+ for (i = 1; i < gridRowSize; i++)
+ {
+ for (j = 1; j < gridColSize; j++)
+ {
+ dp[i][j] = grid[i][j] + min(dp[i - 1][j], dp[i][j - 1]);
+ }
+ }
+ return dp[gridRowSize - 1][gridColSize - 1];
+}
+int main(int argc, char **argv)
+{
+ int i, j;
+ int row = argc - 1;
+ int col = strlen(argv[1]);
+ int **grid = malloc(row * sizeof(int *));
+ for (i = 0; i < row; i++)
+ {
+ grid[i] = malloc(col * sizeof(int));
+ for (j = 0; j < col; j++)
+ {
+ grid[i][j] = argv[i + 1][j] - '0';
+ printf("%d ", grid[i][j]);
+ }
+ printf("\n");
+ }
+ printf("%d\n", minPathSum(grid, row, col));
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/67.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/67.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..394c29bd51818ebad96c17020b3b003496934d98
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/67.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-f35d9558bb004e20afa1137186ed1dfe",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/67.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/67.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..2fe399b91794b077f6e45f3c18d9e70244fd8fe1
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/67.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "c2dcf7aedfce4c1f8cdc906c44f1af3e"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/67.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/67.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d735d5ac0fc684cb18771393469146431823b544
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/67.exercises/solution.md"
@@ -0,0 +1,61 @@
+# 删除链表的倒数第 N 个结点
+
+给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
进阶：你能尝试使用一趟扫描实现吗？
示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]
示例 3：
输入：head = [1,2], n = 1
输出：[1]
提示：
- 链表中结点的数目为
sz 1 <= sz <= 300 <= Node.val <= 1001 <= n <= sz
+
+## template
+
+```cpp
+struct ListNode
+{
+ int val;
+ ListNode *next;
+ ListNode() : val(0), next(nullptr) {}
+ ListNode(int x) : val(x), next(nullptr) {}
+ ListNode(int x, ListNode *next) : val(x), next(next) {}
+};
+#include
+class Solution
+{
+public:
+ ListNode *removeNthFromEnd(ListNode *head, int n)
+ {
+ ListNode empty_node(0, head);
+ ListNode *p = &empty_node;
+ std::vector pv;
+ while (p != nullptr)
+ {
+ pv.push_back(p);
+ p = p->next;
+ }
+ p = pv[pv.size() - 1 - n];
+ p->next = p->next->next;
+ return empty_node.next;
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/68.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/68.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..59ac6bb4ebab779a797d469a6b0042bc31310032
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/68.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-afaa77de3c2349b8a4683b325bb8b53b",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/68.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/68.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d79500a515ae4c4a1f78286cfe9c1572fc3d7332
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/68.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "503ce168784a47bea62ad753f60ff2ee"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/68.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/68.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9af938c7a29904f0ef57bbb2ec80c86734f13d0d
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/68.exercises/solution.md"
@@ -0,0 +1,87 @@
+# 组合总和
+
+给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
+
+candidates 中的数字可以无限制重复被选取。
+说明：
+
+ - 所有数字（包括
target）都是正整数。
+ - 解集不能包含重复的组合。
+
+示例 1：
+输入：candidates = [2,3,6,7], target = 7,
输出：[[7],[2,2,3]]
+示例 2：
+输入：candidates = [2,3,5], target = 8,
输出：[[2,2,2,2],[2,3,3],[3,5]]
+
+提示：
+
+ 1 <= candidates.length <= 301 <= candidates[i] <= 200candidate 中的每个元素都是独一无二的。1 <= target <= 500
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ vector> combinationSum(vector &candidates, int target)
+ {
+ vector> res;
+ dfs(candidates, 0, target, res);
+ return res;
+ }
+private:
+ vector stack;
+ void dfs(vector &candidates, int start, int target, vector> &res)
+ {
+ if (target < 0)
+ {
+ return;
+ }
+ else if (target == 0)
+ {
+ res.push_back(stack);
+ }
+ else
+ {
+ for (int i = start; i < candidates.size(); i++)
+ {
+ stack.push_back(candidates[i]);
+ dfs(candidates, i, target - candidates[i], res);
+ stack.pop_back();
+ }
+ }
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/69.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/69.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..cd6723138f8cef7daa4d9b4728f9c9f95554c973
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/69.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-4fb12397542c48658eb7ae3481c5f498",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/69.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/69.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..96e52a650b2dcf549cdb9731c5fb0808815a37be
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/69.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "8b79337a58c845938a7db985119f132b"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/69.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/69.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0f66468a177ba1f5411de6901db187dfa8163237
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/69.exercises/solution.md"
@@ -0,0 +1,78 @@
+# 最长回文子串
+
+给你一个字符串 s，找到 s 中最长的回文子串。
示例 1：
输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
示例 2：
输入：s = "cbbd"
输出："bb"
示例 3：
输入：s = "a"
输出："a"
示例 4：
输入：s = "ac"
输出："a"
提示：
1 <= s.length <= 1000s 仅由数字和英文字母（大写和/或小写）组成
+
+## template
+
+```cpp
+class Solution
+{
+public:
+ string longestPalindrome(string s)
+ {
+ int ti = 0, maxlen = 0, i, t;
+ for (i = 0; s[i]; i++)
+ {
+ t = 1;
+ while (t <= i && s[i + t])
+ {
+ if (s[i + t] == s[i - t])
+ t++;
+ else
+ break;
+ }
+ t--;
+ if (2 * t + 1 > maxlen)
+ {
+ ti = i - t;
+ maxlen = 2 * t + 1;
+ }
+ }
+ for (i = 0; s[i]; i++)
+ {
+ t = 1;
+ while (t <= i + 1 && s[i + t])
+ {
+ if (s[i - t + 1] == s[i + t])
+ t++;
+ else
+ break;
+ }
+ t--;
+ if (2 * t > maxlen)
+ {
+ ti = i - t + 1;
+ maxlen = 2 * t;
+ }
+ }
+ s[ti + maxlen] = 0;
+ return s.c_str() + ti;
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/70.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/70.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..c953ef94f37e33b8c93de80ae92969b5e8824fe7
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/70.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-f2434aa992324fc5a9d0a7d6ed419462",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/70.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/70.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..b3df99b4f3964ceae729c78f406b0ca6811717ab
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/70.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "3d244e91c00246a481591cfe5ff62646"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/70.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/70.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2592b5f1a7d0ca7305d8e8ed0977d197288752b6
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/70.exercises/solution.md"
@@ -0,0 +1,120 @@
+# 搜索旋转排序数组 II
+
+已知存在一个按非降序排列的整数数组 nums ，数组中的值不必互不相同。
+在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转
+ ，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0
+ 开始 计数）。例如， [0,1,2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为
+ [4,5,6,6,7,0,1,2,4,4] 。
+
+给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果
+ nums 中存在这个目标值 target ，则返回 true ，否则返回 false 。
+
+
+示例 1：
+输入：nums = [2,5,6,0,0,1,2], target = 0
输出：true
+示例 2：
+输入：nums = [2,5,6,0,0,1,2], target = 3
输出：false
+
+提示：
+
+ 1 <= nums.length <= 5000-104 <= nums[i] <= 104- 题目数据保证
nums 在预先未知的某个下标上进行了旋转
+ -104 <= target <= 104
+
+进阶：
+
+ - 这是 搜索旋转排序数组 的延伸题目，本题中的
nums
+ 可能包含重复元素。
+ - 这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？
+
+
+## template
+
+```cpp
+#include
+#include
+#include
+static bool search(int *nums, int numsSize, int target)
+{
+ int lo = 0;
+ int hi = numsSize - 1;
+ while (lo <= hi)
+ {
+ int mid = lo + (hi - lo) / 2;
+ if (nums[mid] == target)
+ {
+ return true;
+ }
+ if (nums[lo] == nums[mid] && nums[mid] == nums[hi])
+ {
+ lo++;
+ hi--;
+ }
+ else if (nums[lo] <= nums[mid])
+ {
+ if (nums[lo] <= target && target < nums[mid])
+ {
+ hi = mid - 1;
+ }
+ else
+ {
+ lo = mid + 1;
+ }
+ }
+ else
+ {
+ if (nums[mid] < target && target <= nums[hi])
+ {
+ lo = mid + 1;
+ }
+ else
+ {
+ hi = mid - 1;
+ }
+ }
+ }
+ return false;
+}
+int main(int argc, char **argv)
+{
+ int i;
+ int target = atoi(argv[1]);
+ int size = argc - 2;
+ int *nums = malloc(size * sizeof(int));
+ for (i = 0; i < argc - 2; i++)
+ {
+ nums[i] = atoi(argv[i + 2]);
+ }
+ printf("%d\n", search(nums, size, target));
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/71.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/71.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d57e7fdc10c67793eb450f75c855b648d094ee66
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/71.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-2d257036886e4620b688bea9851574e6",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/71.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/71.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..66fb51c20ead3f7242aa78a87f48cf2ae11a0042
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/71.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "315486ff73684c8db585ad3723fd34fe"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/71.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/71.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..15f9add11857f2f783e5195024566a86ab58987e
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/71.exercises/solution.md"
@@ -0,0 +1,105 @@
+# 删除有序数组中的重复项 II
+
+给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 最多出现两次 ，返回删除后数组的新长度。
+不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
+
+说明：
+为什么返回数值是整数，但输出的答案是数组呢？
+请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
+你可以想象内部操作如下:
+
+ // nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
+ int len = removeDuplicates(nums);// 在函数里修改输入数组对于调用者是可见的。
+ // 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
+ for (int i = 0; i < len; i++) {
+ print(nums[i]);
+ }
+
+示例 1：
+输入：nums = [1,1,1,2,2,3]
输出：5, nums = [1,1,2,2,3]
解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。 不需要考虑数组中超出新长度后面的元素。
+示例 2：
+输入：nums = [0,0,1,1,1,1,2,3,3]
输出：7, nums = [0,0,1,1,2,3,3]
解释：函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。 不需要考虑数组中超出新长度后面的元素。
+
+提示：
+
+ 1 <= nums.length <= 3 * 104-104 <= nums[i] <= 104nums 已按升序排列
+
+## template
+
+```cpp
+#include
+#include
+static int removeDuplicates(int *nums, int numsSize)
+{
+ if (numsSize == 0)
+ {
+ return 0;
+ }
+ int i;
+ int len = 0;
+ int count = 1;
+ for (i = 1; i < numsSize; i++)
+ {
+ if (nums[len] == nums[i])
+ {
+ if (count < 2)
+ {
+ count++;
+ nums[++len] = nums[i];
+ }
+ }
+ else
+ {
+ count = 1;
+ nums[++len] = nums[i];
+ }
+ }
+ return len + 1;
+}
+int main(int argc, char **argv)
+{
+ int i, count = argc - 1;
+ int *nums = malloc(count * sizeof(int));
+ for (i = 0; i < count; i++)
+ {
+ nums[i] = atoi(argv[i + 1]);
+ }
+ count = removeDuplicates(nums, count);
+ for (i = 0; i < count; i++)
+ {
+ printf("%d ", nums[i]);
+ }
+ printf("\n");
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/72.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/72.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..6ba2edec06d658d36857053f9340f1502bd196c0
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/72.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-fb130081c8504ef2ac255643f4127920",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/72.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/72.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..07c0ec6fbe3e53f9d6a5ebbe68309b0079688ecf
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/72.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "459e74d4759348c99a03fef12c35a25d"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/72.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/72.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..4f3bfced528763e8b14e685730b52aea9ead3940
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/72.exercises/solution.md"
@@ -0,0 +1,84 @@
+# 交错字符串
+
+给定三个字符串 s1、s2、s3，请你帮忙验证 s3 是否是由 s1 和 s2 交错 组成的。
两个字符串 s 和 t 交错 的定义与过程如下，其中每个字符串都会被分割成若干 非空 子字符串：
s = s1 + s2 + ... + snt = t1 + t2 + ... + tm|n - m| <= 1- 交错 是
s1 + t1 + s2 + t2 + s3 + t3 + ... 或者 t1 + s1 + t2 + s2 + t3 + s3 + ...
提示：a + b 意味着字符串 a 和 b 连接。
示例 1：
输入：s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
输出：true
示例 2：
输入：s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"
输出：false
示例 3：
输入：s1 = "", s2 = "", s3 = ""
输出：true
提示：
0 <= s1.length, s2.length <= 1000 <= s3.length <= 200s1、s2、和 s3 都由小写英文字母组成
+
+## template
+
+```cpp
+#include
+#include
+#include
+#include
+static bool isInterleave(char *s1, char *s2, char *s3)
+{
+ int i, j;
+ int len1 = strlen(s1);
+ int len2 = strlen(s2);
+ int len3 = strlen(s3);
+ if (len1 + len2 != len3)
+ {
+ return false;
+ }
+ bool *table = malloc((len1 + 1) * (len2 + 1) * sizeof(bool));
+ bool **dp = malloc((len1 + 1) * sizeof(bool *));
+ for (i = 0; i < len1 + 1; i++)
+ {
+ dp[i] = &table[i * (len2 + 1)];
+ }
+ dp[0][0] = true;
+ for (i = 1; i < len1 + 1; i++)
+ {
+ dp[i][0] = dp[i - 1][0] && s1[i - 1] == s3[i - 1];
+ }
+ for (i = 1; i < len2 + 1; i++)
+ {
+ dp[0][i] = dp[0][i - 1] && s2[i - 1] == s3[i - 1];
+ }
+ for (i = 1; i < len1 + 1; i++)
+ {
+ for (j = 1; j < len2 + 1; j++)
+ {
+ bool up = dp[i - 1][j] && s1[i - 1] == s3[i + j - 1];
+ bool left = dp[i][j - 1] && s2[j - 1] == s3[i + j - 1];
+ dp[i][j] = up || left;
+ }
+ }
+ return dp[len1][len2];
+}
+int main(int argc, char **argv)
+{
+ if (argc != 4)
+ {
+ fprintf(stderr, "Usage: ./test s1 s2 s3\n");
+ exit(-1);
+ }
+ printf("%s\n", isInterleave(argv[1], argv[2], argv[3]) ? "true" : "false");
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/73.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/73.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..95527f45d6f54832f4c4b1f388d127663b342918
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/73.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-a51ea8b65bae411ea5d0f4083610cc96",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/73.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/73.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..91a4b7bf07c948e41488d388e29ba8860593d06d
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/73.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "964658ce1dee48748e3ea84f1bfa1414"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/73.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/73.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..929a028712fbe47bbca812aef44a75cd48e2cc37
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/73.exercises/solution.md"
@@ -0,0 +1,105 @@
+# 合并区间
+
+以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。
示例 1：
输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
示例 2：
输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。
提示：
1 <= intervals.length <= 104intervals[i].length == 20 <= starti <= endi <= 104
+
+## template
+
+```cpp
+#include
+#include
+#include
+static int compare(const void *a, const void *b)
+{
+ return ((int *)a)[0] - ((int *)b)[0];
+}
+int **merge(int **intervals, int intervalsSize, int *intervalsColSize, int *returnSize, int **returnColumnSizes)
+{
+ if (intervalsSize == 0)
+ {
+ *returnSize = 0;
+ return intervals;
+ }
+ int i, len = 0;
+ int *tmp = malloc(intervalsSize * 2 * sizeof(int));
+ for (i = 0; i < intervalsSize; i++)
+ {
+ tmp[i * 2] = intervals[i][0];
+ tmp[i * 2 + 1] = intervals[i][1];
+ }
+ qsort(tmp, intervalsSize, 2 * sizeof(int), compare);
+ intervals[0][0] = tmp[0];
+ intervals[0][1] = tmp[1];
+ for (i = 1; i < intervalsSize; i++)
+ {
+ if (tmp[i * 2] > intervals[len][1])
+ {
+ len++;
+ intervals[len][0] = tmp[i * 2];
+ intervals[len][1] = tmp[i * 2 + 1];
+ }
+ else if (tmp[i * 2 + 1] > intervals[len][1])
+ {
+ intervals[len][1] = tmp[i * 2 + 1];
+ }
+ }
+ len += 1;
+ *returnSize = len;
+ *returnColumnSizes = malloc(len * sizeof(int));
+ for (i = 0; i < len; i++)
+ {
+ (*returnColumnSizes)[i] = 2;
+ }
+ return intervals;
+}
+int main(int argc, char **argv)
+{
+ if (argc < 1 || argc % 2 == 0)
+ {
+ fprintf(stderr, "Usage: ./test s0 e0 s1 e1...");
+ exit(-1);
+ }
+ int i, count = 0;
+ int *sizes = malloc((argc - 1) / 2 * sizeof(int));
+ int **intervals = malloc((argc - 1) / 2 * sizeof(int *));
+ for (i = 0; i < (argc - 1) / 2; i++)
+ {
+ sizes[i] = 2;
+ intervals[i] = malloc(2 * sizeof(int));
+ intervals[i][0] = atoi(argv[i * 2 + 1]);
+ intervals[i][1] = atoi(argv[i * 2 + 2]);
+ }
+ int *col_sizes;
+ int **results = merge(intervals, (argc - 1) / 2, sizes, &count, &col_sizes);
+ for (i = 0; i < count; i++)
+ {
+ printf("[%d,%d]\n", results[i][0], results[i][1]);
+ }
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/74.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/74.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..c8f17734103d75402ef2fbe0dffa01cde8858c98
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/74.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-f0b3392045414af9802c10e6fadeb185",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/74.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/74.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..5269ee4fa50a706d7b912bac4372a8ce9125c427
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/74.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "a0be7844bb474524b9b2f6c8dead32a4"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/74.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/74.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f4541f605de58510e3e86edb4b0fd5112480b6f5
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/74.exercises/solution.md"
@@ -0,0 +1,91 @@
+# 三数之和
+
+给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例 1：
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
示例 2：
输入：nums = []
输出：[]
示例 3：
输入：nums = [0]
输出：[]
提示：
0 <= nums.length <= 3000-105 <= nums[i] <= 105
+
+## template
+
+```cpp
+#include
+#include
+class Solution
+{
+public:
+ vector> threeSum(vector &nums)
+ {
+ vector> r;
+ if (nums.size() == 0)
+ return r;
+ sort(nums.begin(), nums.end());
+ int cur, left, right;
+ cur = 0;
+ while (cur < nums.size())
+ {
+ if (nums[cur] > 0)
+ break;
+ left = cur + 1;
+ right = nums.size() - 1;
+ while (left < right)
+ {
+ int n = nums[cur] + nums[left] + nums[right];
+ if (n == 0)
+ {
+ r.emplace_back(vector({nums[cur], nums[left], nums[right]}));
+ int t = left + 1;
+ while (t < right && nums[t] == nums[left])
+ t++;
+ left = t;
+ t = right - 1;
+ while (t > left && nums[t] == nums[right])
+ t--;
+ right = t;
+ }
+ else if (n > 0)
+ {
+ int t = right - 1;
+ while (t > left && nums[t] == nums[right])
+ t--;
+ right = t;
+ }
+ else
+ {
+ int t = left + 1;
+ while (t < right && nums[t] == nums[left])
+ t++;
+ left = t;
+ }
+ }
+ int t = cur + 1;
+ while (t < nums.size() && nums[t] == nums[cur])
+ t++;
+ cur = t;
+ }
+ return r;
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/75.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/75.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..40955c082b60c841515601699498f46ad645b814
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/75.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-15e8eacd0cf64134895c9e304650f07f",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/75.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/75.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..cefd609d7b8447ae442ddad858741cf5d8ca4e89
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/75.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "b8e1d751af744d3ca85218cc8f0e45e6"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/75.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/75.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..75928db77eb0ccce00af83f44bbbcd82865db1ab
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/75.exercises/solution.md"
@@ -0,0 +1,64 @@
+# 字符串相乘
+
+给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。
示例 1:
输入: num1 = "2", num2 = "3"
输出: "6"
示例 2:
输入: num1 = "123", num2 = "456"
输出: "56088"
说明：
num1 和 num2 的长度小于110。num1 和 num2 只包含数字 0-9。num1 和 num2 均不以零开头，除非是数字 0 本身。- 不能使用任何标准库的大数类型（比如 BigInteger）或直接将输入转换为整数来处理。
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ string multiply(string num1, string num2)
+ {
+ string res(num1.length() + num2.length(), '0');
+ for (int i = num2.length() - 1; i >= 0; i--)
+ {
+ int j, carry = 0;
+ for (j = num1.length() - 1; j >= 0; j--)
+ {
+ carry += (num1[j] - '0') * (num2[i] - '0') + (res[i + j + 1] - '0');
+ res[i + j + 1] = carry % 10 + '0';
+ carry /= 10;
+ }
+ res[i + j + 1] = carry + '0';
+ }
+ int i;
+ for (i = 0; i < res.length() - 1; i++)
+ {
+ if (res[i] != '0')
+ {
+ break;
+ }
+ }
+ return res.substr(i);
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/76.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/76.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..b66897a8fd9a70448d847f6c53230bd1ec2125bc
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/76.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-fa325972af1746b4a703e0ee3bb55329",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/76.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/76.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..6f52e76b2f82a9aa7081389e39c547a1e9916c21
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/76.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "d36efbcaa793497eb9cef338ca029367"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/76.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/76.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..1318e8d0662b06627bd0990ad4e7460ddfce612d
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/76.exercises/solution.md"
@@ -0,0 +1,83 @@
+# 最接近的三数之和
+
+给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
示例：
输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
提示：
3 <= nums.length <= 10^3-10^3 <= nums[i] <= 10^3-10^4 <= target <= 10^4
+
+## template
+
+```cpp
+#include
+class Solution
+{
+public:
+ int threeSumClosest(vector &nums, int target)
+ {
+ sort(nums.begin(), nums.end());
+ int cur, left, right;
+ cur = 0;
+ int closest = nums[0] + nums[1] + nums[2];
+ while (cur < nums.size() - 2)
+ {
+ left = cur + 1;
+ right = nums.size() - 1;
+ int n;
+ while (left < right)
+ {
+ n = nums[cur] + nums[left] + nums[right];
+ if (abs(target - n) < abs(target - closest))
+ {
+ closest = n;
+ }
+ if (n == target)
+ {
+ break;
+ }
+ else if (n > target)
+ {
+ int t = right - 1;
+ while (t > left && nums[t] == nums[right])
+ t--;
+ right = t;
+ }
+ else
+ {
+ int t = left + 1;
+ while (t < right && nums[t] == nums[left])
+ t++;
+ left = t;
+ }
+ }
+ int t = cur + 1;
+ while (t < nums.size() && nums[t] == nums[cur])
+ t++;
+ cur = t;
+ }
+ return closest;
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/77.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/77.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..04d5b35c8086dcc542ec2d1460dd993e373ce64b
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/77.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-f6fc759a81fe4b0abc4892c6c6b5e345",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/77.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/77.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..3212360f104860f521cbfb7bda357e7d96e0fc43
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/77.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "5ad6f96648d0498d89d8d596e51d60cb"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/77.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/77.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..55bdbb4e687efa6f05c0a48aec58bb7545552f73
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/77.exercises/solution.md"
@@ -0,0 +1,65 @@
+# 跳跃游戏
+
+给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个下标。
示例 1：
输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
示例 2：
输入：nums = [3,2,1,0,4]
输出：false
解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。
提示：
1 <= nums.length <= 3 * 1040 <= nums[i] <= 105
+
+## template
+
+```cpp
+#include
+#include
+#include
+static inline int max(int a, int b)
+{
+ return a > b ? a : b;
+}
+static bool canJump(int *nums, int numsSize)
+{
+ int i, pos = 0;
+ for (i = 0; i < numsSize - 1; i++)
+ {
+ if (pos < i || pos >= numsSize - 1)
+ {
+ break;
+ }
+ pos = max(i + nums[i], pos);
+ }
+ return pos >= numsSize - 1;
+}
+int main(int argc, char **argv)
+{
+ int i, count = argc - 1;
+ int *nums = malloc(count * sizeof(int));
+ for (i = 0; i < count; i++)
+ {
+ nums[i] = atoi(argv[i + 1]);
+ }
+ printf("%s\n", canJump(nums, count) ? "true" : "false");
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/78.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/78.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d7eb04d2e36f020f3d32e02af89cd969c16e4def
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/78.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-54ba584225b140f083bfc38f750bff12",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/78.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/78.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d3197a35d7b9479aa66947b95d112e9beb2d3d5b
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/78.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "c8233a1315554943a1914fc8de46baf1"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/78.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/78.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..21e6e71d91bd73428cf5aa96113a2b32067970a9
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/78.exercises/solution.md"
@@ -0,0 +1,102 @@
+# 单词搜索
+
+给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
示例 1：
输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true
示例 2：
输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "SEE"
输出：true
示例 3：
输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"
输出：false
提示：
m == board.lengthn = board[i].length1 <= m, n <= 61 <= word.length <= 15board 和 word 仅由大小写英文字母组成
进阶：你可以使用搜索剪枝的技术来优化解决方案，使其在 board 更大的情况下可以更快解决问题？
+
+## template
+
+```cpp
+#include
+#include
+#include
+#include
+static bool dfs(char *word, char **board, bool *used,
+ int row, int col, int row_size, int col_size)
+{
+ if (board[row][col] != *word)
+ {
+ return false;
+ }
+ used[row * col_size + col] = true;
+ if (*(word + 1) == '\0')
+ {
+ return true;
+ }
+ bool result = false;
+ if (row > 0 && !used[(row - 1) * col_size + col])
+ {
+ result = dfs(word + 1, board, used, row - 1, col, row_size, col_size);
+ }
+ if (!result && row < row_size - 1 && !used[(row + 1) * col_size + col])
+ {
+ result = dfs(word + 1, board, used, row + 1, col, row_size, col_size);
+ }
+ if (!result && col > 0 && !used[row * col_size + col - 1])
+ {
+ result = dfs(word + 1, board, used, row, col - 1, row_size, col_size);
+ }
+ if (!result && col < col_size - 1 && !used[row * col_size + col + 1])
+ {
+ result = dfs(word + 1, board, used, row, col + 1, row_size, col_size);
+ }
+ used[row * col_size + col] = false;
+ return result;
+}
+static bool exist(char **board, int boardRowSize, int boardColSize, char *word)
+{
+ int i, j;
+ int len = strlen(word);
+ if (len > boardRowSize * boardColSize)
+ {
+ return false;
+ }
+ bool *used = malloc(boardRowSize * boardColSize);
+ for (i = 0; i < boardRowSize; i++)
+ {
+ for (j = 0; j < boardColSize; j++)
+ {
+ memset(used, false, boardRowSize * boardColSize);
+ if (dfs(word, board, used, i, j, boardRowSize, boardColSize))
+ {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+int main(int argc, char **argv)
+{
+ if (argc < 3)
+ {
+ fprintf(stderr, "Usage: ./test word row1 row2...\n");
+ exit(-1);
+ }
+ printf("%s\n", exist(argv + 2, argc - 2, strlen(argv[2]), argv[1]) ? "true" : "false");
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/79.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/79.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..a503b136e764f8ad4325019762b2ea8acb397bc1
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/79.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-c1db08ac05da4c63bf72f736426191b9",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/79.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/79.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..a9a33ce32c13eb36b969eccfa0af26b7424e60de
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/79.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "bab18cbedf4149a391c23d4a8c90bf9b"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/79.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/79.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9633687c6b3912afec1c7c833f91967db95c6fda
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/79.exercises/solution.md"
@@ -0,0 +1,110 @@
+# 验证二叉搜索树
+
+
+
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。
+
+
有效 二叉搜索树定义如下：
+
+
+ - 节点的左子树只包含 小于 当前节点的数。
+ - 节点的右子树只包含 大于 当前节点的数。
+ - 所有左子树和右子树自身必须也是二叉搜索树。
+
+
+
+
+
示例 1：
+
+
输入：root = [2,1,3]
+输出：true
+
+
+
示例 2：
+
+
输入：root = [5,1,4,null,null,3,6]
+输出：false
+解释：根节点的值是 5 ，但是右子节点的值是 4 。
+
+
+
+
+
提示：
+
+
+ - 树中节点数目范围在
[1, 104] 内
+ -231 <= Node.val <= 231 - 1
+
存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除链表中所有存在数字重复情况的节点，只保留原始链表中 没有重复出现 的数字。
返回同样按升序排列的结果链表。
示例 1：
输入：head = [1,2,3,3,4,4,5]
输出：[1,2,5]
示例 2：
输入：head = [1,1,1,2,3]
输出：[2,3]
提示：
- 链表中节点数目在范围
[0, 300] 内 -100 <= Node.val <= 100- 题目数据保证链表已经按升序排列
+
+## template
+
+```cpp
+#include
+#include
+struct ListNode
+{
+ int val;
+ struct ListNode *next;
+};
+struct ListNode *deleteDuplicates(struct ListNode *head)
+{
+ struct ListNode dummy;
+ struct ListNode *p, *q, *prev;
+ prev = &dummy;
+ dummy.next = head;
+ p = q = head;
+ while (p != NULL)
+ {
+ while (q != NULL && q->val == p->val)
+ {
+ q = q->next;
+ }
+ if (p->next == q)
+ {
+ prev = p;
+ }
+ else
+ {
+ prev->next = q;
+ }
+ p = q;
+ }
+ return dummy.next;
+}
+int main(int argc, char **argv)
+{
+ int i;
+ struct ListNode *head = NULL;
+ struct ListNode *prev = NULL;
+ struct ListNode *p;
+ for (i = 0; i < argc - 1; i++)
+ {
+ p = malloc(sizeof(*p));
+ p->val = atoi(argv[i + 1]);
+ p->next = NULL;
+ if (head == NULL)
+ {
+ head = p;
+ prev = head;
+ }
+ else
+ {
+ prev->next = p;
+ prev = p;
+ }
+ }
+ p = deleteDuplicates(head);
+ while (p != NULL)
+ {
+ printf("%d ", p->val);
+ p = p->next;
+ }
+ printf("\n");
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/81.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/81.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..302e4bdaa2711c6a4c437730f224a51083ee3088
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/81.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-a985201eb15543b2963a17e2d14a7f3d",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/81.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/81.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..ad69c873885541019c1bf98dac8688e57995d69a
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/81.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "940fcda088b8488b999d47f7dfbe097f"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/81.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/81.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..107f12bf9d03cc4261a569f41052c6bcb7575288
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/81.exercises/solution.md"
@@ -0,0 +1,127 @@
+# Z 字形变换
+
+
+
将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。
+
+
比如输入字符串为 "PAYPALISHIRING" 行数为 3 时，排列如下：
+
+
+ P A H N
+ A P L S I I G
+ Y I R
+
+
之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："PAHNAPLSIIGYIR"。
+
+
请你实现这个将字符串进行指定行数变换的函数：
+
+
string convert(string s, int numRows);
+
+
+
+
示例 1：
+
+
输入：s = "PAYPALISHIRING", numRows = 3
+输出："PAHNAPLSIIGYIR"
+
+
示例 2：
+
+
输入：s = "PAYPALISHIRING", numRows = 4
+输出："PINALSIGYAHRPI"
+解释：
+P I N
+A L S I G
+Y A H R
+P I
+
+
+
示例 3：
+
+
输入：s = "A", numRows = 1
+输出："A"
+
+
+
+
+
提示：
+
+
+ 1 <= s.length <= 1000s 由英文字母（小写和大写）、',' 和 '.' 组成1 <= numRows <= 1000
+
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
+
+candidates 中的每个数字在每个组合中只能使用一次。
+说明：
+
+ - 所有数字（包括目标数）都是正整数。
+ - 解集不能包含重复的组合。
+
+示例 1:
+输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:[[1, 7],[1, 2, 5],[2, 6],[1, 1, 6]]
+示例 2:
+输入: candidates = [2,5,2,1,2], target = 5,
所求解集为:[[1,2,2],[5]]
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ vector> combinationSum2(vector &candidates, int target)
+ {
+ vector> res;
+ sort(candidates.begin(), candidates.end());
+ dfs(candidates, 0, target, res);
+ return res;
+ }
+private:
+ vector stack;
+ void dfs(vector &candidates, int start, int target, vector> &res)
+ {
+ if (target < 0)
+ {
+ return;
+ }
+ else if (target == 0)
+ {
+ res.push_back(stack);
+ }
+ else
+ {
+ int last = INT_MIN;
+ for (int i = start; i < candidates.size(); i++)
+ {
+ if (last != candidates[i])
+ {
+ stack.push_back(candidates[i]);
+ dfs(candidates, i + 1, target - candidates[i], res);
+ stack.pop_back();
+ }
+ last = candidates[i];
+ }
+ }
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/83.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/83.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d5081b6e678483213833c07bf962b15bee304d3b
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/83.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-cf85f408907543ee806a3d2332a07e72",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/83.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/83.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..20e49f51527447522105c784cff80f683e2f1a20
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/83.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "2cea3fbdd79e47f3a2696f1be97e1414"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/83.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/83.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..a0531011cf8ed6fb759311d0b24f8a0cafa3160c
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/83.exercises/solution.md"
@@ -0,0 +1,87 @@
+# 螺旋矩阵 II
+
+给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
示例 1：
输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]
示例 2：
输入：n = 1
输出：[[1]]
提示：
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ vector> generateMatrix(int n)
+ {
+ vector> matrix(n, vector(n));
+ int direction = 0;
+ int hor_top = 0;
+ int hor_bottom = n - 1;
+ int ver_left = 0;
+ int ver_right = n - 1;
+ int num = 0;
+ while (num < n * n)
+ {
+ switch (direction)
+ {
+ case 0:
+ for (int i = ver_left; i <= ver_right; i++)
+ {
+ matrix[hor_top][i] = ++num;
+ }
+ hor_top++;
+ break;
+ case 1:
+ for (int i = hor_top; i <= hor_bottom; i++)
+ {
+ matrix[i][ver_right] = ++num;
+ }
+ ver_right--;
+ break;
+ case 2:
+ for (int i = ver_right; i >= ver_left; i--)
+ {
+ matrix[hor_bottom][i] = ++num;
+ }
+ hor_bottom--;
+ break;
+ case 3:
+ for (int i = hor_bottom; i >= hor_top; i--)
+ {
+ matrix[i][ver_left] = ++num;
+ }
+ ver_left++;
+ break;
+ }
+ direction++;
+ direction %= 4;
+ }
+ return matrix;
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/84.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/84.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..824ae17a02ee95eb2bfa8d1f2f0c043ffafb9e3d
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/84.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-f0add5b941524853ba8bce1d170cdd3a",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/84.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/84.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..3d725971ce04adf8d16188c892446336dccde0cc
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/84.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "82543cb9e99d4953a0ea8531316a2f27"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/84.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/84.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..3d6fb609817654ef9efd982ad15e1904d4a7c36a
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/84.exercises/solution.md"
@@ -0,0 +1,63 @@
+# 两两交换链表中的节点
+
+给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]
提示：
- 链表中节点的数目在范围
[0, 100] 内 0 <= Node.val <= 100
进阶：你能在不修改链表节点值的情况下解决这个问题吗?（也就是说，仅修改节点本身。）
+
+## template
+
+```cpp
+#include
+using namespace std;
+struct ListNode
+{
+ int val;
+ ListNode *next;
+ ListNode() : val(0), next(nullptr) {}
+ ListNode(int x) : val(x), next(nullptr) {}
+ ListNode(int x, ListNode *next) : val(x), next(next) {}
+};
+class Solution
+{
+public:
+ ListNode *swapPairs(ListNode *head)
+ {
+ struct ListNode dummy, *prev = &dummy, *p = head;
+ dummy.next = head;
+ while (p != nullptr && p->next != nullptr)
+ {
+ struct ListNode *q = p->next;
+ p->next = q->next;
+ q->next = prev->next;
+ prev->next = q;
+ prev = p;
+ p = p->next;
+ }
+ return dummy.next;
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/85.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/85.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..11c8f56e14d4c6b8b890d6881ee3baac9bd4801a
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/85.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-1a32ddc1ddca400c8b063f6d19fb8907",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/85.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/85.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..a1c73683425ee715b81a91affa5a39cf174bff3b
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/85.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "296fd8f82ac4470d8c077f261b73e0bf"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/85.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/85.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..973dd513499f60d742f66e32d6e1dcbc9587d8d8
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/85.exercises/solution.md"
@@ -0,0 +1,73 @@
+# 颜色分类
+
+给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。
此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。
示例 1：
输入：nums = [2,0,2,1,1,0]
输出：[0,0,1,1,2,2]
示例 2：
输入：nums = [2,0,1]
输出：[0,1,2]
示例 3：
输入：nums = [0]
输出：[0]
示例 4：
输入：nums = [1]
输出：[1]
提示：
n == nums.length1 <= n <= 300nums[i] 为 0、1 或 2
进阶：
- 你可以不使用代码库中的排序函数来解决这道题吗？
- 你能想出一个仅使用常数空间的一趟扫描算法吗？
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ void sortColors(vector &nums)
+ {
+ int i = 0, j = nums.size() - 1;
+ while (i < j)
+ {
+ if (nums[i] == 0)
+ {
+ i++;
+ continue;
+ }
+ if (nums[j] != 0)
+ {
+ j--;
+ continue;
+ }
+ swap(nums[i], nums[j]);
+ }
+ j = nums.size() - 1;
+ while (i < j)
+ {
+ if (nums[i] == 1)
+ {
+ i++;
+ continue;
+ }
+ if (nums[j] != 1)
+ {
+ j--;
+ continue;
+ }
+ swap(nums[i], nums[j]);
+ }
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/86.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/86.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..74c44ac62f64693d76d833ca908938f712c1b136
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/86.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-9b3d74b35c564dfaab8603a7b2110f65",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/86.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/86.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..849d1810408a28b8f49755ba93fdbb6da9b86953
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/86.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "e8c5ac6556174e368ff9752403716ada"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/86.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/86.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f8c5b94b788f57cb162673b75c192f8bdc80f498
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/86.exercises/solution.md"
@@ -0,0 +1,138 @@
+# 不同路径 II
+
+一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
+机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
+现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
+
+网格中的障碍物和空位置分别用 1 和 0 来表示。
+
+示例 1：
+输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出：2
解释：3x3 网格的正中间有一个障碍物。从左上角到右下角一共有 2 条不同的路径：
1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右
+示例 2：
+输入：obstacleGrid = [[0,1],[0,0]]
输出：1
+
+提示：
+
+ m == obstacleGrid.lengthn == obstacleGrid[i].length1 <= m, n <= 100obstacleGrid[i][j] 为 0 或 1
+
+## template
+
+```cpp
+#include
+#include
+static int uniquePathsWithObstacles(int **obstacleGrid, int obstacleGridRowSize, int obstacleGridColSize)
+{
+ int row, col;
+ int reset = 0;
+ for (row = 0; row < obstacleGridRowSize; row++)
+ {
+ if (reset)
+ {
+ obstacleGrid[row][0] = 1;
+ }
+ else
+ {
+ if (obstacleGrid[row][0] == 1)
+ {
+ reset = 1;
+ }
+ }
+ }
+ reset = 0;
+ for (col = 0; col < obstacleGridColSize; col++)
+ {
+ if (reset)
+ {
+ obstacleGrid[0][col] = 1;
+ }
+ else
+ {
+ if (obstacleGrid[0][col] == 1)
+ {
+ reset = 1;
+ }
+ }
+ }
+ for (row = 0; row < obstacleGridRowSize; row++)
+ {
+ int *line = obstacleGrid[row];
+ for (col = 0; col < obstacleGridColSize; col++)
+ {
+ line[col] ^= 1;
+ }
+ }
+ for (row = 1; row < obstacleGridRowSize; row++)
+ {
+ int *last_line = obstacleGrid[row - 1];
+ int *line = obstacleGrid[row];
+ for (col = 1; col < obstacleGridColSize; col++)
+ {
+ if (line[col] != 0)
+ {
+ line[col] = line[col - 1] + last_line[col];
+ }
+ }
+ }
+ return obstacleGrid[obstacleGridRowSize - 1][obstacleGridColSize - 1];
+}
+int main(int argc, char **argv)
+{
+ if (argc < 3)
+ {
+ fprintf(stderr, "Usage: ./test m n\n");
+ exit(-1);
+ }
+ int i, j, k = 3;
+ int row_size = atoi(argv[1]);
+ int col_size = atoi(argv[2]);
+ int **grids = malloc(row_size * sizeof(int *));
+ for (i = 0; i < row_size; i++)
+ {
+ grids[i] = malloc(col_size * sizeof(int));
+ int *line = grids[i];
+ for (j = 0; j < col_size; j++)
+ {
+ line[j] = atoi(argv[k++]);
+ printf("%d ", line[j]);
+ }
+ printf("\n");
+ }
+ printf("%d\n", uniquePathsWithObstacles(grids, row_size, col_size));
+ return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/87.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/87.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..53ce93e09f626b901809e4d1ff5a53d27a68927c
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/87.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-2241bbc6d900433d918667440b3f2dbf",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/87.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/87.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..0476a9143e7643fdbe04a8fe7ef710996e7c50ad
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/87.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "https://github.com/begeekmyfriend/leetcode",
+ "source": "solution.md",
+ "exercise_id": "0d64ba7398c344fca20c0b90624f3680"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/1.cpp/87.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/87.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..8a05b893d62f821801d527d0cc4d731709e6732f
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/1.cpp/87.exercises/solution.md"
@@ -0,0 +1,146 @@
+# 有效的数独
+
+请你判断一个 9x9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。
+
+ - 数字
1-9 在每一行只能出现一次。
+ - 数字
1-9 在每一列只能出现一次。
+ - 数字
1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
+
+数独部分空格内已填入了数字，空白格用 '.' 表示。
+注意：
+
+ - 一个有效的数独（部分已被填充）不一定是可解的。
+ - 只需要根据以上规则，验证已经填入的数字是否有效即可。
+
+
+示例 1：
+输入：board =
+ [["5","3",".",".","7",".",".",".","."]
+ ,["6",".",".","1","9","5",".",".","."]
+ ,[".","9","8",".",".",".",".","6","."]
+ ,["8",".",".",".","6",".",".",".","3"]
+ ,["4",".",".","8",".","3",".",".","1"]
+ ,["7",".",".",".","2",".",".",".","6"]
+ ,[".","6",".",".",".",".","2","8","."]
+ ,[".",".",".","4","1","9",".",".","5"]
+ ,[".",".",".",".","8",".",".","7","9"]]
+输出：true
+
+示例 2：
+输入：board =
+ [["8","3",".",".","7",".",".",".","."]
+ ,["6",".",".","1","9","5",".",".","."]
+ ,[".","9","8",".",".",".",".","6","."]
+ ,["8",".",".",".","6",".",".",".","3"]
+ ,["4",".",".","8",".","3",".",".","1"]
+ ,["7",".",".",".","2",".",".",".","6"]
+ ,[".","6",".",".",".",".","2","8","."]
+ ,[".",".",".","4","1","9",".",".","5"]
+ ,[".",".",".",".","8",".",".","7","9"]]
+输出：false
+解释：除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。 但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。
+
+提示：
+
+ board.length == 9board[i].length == 9board[i][j] 是一位数字或者 '.'
+
+## template
+
+```cpp
+#include
+using namespace std;
+class Solution
+{
+public:
+ bool isValidSudoku(vector> &board)
+ {
+ for (int i = 0; i < board.size(); i++)
+ {
+ vector mark(10);
+ for (int j = 0; j < board.size(); j++)
+ {
+ if (!valid(board, mark, i, j))
+ {
+ return false;
+ }
+ }
+ }
+ for (int j = 0; j < board.size(); j++)
+ {
+ vector mark(10);
+ for (int i = 0; i < board.size(); i++)
+ {
+ if (!valid(board, mark, i, j))
+ {
+ return false;
+ }
+ }
+ }
+ for (int k = 0; k < board.size(); k++)
+ {
+ int sr = k / 3 * 3;
+ int sc = (k % 3) * 3;
+ vector mark(10);
+ for (int i = sr; i < sr + 3; i++)
+ {
+ for (int j = sc; j < sc + 3; j++)
+ {
+ if (!valid(board, mark, i, j))
+ {
+ return false;
+ }
+ }
+ }
+ }
+ return true;
+ }
+private:
+ bool valid(vector> &board, vector &mark, int i, int j)
+ {
+ if (board[i][j] != '.')
+ {
+ int index = board[i][j] - '0';
+ if (mark[index])
+ {
+ return false;
+ }
+ else
+ {
+ mark[index] = 1;
+ }
+ }
+ return true;
+ }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/10.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/10.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..b0a30bdb1f28f49552406bca639bfc0974e955ae
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/10.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-8c77fcb047c0495bafecdfcd1de6ff22",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/10.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/10.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..3fd9f7763dd13332fd3cb1e52f3a9959661abd43
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/10.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "fcf347d163044712ade2667f4edca699"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/10.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/10.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9b117f71f3b16d30a97fa2f0b36e15bc57cffbf2
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/10.exercises/solution.md"
@@ -0,0 +1,108 @@
+# 不同的二叉搜索树 II
+
+
+
给你一个整数 n ，请你生成并返回所有由 n 个节点组成且节点值从 1 到 n 互不相同的不同
+ 二叉搜索树 。可以按 任意顺序 返回答案。
+
+
+
+
+
+
+
示例 1：
+
+
输入：n = 3
+输出：[[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]
+
+
+
示例 2：
+
+
输入：n = 1
+输出：[[1]]
+
+
+
+
+
提示：
+
+
+
+
+
+
请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。
+
+
函数 myAtoi(string s) 的算法如下：
+
+
+ - 读入字符串并丢弃无用的前导空格
+ - 检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
+ - 读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
+ - 将前面步骤读入的这些数字转换为整数（即，"123" -> 123， "0032" -> 32）。如果没有读入数字，则整数为
0 。必要时更改符号（从步骤 2 开始）。
+ - 如果整数数超过 32 位有符号整数范围
[−231, 231 − 1]
+ ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于
+ 231 − 1 的整数应该被固定为 231 − 1 。
+
+ - 返回整数作为最终结果。
+
+
+
注意：
+
+
+ - 本题中的空白字符只包括空格字符
' ' 。
+ - 除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。
+
+
+
+
+
示例 1：
+
+
输入：s = "42"
+输出：42
+解释：加粗的字符串为已经读入的字符，插入符号是当前读取的字符。
+第 1 步："42"（当前没有读入字符，因为没有前导空格）
+ ^
+第 2 步："42"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
+ ^
+第 3 步："42"（读入 "42"）
+ ^
+解析得到整数 42 。
+由于 "42" 在范围 [-231, 231 - 1] 内，最终结果为 42 。
+
+
示例 2：
+
+
输入：s = " -42"
+输出：-42
+解释：
+第 1 步：" -42"（读入前导空格，但忽视掉）
+ ^
+第 2 步：" -42"（读入 '-' 字符，所以结果应该是负数）
+ ^
+第 3 步：" -42"（读入 "42"）
+ ^
+解析得到整数 -42 。
+由于 "-42" 在范围 [-231, 231 - 1] 内，最终结果为 -42 。
+
+
+
示例 3：
+
+
输入：s = "4193 with words"
+输出：4193
+解释：
+第 1 步："4193 with words"（当前没有读入字符，因为没有前导空格）
+ ^
+第 2 步："4193 with words"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
+ ^
+第 3 步："4193 with words"（读入 "4193"；由于下一个字符不是一个数字，所以读入停止）
+ ^
+解析得到整数 4193 。
+由于 "4193" 在范围 [-231, 231 - 1] 内，最终结果为 4193 。
+
+
+
示例 4：
+
+
输入：s = "words and 987"
+输出：0
+解释：
+第 1 步："words and 987"（当前没有读入字符，因为没有前导空格）
+ ^
+第 2 步："words and 987"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
+ ^
+第 3 步："words and 987"（由于当前字符 'w' 不是一个数字，所以读入停止）
+ ^
+解析得到整数 0 ，因为没有读入任何数字。
+由于 0 在范围 [-231, 231 - 1] 内，最终结果为 0 。
+
+
示例 5：
+
+
输入：s = "-91283472332"
+输出：-2147483648
+解释：
+第 1 步："-91283472332"（当前没有读入字符，因为没有前导空格）
+ ^
+第 2 步："-91283472332"（读入 '-' 字符，所以结果应该是负数）
+ ^
+第 3 步："-91283472332"（读入 "91283472332"）
+ ^
+解析得到整数 -91283472332 。
+由于 -91283472332 小于范围 [-231, 231 - 1] 的下界，最终结果被截断为 -231 = -2147483648 。
+
+
+
+
提示：
+
+
+ 0 <= s.length <= 200s 由英文字母（大写和小写）、数字（0-9）、' '、'+'、'-' 和
+ '.' 组成
+
+
+
给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树
+ 有多少种？返回满足题意的二叉搜索树的种数。
+
+
+
+
示例 1：
+
+
输入：n = 3
+输出：5
+
+
+
示例 2：
+
+
输入：n = 1
+输出：1
+
+
+
+
+
提示：
+
+
+
给你一个 无重叠的 ，按照区间起始端点排序的区间列表。
+在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。
+
+示例 1：
+输入：intervals = [[1,3],[6,9]], newInterval = [2,5]
输出：[[1,5],[6,9]]
+示例 2：
+输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
输出：[[1,2],[3,10],[12,16]]
解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。
+示例 3：
+输入：intervals = [], newInterval = [5,7]
输出：[[5,7]]
+示例 4：
+输入：intervals = [[1,5]], newInterval = [2,3]
输出：[[1,5]]
+示例 5：
+输入：intervals = [[1,5]], newInterval = [2,7]
输出：[[1,7]]
+
+提示：
+
+ 0 <= intervals.length <= 104intervals[i].length == 20 <= intervals[i][0] <= intervals[i][1] <= 105intervals 根据 intervals[i][0] 按 升序 排列newInterval.length == 20 <= newInterval[0] <= newInterval[1] <= 105
+
+## template
+
+```java
+
+public class Interval {
+ int start;
+ int end;
+
+ Interval() {
+ start = 0;
+ end = 0;
+ }
+
+ Interval(int s, int e) {
+ start = s;
+ end = e;
+ }
+}
+
+class Solution {
+ public int[][] insert(int[][] intervals, int[] newInterval) {
+ int[][] newIntervals = new int[intervals.length + 1][];
+ System.arraycopy(intervals, 0, newIntervals, 0, intervals.length);
+ newIntervals[intervals.length] = newInterval;
+
+ Arrays.sort(newIntervals, (a, b) -> a[0] - b[0]);
+ Stack stack = new Stack<>();
+ for (int[] num : newIntervals) {
+ if (stack.isEmpty()) {
+ stack.push(num);
+ continue;
+ }
+ int[] arr = stack.peek();
+ if (arr[1] >= num[0]) {
+ int[] combine = { arr[0], Math.max(arr[1], num[1]) };
+ stack.pop();
+ stack.push(combine);
+ } else {
+ stack.push(num);
+ }
+ }
+ return stack.toArray(new int[0][]);
+ }
+}
+
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/14.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/14.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..225ff84db716babdac0af355580d757ab167b966
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/14.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-19da8c9496ca40f6adc9b8657a95f7f3",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/14.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/14.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..8e967ade16ebb1193d938ff828ffa2ce1ed9794c
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/14.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "6b126d016c65401599231bcb942ff2bd"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/14.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/14.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..29a7321339dbbd8a62ad16536e2e2a43e4b2d779
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/14.exercises/solution.md"
@@ -0,0 +1,69 @@
+# 四数之和
+
+给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：答案中不可以包含重复的四元组。
示例 1：
输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例 2：
输入：nums = [], target = 0
输出：[]
提示：
0 <= nums.length <= 200-109 <= nums[i] <= 109-109 <= target <= 109
+
+## template
+
+```java
+class Solution {
+ public List> fourSum(int[] nums, int target) {
+ long l_target = target;
+ Arrays.sort(nums);
+ List> results = new ArrayList<>();
+ int N = nums.length;
+ for (int i = 0; i < N - 3; i++) {
+ if (i > 0 && nums[i] == nums[i - 1])
+ continue;
+ for (int j = i + 1; j < N - 2; j++) {
+ if (j > i + 1 && nums[j] == nums[j - 1])
+ continue;
+ for (int k = j + 1, l = N - 1; k < l; k++) {
+ if (k > j + 1 && nums[k] == nums[k - 1])
+ continue;
+ while (k < l && (l_target - nums[i] - nums[j] - nums[k] - nums[l]) < 0) {
+ l--;
+ }
+ if (k >= l) {
+ break;
+ }
+ if ((target - nums[i] - nums[j] - nums[k] - nums[l]) == 0) {
+ List item = new ArrayList<>();
+ item.add(nums[i]);
+ item.add(nums[j]);
+ item.add(nums[k]);
+ item.add(nums[l]);
+ results.add(item);
+ }
+ }
+ }
+ }
+ return results;
+ }
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/15.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/15.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..4b9380f2eec652927a84b4b1d8ab2813a79d21b2
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/15.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-47e9de3a5ef1478883bf32125ea2bdf3",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/15.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/15.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..63ef68d84d886a81fb997f90e51f57032b60e709
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/15.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "72a749865e8f4cf8aeb9b9cf7e3d8ed3"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/15.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/15.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..4bb94f2ad1a08f64f5a46d5b44a5316928d3ae9e
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/15.exercises/solution.md"
@@ -0,0 +1,121 @@
+# 外观数列
+
+
+
给定一个正整数 n ，输出外观数列的第 n 项。
+
+
「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。
+
+
你可以将其视作是由递归公式定义的数字字符串序列：
+
+
+ countAndSay(1) = "1"countAndSay(n) 是对 countAndSay(n-1) 的描述，然后转换成另一个数字字符串。
+
+
前五项如下：
+
+
+ 1. 1
+ 2. 11
+ 3. 21
+ 4. 1211
+ 5. 111221
+ 第一项是数字 1
+ 描述前一项，这个数是 1 即 “ 一 个 1 ”，记作 "11"
+ 描述前一项，这个数是 11 即 “ 二 个 1 ” ，记作 "21"
+ 描述前一项，这个数是 21 即 “ 一 个 2 + 一 个 1 ” ，记作 "1211"
+ 描述前一项，这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ，记作 "111221"
+
+
+
要 描述 一个数字字符串，首先要将字符串分割为 最小 数量的组，每个组都由连续的最多 相同字符
+ 组成。然后对于每个组，先描述字符的数量，然后描述字符，形成一个描述组。要将描述转换为数字字符串，先将每组中的字符数量用数字替换，再将所有描述组连接起来。
+
+
例如，数字字符串 "3322251" 的描述如下图：
+
+
+
+
+
+
示例 1：
+
+
输入：n = 1
+输出："1"
+解释：这是一个基本样例。
+
+
+
示例 2：
+
+
输入：n = 4
+输出："1211"
+解释：
+countAndSay(1) = "1"
+countAndSay(2) = 读 "1" = 一 个 1 = "11"
+countAndSay(3) = 读 "11" = 二 个 1 = "21"
+countAndSay(4) = 读 "21" = 一 个 2 + 一 个 1 = "12" + "11" = "1211"
+
+
+
+
+
提示：
+
+
+
给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。
示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[4,5,1,2,3]
示例 2：
输入：head = [0,1,2], k = 4
输出：[2,0,1]
提示：
- 链表中节点的数目在范围
[0, 500] 内 -100 <= Node.val <= 1000 <= k <= 2 * 109
+
+## template
+
+```java
+public class ListNode {
+ int val;
+ ListNode next;
+ ListNode(int x) {
+ val = x;
+ }
+}
+class Solution {
+ public ListNode rotateRight(ListNode head, int k) {
+ if (head == null || k == 0) {
+ return head;
+ }
+ ListNode cursor = head;
+ ListNode tail = null;
+ int length = 1;
+ while (cursor.next != null) {
+ cursor = cursor.next;
+ length++;
+ }
+ int loop = length - (k % length);
+ tail = cursor;
+ cursor.next = head;
+ cursor = head;
+ for (int i = 0; i < loop; i++) {
+ cursor = cursor.next;
+ tail = tail.next;
+ }
+ tail.next = null;
+ return cursor;
+ }
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/17.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/17.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..32b072506df81b0d5495f4834730fc9139c5a1ed
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/17.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-bd43cf6d844c442b8d5c09969b905166",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/17.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/17.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..69fe65989bf7144f5652af5258e2c13068ca72da
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/17.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "43bd22aebe9a43fb848b0e9ad2ee4777"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/17.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/17.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2b13a7175af5e3e24588a2626e73457ff5923107
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/17.exercises/solution.md"
@@ -0,0 +1,69 @@
+# 组合
+
+给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。
+示例:
+输入: n = 4, k = 2
输出:[[2,4],[3,4],[2,3],[1,2],[1,3],[1,4],]
+
+## template
+
+```java
+
+import java.util.*;
+
+public class Solution77 {
+ List> output = new LinkedList<>();
+ int n;
+ int k;
+
+ public void traceback(int first, LinkedList current) {
+ if (current.size() == k) {
+
+ output.add(new LinkedList(current));
+ System.out.println(output);
+ return;
+ }
+
+ for (int i = first; i <= n; i++) {
+
+ current.add(i);
+ traceback(i + 1, current);
+
+ current.removeLast();
+ }
+ }
+
+ public List> combine(int n, int k) {
+ this.n = n;
+ this.k = k;
+ traceback(1, new LinkedList<>());
+ return output;
+ }
+}
+
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/18.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/18.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..b3aaba8b5ccb32010ffae6402f1a48ea17dc32ce
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/18.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-923abd0becbb4abd97ebfff249082f46",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/18.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/18.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d30500de4597b4607e319d6523c158030b648e24
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/18.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "7671e2aadf874141a65e29516c86dd1b"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/18.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/18.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..480444bd46984a1d1bdb7dbfc797fa7c62bf9241
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/18.exercises/solution.md"
@@ -0,0 +1,66 @@
+# 括号生成
+
+数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
示例 1：
输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]
示例 2：
输入：n = 1
输出：["()"]
提示：
+
+## template
+
+```java
+class Solution {
+ void gen(Stack p, int lc, int rc, List r, int n) {
+ if (lc > n) {
+ return;
+ }
+ if (lc == n && rc == n) {
+ StringBuilder sb = new StringBuilder();
+ for (String l : p) {
+ sb.append(l);
+ }
+ r.add(sb.toString());
+ }
+ p.push("(");
+ lc++;
+ gen(p, lc, rc, r, n);
+ p.pop();
+ lc--;
+ if (lc > rc) {
+ p.push(")");
+ rc++;
+ gen(p, lc, rc, r, n);
+ p.pop();
+ rc--;
+ }
+ }
+ public List generateParenthesis(int n) {
+ List results = new ArrayList();
+ Stack p = new Stack();
+ gen(p, 0, 0, results, n);
+ return results;
+ }
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/19.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/19.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..a18200df569d0cb99f8a98658a9909efb990af29
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/19.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-07bdd9acd4664d37b9308222744b0529",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/19.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/19.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..1b0e1719e529254122ba0dff575cb0f065a2e937
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/19.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "9a2194cdf66748fca6df95005cca6ea4"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/19.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/19.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ede72f62101237f9cb976254a8560b71ae213641
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/19.exercises/solution.md"
@@ -0,0 +1,51 @@
+# 旋转图像
+
+给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。
你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[7,4,1],[8,5,2],[9,6,3]]
示例 2：
输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
输出：[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]
示例 3：
输入：matrix = [[1]]
输出：[[1]]
示例 4：
输入：matrix = [[1,2],[3,4]]
输出：[[3,1],[4,2]]
提示：
matrix.length == nmatrix[i].length == n1 <= n <= 20-1000 <= matrix[i][j] <= 1000
+
+## template
+
+```java
+class Solution {
+
+ public void rotate(int[][] matrix) {
+ int len = matrix.length;
+ int le = len - 1;
+ for (int i = 0; i < len / 2; i++) {
+ for (int j = 0; j < (len + 1) / 2; j++) {
+ int temp = matrix[i][j];
+ matrix[i][j] = matrix[le - j][i];
+ matrix[le - j][i] = matrix[le - i][le - j];
+ matrix[le - i][le - j] = matrix[j][le - i];
+ matrix[j][le - i] = temp;
+ }
+ }
+ }
+}
+
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/20.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/20.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..b70a69cda8185e63fa0e6572047147acc9732380
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/20.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-3987208af25c4ac0af4842650ea1e5e7",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/20.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/20.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..abe972cba19c5c4084e8e953e19ccfcb78c46fae
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/20.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "a050eb4a7ec1488ea0ba1fb19243df41"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/20.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/20.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..4cdb67df84c2a5dbc01ad48062547ddf119786ab
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/20.exercises/solution.md"
@@ -0,0 +1,54 @@
+# 盛最多水的容器
+
+给你 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
说明：你不能倾斜容器。
示例 1：
输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
示例 2：
输入：height = [1,1]
输出：1
示例 3：
输入：height = [4,3,2,1,4]
输出：16
示例 4：
输入：height = [1,2,1]
输出：2
提示：
n = height.length2 <= n <= 3 * 1040 <= height[i] <= 3 * 104
+
+## template
+
+```java
+class Solution {
+ public int maxArea(int[] height) {
+ int N = height.length;
+ int i = 0;
+ int j = N - 1;
+ int max = 0;
+ while (i < j) {
+ int c = (j - i) * Math.min(height[i], height[j]);
+ if (c > max) {
+ max = c;
+ }
+ if (height[i] > height[j]) {
+ j--;
+ } else {
+ i++;
+ }
+ }
+ return max;
+ }
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/21.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/21.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..f5fdf28b20abb7636c33c07fa97d6b4ba5d1035a
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/21.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-ed76415d470d4929adc103d1aba326e9",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/21.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/21.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..6e5e38cff776239d162c19d407bda9cd54042c7d
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/21.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "51ec34e954684cf297c80c42be58e629"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/21.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/21.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..b4930739628686711034a6bf5ea1e6e486cbadf4
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/21.exercises/solution.md"
@@ -0,0 +1,63 @@
+# 复原 IP 地址
+
+给定一个只包含数字的字符串，用以表示一个 IP 地址，返回所有可能从 s 获得的 有效 IP 地址 。你可以按任何顺序返回答案。
有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。
例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。
示例 1：
输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]
示例 2：
输入：s = "0000"
输出：["0.0.0.0"]
示例 3：
输入：s = "1111"
输出：["1.1.1.1"]
示例 4：
输入：s = "010010"
输出：["0.10.0.10","0.100.1.0"]
示例 5：
输入：s = "101023"
输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]
提示：
0 <= s.length <= 3000s 仅由数字组成
+
+## template
+
+```java
+class Solution {
+ private List res = new ArrayList<>();
+
+ public List restoreIpAddresses(String s) {
+ if (s.length() < 4)
+ return res;
+ backtrack(s, 0, new StringBuilder(), 0);
+ return res;
+ }
+
+ private void backtrack(String s, int start, StringBuilder sb, int pointNumOfSb) {
+ if (pointNumOfSb > 4)
+ return;
+ if (start == s.length() && pointNumOfSb == 4) {
+ res.add(sb.toString().substring(1));
+ return;
+ }
+ for (int i = start; i < s.length() && i - start < 3; i++) {
+ String x = s.substring(start, i + 1);
+ if (x.charAt(0) == '0' && x.length() > 1)
+ return;
+ if (Integer.parseInt(x) <= 255) {
+ sb.append("." + x);
+ backtrack(s, i + 1, sb, pointNumOfSb + 1);
+ sb.delete(sb.lastIndexOf("."), sb.length());
+ }
+ }
+ }
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/22.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/22.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..883d0a1cc03dbd6a74278f6e930adc8c704e6cad
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/22.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-2f6152d9101e450dae9edf9c3fac7b05",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/22.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/22.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..79665f23a09b54b18ae09480d2eac8473562313b
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/22.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "264f3f94da4340078e5526e6eb073c43"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/22.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/22.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..472fa532a0be1d83735ec4ee4354d09a7e190acb
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/22.exercises/solution.md"
@@ -0,0 +1,57 @@
+# 格雷编码
+
+格雷编码是一个二进制数字系统，在该系统中，两个连续的数值仅有一个位数的差异。
+给定一个代表编码总位数的非负整数 n，打印其格雷编码序列。即使有多个不同答案，你也只需要返回其中一种。
+格雷编码序列必须以 0 开头。
+
+示例 1:
+输入: 2
输出: [0,1,3,2]
解释:00 - 001 - 111 - 310 - 2对于给定的 n，其格雷编码序列并不唯一。例如，[0,2,3,1] 也是一个有效的格雷编码序列。00 - 010 - 211 - 301 - 1
+示例 2:
+输入: 0
输出: [0]
解释: 我们定义格雷编码序列必须以 0 开头。给定编码总位数为 n 的格雷编码序列，其长度为 2n。当 n = 0 时，长度为 20 = 1。因此，当 n = 0 时，其格雷编码序列为 [0]。
+
+## template
+
+```java
+class Solution {
+ public List grayCode(int n) {
+ List res = new ArrayList<>();
+ res.add(0);
+ int cur;
+ for (int i = 0; i < n; i++) {
+ int change = 1 << i;
+ cur = res.size() - 1;
+ while (cur >= 0) {
+ res.add(res.get(cur) ^ change);
+ cur--;
+ }
+ }
+ return res;
+ }
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/23.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/23.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..818860c594217c92be05d41f273a9f1ec9dfd92a
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/23.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-82deb808258e4d5c9b6c6c6a04f0e0bd",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/23.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/23.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..31b3ab846a553966f0ac337495cd59119f7de065
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/23.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "a9f4b8b841324c9898703af2b3c9bd02"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/23.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/23.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6874e85db140386bddf6f7b5f258ce0152cebc35
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/23.exercises/solution.md"
@@ -0,0 +1,63 @@
+# 下一个排列
+
+实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。
如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
必须 原地 修改，只允许使用额外常数空间。
示例 1：
输入：nums = [1,2,3]
输出：[1,3,2]
示例 2：
输入：nums = [3,2,1]
输出：[1,2,3]
示例 3：
输入：nums = [1,1,5]
输出：[1,5,1]
示例 4：
输入：nums = [1]
输出：[1]
提示：
1 <= nums.length <= 1000 <= nums[i] <= 100
+
+## template
+
+```java
+class Solution {
+ public void nextPermutation(int[] nums) {
+ int i = nums.length - 1;
+ while (i > 0 && nums[i] <= nums[i - 1]) {
+ i--;
+ }
+ if (i > 0) {
+ int j = nums.length - 1;
+ while (j >= 0 && nums[j] <= nums[i - 1]) {
+ j--;
+ }
+ swap(nums, i - 1, j);
+ }
+ reverse(nums, i);
+ }
+ private void reverse(int[] nums, int i) {
+ int j = nums.length - 1;
+ while (i < j) {
+ swap(nums, i, j);
+ i++;
+ j--;
+ }
+ }
+ private void swap(int[] nums, int i, int j) {
+ int temp = nums[i];
+ nums[i] = nums[j];
+ nums[j] = temp;
+ }
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/24.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/24.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..3aaa2219b0bd7d337932cd2b4f089e54e2985c11
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/24.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-74b59e14dd384e97a60aa9a6adfee078",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/24.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/24.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..4db2d8a7662f79cea117301e883edd153ee1da9e
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/24.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "b3d45c955e6a403f9bcf0d10eeabef41"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/24.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/24.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2c21e07af7fac9c23a839297f615f284a6fe7cd9
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/24.exercises/solution.md"
@@ -0,0 +1,61 @@
+# 子集 II
+
+给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。
示例 1：
输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]
示例 2：
输入：nums = [0]
输出：[[],[0]]
提示：
1 <= nums.length <= 10-10 <= nums[i] <= 10
给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格 绝对路径 （以 '/' 开头），请你将其转化为更加简洁的规范路径。
在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （..） 表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。任意多个连续的斜杠（即，'//'）都被视为单个斜杠 '/' 。 对于此问题，任何其他格式的点（例如，'...'）均被视为文件/目录名称。
请注意，返回的 规范路径 必须遵循下述格式：
- 始终以斜杠
'/' 开头。 - 两个目录名之间必须只有一个斜杠
'/' 。 - 最后一个目录名（如果存在）不能 以
'/' 结尾。 - 此外，路径仅包含从根目录到目标文件或目录的路径上的目录（即，不含
'.' 或 '..'）。
返回简化后得到的 规范路径 。
示例 1：
输入：path = "/home/"
输出："/home"
解释：注意，最后一个目录名后面没有斜杠。
示例 2：
输入：path = "/../"
输出："/"
解释：从根目录向上一级是不可行的，因为根目录是你可以到达的最高级。
示例 3：
输入：path = "/home//foo/"
输出："/home/foo"
解释：在规范路径中，多个连续斜杠需要用一个斜杠替换。
示例 4：
输入：path = "/a/./b/../../c/"
输出："/c"
提示：
1 <= path.length <= 3000path 由英文字母，数字，'.'，'/' 或 '_' 组成。path 是一个有效的 Unix 风格绝对路径。
+
+## template
+
+```java
+class Solution {
+ public String simplifyPath(String path) {
+
+ Deque stack = new ArrayDeque<>();
+
+ for (String str : path.split("/")) {
+
+ if ("".equals(str) || ".".equals(str))
+ continue;
+ stack.push(str);
+ }
+
+ StringBuilder sb = new StringBuilder();
+ int count = 0;
+ while (!stack.isEmpty()) {
+ String str = stack.pop();
+
+ if ("..".equals(str))
+ count++;
+ else {
+
+ if (count > 0) {
+ count--;
+ continue;
+ }
+
+ sb.insert(0, str);
+ sb.insert(0, "/");
+ }
+ }
+
+ if (sb.length() == 0)
+ sb.append("/");
+
+ return sb.toString();
+ }
+}
+
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/26.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/26.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d2b44b92fb076145ca4898955e9eec8ac05375af
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/26.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-03b22f16ca8a4355901f6f0a99757f3e",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/26.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/26.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..7e378ada574ce0a50b4f4645132c8f0074b0b263
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/26.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "1ef4881f992d439190409c691eb791ea"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/26.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/26.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..37d5cfd587e3a94935fab301881978bed7f43041
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/26.exercises/solution.md"
@@ -0,0 +1,71 @@
+# 两数相加
+
+给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例 1：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
提示：
- 每个链表中的节点数在范围
[1, 100] 内 0 <= Node.val <= 9- 题目数据保证列表表示的数字不含前导零
+
+## template
+
+```java
+class ListNode {
+ int val;
+ ListNode next;
+ ListNode() {
+ }
+ ListNode(int val) {
+ this.val = val;
+ }
+ ListNode(int val, ListNode next) {
+ this.val = val;
+ this.next = next;
+ }
+}
+class Solution {
+ public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+ ListNode lrr = l1;
+ while (true) {
+ l1.val = l1.val + l2.val;
+ if (l1.next == null && l2.next == null && l1.val < 10) {
+ break;
+ }
+ if (l1.next == null) {
+ l1.next = new ListNode(0);
+ }
+ if (l2.next == null) {
+ l2.next = new ListNode(0);
+ }
+ if (l1.val >= 10) {
+ l1.val = l1.val - 10;
+ l1.next.val += 1;
+ }
+ l1 = l1.next;
+ l2 = l2.next;
+ }
+ return lrr;
+ }
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/27.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/27.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..4e78f246f264f9a7fbef0c8737d7602e985fd1c4
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/27.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-ddb3174b00024240be3f15a2a74733a1",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/27.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/27.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..2afa45c09273da9a7e85b32bdcf0a268aebc1653
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/27.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "55ed56f613e44a8985bcb73f7063d971"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/27.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/27.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..05aca400d073afaa38674f5e6b1730d4b6cbda0a
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/27.exercises/solution.md"
@@ -0,0 +1,64 @@
+# 分隔链表
+
+给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。
你应当 保留 两个分区中每个节点的初始相对位置。
示例 1：
输入：head = [1,4,3,2,5,2], x = 3
输出：[1,2,2,4,3,5]
示例 2：
输入：head = [2,1], x = 2
输出：[1,2]
提示：
- 链表中节点的数目在范围
[0, 200] 内 -100 <= Node.val <= 100-200 <= x <= 200
+
+## template
+
+```java
+public class ListNode {
+ int val;
+ ListNode next;
+ ListNode(int x) {
+ val = x;
+ }
+}
+class Solution {
+ public ListNode partition(ListNode head, int x) {
+ ListNode dummyHead1 = new ListNode(0);
+ ListNode dummyHead2 = new ListNode(0);
+ ListNode node1 = dummyHead1;
+ ListNode node2 = dummyHead2;
+ while (head != null) {
+ if (head.val < x) {
+ node1.next = head;
+ head = head.next;
+ node1 = node1.next;
+ node1.next = null;
+ } else {
+ node2.next = head;
+ head = head.next;
+ node2 = node2.next;
+ node2.next = null;
+ }
+ }
+ node1.next = dummyHead2.next;
+ return dummyHead1.next;
+ }
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/28.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/28.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..45ee6a1b633b7de7a4233a9c2ceb4c2a2c2a73ed
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/28.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-a42019ddbfad4f19b29539cbdb1d558d",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/28.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/28.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..8c709dcb5ce30e5cc24d86b5a2e243373b81c557
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/28.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "3e16432078fd4d6d88a1f056943e56ea"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/28.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/28.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..a9eeebf0877923520bd13b5bd774539769783293
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/28.exercises/solution.md"
@@ -0,0 +1,145 @@
+# 整数转罗马数字
+
+
+
罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。
+
+
+
字符 数值
+I 1
+V 5
+X 10
+L 50
+C 100
+D 500
+M 1000
+
+
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12
+ 写做 XII ，即为 X + II 。 27
+ 写做 XXVII,
+ 即为 XX + V + II 。
+
+
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5
+ 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
+
+
+ I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。X 可以放在 L (50) 和 C (100) 的左边，来表示 40
+ 和 90。 C 可以放在 D (500) 和 M (1000) 的左边，来表示 400
+ 和 900。
+
+
给你一个整数，将其转为罗马数字。
+
+
+
+
示例 1:
+
+
输入: num = 3
+
输出: "III"
+
+
示例 2:
+
+
输入: num = 4
+
输出: "IV"
+
+
示例 3:
+
+
输入: num = 9
+
输出: "IX"
+
+
示例 4:
+
+
输入: num = 58
+
输出: "LVIII"
+
解释: L = 50, V = 5, III = 3.
+
+
+
示例 5:
+
+
输入: num = 1994
+
输出: "MCMXCIV"
+
解释: M = 1000, CM = 900, XC = 90, IV = 4.
+
+
+
+
提示：
+
+
+
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
示例 1：
输入：nums = [1,1,2]
输出：[[1,1,2], [1,2,1], [2,1,1]]
示例 2：
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
提示：
1 <= nums.length <= 8-10 <= nums[i] <= 10
+
+## template
+
+```java
+class Solution {
+ List> ans = new ArrayList<>();
+
+ public List> permuteUnique(int[] nums) {
+ dfs(nums, 0);
+ return ans;
+ }
+
+ private void dfs(int[] nums, int cur) {
+ if (cur == nums.length) {
+ List line = new ArrayList<>();
+ for (int i : nums) {
+ line.add(i);
+ }
+ ans.add(line);
+ } else {
+ for (int i = cur; i < nums.length; i++) {
+ if (canSwap(nums, cur, i)) {
+ swap(nums, cur, i);
+ dfs(nums, cur + 1);
+ swap(nums, cur, i);
+ }
+ }
+ }
+ }
+
+ private boolean canSwap(int nums[], int begin, int end) {
+ for (int i = begin; i < end; i++) {
+ if (nums[i] == nums[end]) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ private void swap(int nums[], int i, int j) {
+ int temp = nums[i];
+ nums[i] = nums[j];
+ nums[j] = temp;
+ }
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/30.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/30.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..65f44b1ebec9178208293a4400e51a25c36184fe
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/30.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-1ce31ee774cc479ba539ca08f957da5a",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/30.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/30.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..3d1425dab7a57f36a9002a2f7ef83c996bebb528
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/30.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "1f04d4cdb5d148f6a74282b702683f53"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/30.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/30.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..acb00fa8dc564e19aaa6e71e024b0898a086f686
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/30.exercises/solution.md"
@@ -0,0 +1,53 @@
+# 无重复字符的最长子串
+
+给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
+请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
示例 4:
输入: s = ""
输出: 0
提示：
0 <= s.length <= 5 * 104s 由英文字母、数字、符号和空格组成
+
+## template
+
+```java
+class Solution {
+ public int lengthOfLongestSubstring(String s) {
+ int i = 0;
+ int j = 0;
+ int m = 0;
+ Map hset = new HashMap<>();
+ for (; j < s.length(); j++) {
+ int code = s.codePointAt(j);
+ Integer o = hset.get(code);
+ if (o != null && o > i) {
+ i = o;
+ }
+ m = m > j - i + 1 ? m : j - i + 1;
+ hset.put(code, j + 1);
+ }
+ return m;
+ }
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/31.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/31.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..18158ae66b0a596e60fc42fafe380d38703a472b
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/31.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-0fec02446f8046d9bb5588f6dfad8f99",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/31.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/31.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..4cf09960dd94081a516a310c7826d59e857b6482
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/31.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "760bca1d15cf44fa93a4510c6648f4f0"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/31.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/31.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d7e8f6214b12983bca7de0b6e7122fd1a68d92ca
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/31.exercises/solution.md"
@@ -0,0 +1,80 @@
+# 解码方法
+
+一条包含字母 A-Z 的消息通过以下映射进行了 编码 ：
+'A' -> 1'B' -> 2...'Z' -> 26
+要 解码 已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，"11106" 可以映射为：
+
+ "AAJF" ，将消息分组为 (1 1 10 6)"KJF" ，将消息分组为 (11 10 6)
+注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和
+ "06" 在映射中并不等价。
+
+给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。
+题目数据保证答案肯定是一个 32 位 的整数。
+
+示例 1：
+输入：s = "12"
输出：2
解释：它可以解码为 "AB"（1 2）或者 "L"（12）。
+示例 2：
+输入：s = "226"
输出：3
解释：它可以解码为 "BZ" (2 26), "VF" (22 6), 或者 "BBF" (2 2 6) 。
+示例 3：
+输入：s = "0"
输出：0
解释：没有字符映射到以 0 开头的数字。含有 0 的有效映射是 'J' -> "10" 和 'T'-> "20" 。由于没有字符，因此没有有效的方法对此进行解码，因为所有数字都需要映射。
+示例 4：
+输入：s = "06"
输出：0
解释："06" 不能映射到 "F" ，因为字符串含有前导 0（"6" 和 "06" 在映射中并不等价）。
+
+提示：
+
+ 1 <= s.length <= 100s 只包含数字，并且可能包含前导零。
+
+## template
+
+```java
+class Solution {
+ public int numDecodings(String s) {
+ if (s == null || s.length() == 0) {
+ return 0;
+ }
+ int n = s.length();
+ int[] dp = new int[n + 1];
+ dp[0] = 1;
+ dp[1] = (s.charAt(0) == '0' ? 0 : 1);
+ for (int i = 1; i < n; i++) {
+ char c = s.charAt(i);
+ char pre = s.charAt(i - 1);
+ dp[i + 1] = c == '0' ? 0 : dp[i];
+ if (pre == '1' || (pre == '2' && c <= '6')) {
+ dp[i + 1] += dp[i - 1];
+ }
+ }
+ return dp[n];
+ }
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/32.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/32.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..1ecc6caa4c6068930c6ecd7f4aea293c4663d391
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/32.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-dbf1215ef2ad4f189c646a82bb3015df",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/32.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/32.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..f9ff5b6ee6fb5a7001b3d0123362e5b846322fe7
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/32.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "8478d047fa1b4802badbcbaf24d9d493"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/32.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/32.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f40de1d011bacb06447b805b45c3bfc984de01be
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/32.exercises/solution.md"
@@ -0,0 +1,56 @@
+# 两数相除
+
+给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。
返回被除数 dividend 除以除数 divisor 得到的商。
整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2
示例 1:
输入: dividend = 10, divisor = 3
输出: 3
解释: 10/3 = truncate(3.33333..) = truncate(3) = 3
示例 2:
输入: dividend = 7, divisor = -3
输出: -2
解释: 7/-3 = truncate(-2.33333..) = -2
提示：
- 被除数和除数均为 32 位有符号整数。
- 除数不为 0。
- 假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−231, 231 − 1]。本题中，如果除法结果溢出，则返回 231 − 1。
+
+## template
+
+```java
+class Solution {
+ public int divide(int dividend, int divisor) {
+ if (dividend == 0) {
+ return 0;
+ }
+ if (dividend == Integer.MIN_VALUE && divisor == -1) {
+ return Integer.MAX_VALUE;
+ }
+ boolean negative;
+ negative = (dividend ^ divisor) < 0;
+ long t = Math.abs((long) dividend);
+ long d = Math.abs((long) divisor);
+ int result = 0;
+ for (int i = 31; i >= 0; i--) {
+ if ((t >> i) >= d) {
+ result += 1 << i;
+ t -= d << i;
+ }
+ }
+ return negative ? -result : result;
+ }
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/33.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/33.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..f57b06faeeeebf637976305b63702eaaeb67933c
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/33.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-7787f94d6cd24b4687aa04bad490dcdb",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/33.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/33.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..9921900857021f24c005f8c6370e4fcea93c6e16
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/33.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "b0273841fc20454c919506f8347f10aa"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/33.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/33.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2d33088319bad2c4c38428b47b002b56697e3987
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/33.exercises/solution.md"
@@ -0,0 +1,77 @@
+# 螺旋矩阵
+
+给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：
输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]
提示：
m == matrix.lengthn == matrix[i].length1 <= m, n <= 10-100 <= matrix[i][j] <= 100
+
+## template
+
+```java
+class Solution {
+ public List spiralOrder(int[][] matrix) {
+ List res = new ArrayList();
+ if (matrix.length == 0 || (matrix.length == 1 && matrix[0].length == 0))
+ return res;
+ int left = 0;
+ int right = matrix[0].length - 1;
+ int top = 0;
+ int bottom = matrix.length - 1;
+ int num = (right + 1) * (bottom + 1);
+ while (num > 0) {
+ for (int j = left; j <= right; j++) {
+ res.add(matrix[top][j]);
+ num--;
+ }
+ if (num <= 0)
+ break;
+ top++;
+ for (int i = top; i <= bottom; i++) {
+ res.add(matrix[i][right]);
+ num--;
+ }
+ if (num <= 0)
+ break;
+ right--;
+ for (int j = right; j >= left; j--) {
+ res.add(matrix[bottom][j]);
+ num--;
+ }
+ if (num <= 0)
+ break;
+ bottom--;
+ for (int i = bottom; i >= top; i--) {
+ res.add(matrix[i][left]);
+ num--;
+ }
+ if (num <= 0)
+ break;
+ left++;
+ }
+ return res;
+ }
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/34.exercises/config.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/34.exercises/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..406cfb54c55fd5f91a8fb92d3084d6eb2e196a70
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/34.exercises/config.json"
@@ -0,0 +1,8 @@
+{
+ "node_id": "dailycode-64da55094c5b46ba92e7deac23aeb465",
+ "keywords": [],
+ "children": [],
+ "export": [
+ "solution.json"
+ ]
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/34.exercises/solution.json" "b/data/2.dailycode\344\270\255\351\230\266/2.java/34.exercises/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..59cfeb12476806649f183d79c1461a8b38a33efb
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/34.exercises/solution.json"
@@ -0,0 +1,6 @@
+{
+ "type": "code_options",
+ "author": "csdn.net",
+ "source": "solution.md",
+ "exercise_id": "ce2277c91ff64313afb5212277095237"
+}
\ No newline at end of file
diff --git "a/data/2.dailycode\344\270\255\351\230\266/2.java/34.exercises/solution.md" "b/data/2.dailycode\344\270\255\351\230\266/2.java/34.exercises/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..eed31e5600dab9de70678a959b93d8f5bb2afcfb
--- /dev/null
+++ "b/data/2.dailycode\344\270\255\351\230\266/2.java/34.exercises/solution.md"
@@ -0,0 +1,102 @@
+# 全排列
+
+给定一个