update dailycode pipline

data/1.dailycode初阶/1.cpp/78.exercises/config.json

+{
+  "node_id": "dailycode-0dc5a625a3914f54be8981be75254bb9",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/78.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "4f0286361e18400f8cd1dd9b365c0b2d"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/78.exercises/solution.md

+# 合并两个有序链表
+
+<p>将两个升序链表合并为一个新的 <strong>升序</strong> 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 </p><p> </p><p><strong>示例 1：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0021.Merge%20Two%20Sorted%20Lists/images/merge_ex1.jpg" style="width: 662px; height: 302px;" /><pre><strong>输入：</strong>l1 = [1,2,4], l2 = [1,3,4]<strong><br />输出：</strong>[1,1,2,3,4,4]</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>l1 = [], l2 = []<strong><br />输出：</strong>[]</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>l1 = [], l2 = [0]<strong><br />输出：</strong>[0]</pre><p> </p><p><strong>提示：</strong></p><ul>	<li>两个链表的节点数目范围是 <code>[0, 50]</code></li>	<li><code>-100 <= Node.val <= 100</code></li>	<li><code>l1</code> 和 <code>l2</code> 均按 <strong>非递减顺序</strong> 排列</li></ul>
+
+## template
+
+```cpp
+struct ListNode
+{
+	int val;
+	ListNode *next;
+	ListNode(int x) : val(x), next(NULL) {}
+};
+class Solution
+{
+public:
+	ListNode *mergeTwoLists(ListNode *l1, ListNode *l2)
+	{
+		ListNode h(0, nullptr);
+		ListNode *p = &h;
+		while (l1 && l2)
+		{
+			ListNode **t;
+			if (l1->val < l2->val)
+				t = &l1;
+			else
+				t = &l2;
+			p->next = *t;
+			p = *t;
+			*t = (*t)->next;
+		}
+		if (l1)
+			p->next = l1;
+		else
+			p->next = l2;
+		return h.next;
+	}
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/79.exercises/config.json

+{
+  "node_id": "dailycode-95b5f3ea417a4993b1d2de9d0e03333b",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/79.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "https://github.com/begeekmyfriend/leetcode",
+  "source": "solution.md",
+  "exercise_id": "d8072053a01149a9aa42f6b7b0079d38"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/79.exercises/solution.md

+# 最后一个单词的长度
+
+<p>给你一个字符串 <code>s</code>，由若干单词组成，单词之间用空格隔开。返回字符串中最后一个单词的长度。如果不存在最后一个单词，请返回 0 。</p><p><strong>单词</strong> 是指仅由字母组成、不包含任何空格字符的最大子字符串。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>s = "Hello World"<strong><br />输出：</strong>5</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>s = " "<strong><br />输出：</strong>0</pre><p> </p><p><strong>提示：</strong></p><ul>	<li><code>1 <= s.length <= 10<sup>4</sup></code></li>	<li><code>s</code> 仅有英文字母和空格 <code>' '</code> 组成</li></ul>
+
+## template
+
+```cpp
+#include <stdio.h>
+#include <stdlib.h>
+int lengthOfLastWord(char *s)
+{
+	int len = 0;
+	while (*s != '\0')
+	{
+		if (s[-1] == ' ' && s[0] != ' ')
+		{
+			len = 1;
+		}
+		else if (*s != ' ')
+		{
+			len++;
+		}
+		s++;
+	}
+	return len;
+}
+int main(int argc, char **argv)
+{
+	if (argc != 2)
+	{
+		fprintf(stderr, "Usage: ./test word\n");
+		exit(-1);
+	}
+	printf("%d\n", lengthOfLastWord(argv[1]));
+	return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/80.exercises/config.json

+{
+  "node_id": "dailycode-bdf88ba27c68490495382360648a7224",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/80.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "https://github.com/begeekmyfriend/leetcode",
+  "source": "solution.md",
+  "exercise_id": "39f3737953434bd5a1f2be8c5a98988f"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/80.exercises/solution.md

+# 删除排序链表中的重复元素
+
+<p>存在一个按升序排列的链表，给你这个链表的头节点 <code>head</code> ，请你删除所有重复的元素，使每个元素 <strong>只出现一次</strong> 。</p><p>返回同样按升序排列的结果链表。</p><p> </p><p><strong>示例 1：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0083.Remove%20Duplicates%20from%20Sorted%20List/images/list1.jpg" style="width: 302px; height: 242px;" /><pre><strong>输入：</strong>head = [1,1,2]<strong><br />输出：</strong>[1,2]</pre><p><strong>示例 2：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0083.Remove%20Duplicates%20from%20Sorted%20List/images/list2.jpg" style="width: 542px; height: 222px;" /><pre><strong>输入：</strong>head = [1,1,2,3,3]<strong><br />输出：</strong>[1,2,3]</pre><p> </p><p><strong>提示：</strong></p><ul>	<li>链表中节点数目在范围 <code>[0, 300]</code> 内</li>	<li><code>-100 <= Node.val <= 100</code></li>	<li>题目数据保证链表已经按升序排列</li></ul>
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+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 *deleteDuplicates(ListNode *head)
+	{
+		if (head == nullptr)
+		{
+			return nullptr;
+		}
+		ListNode *prev = head;
+		ListNode *p = prev->next;
+		while (p != nullptr)
+		{
+			if (p->val != prev->val)
+			{
+				prev->next = p;
+				prev = p;
+			}
+			p = p->next;
+		}
+		prev->next = p;
+		return head;
+	}
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/81.exercises/config.json

+{
+  "node_id": "dailycode-cb2b55c067e043aebdcb06de78ba59b2",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/81.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "215a84a365404b8e9661f0441bd654ec"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/81.exercises/solution.md

+# 整数反转
+
+<p>给你一个 32 位的有符号整数 <code>x</code> ，返回将 <code>x</code> 中的数字部分反转后的结果。</p><p>如果反转后整数超过 32 位的有符号整数的范围 <code>[−2<sup>31</sup>,  2<sup>31 </sup>− 1]</code> ，就返回 0。</p><strong>假设环境不允许存储 64 位整数（有符号或无符号）。</strong><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>x = 123<strong><br />输出：</strong>321</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>x = -123<strong><br />输出：</strong>-321</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>x = 120<strong><br />输出：</strong>21</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>x = 0<strong><br />输出：</strong>0</pre><p> </p><p><strong>提示：</strong></p><ul>	<li><code>-2<sup>31</sup> <= x <= 2<sup>31</sup> - 1</code></li></ul>
+
+## template
+
+```cpp
+int reverse(int x)
+{
+	long long int r = 0;
+	while (x)
+	{
+		r = r * 10 + (x % 10);
+		x /= 10;
+	}
+	if (r > 2147483647)
+		return 0;
+	if (r < -2147483648)
+		return 0;
+	return (int)r;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/82.exercises/config.json

+{
+  "node_id": "dailycode-ef357d9dbd1c474f8e14c9783b786c60",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/82.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "https://github.com/begeekmyfriend/leetcode",
+  "source": "solution.md",
+  "exercise_id": "90a1217143b94f56b82cb3186ad9c7ff"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/82.exercises/solution.md

+# 相同的树
+
+<p>给你两棵二叉树的根节点 <code>p</code> 和 <code>q</code> ，编写一个函数来检验这两棵树是否相同。</p><p>如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。</p><p> </p><p><strong>示例 1：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0100-0199/0100.Same%20Tree/images/ex1.jpg" style="width: 622px; height: 182px;" /><pre><strong>输入：</strong>p = [1,2,3], q = [1,2,3]<strong><br />输出：</strong>true</pre><p><strong>示例 2：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0100-0199/0100.Same%20Tree/images/ex2.jpg" style="width: 382px; height: 182px;" /><pre><strong>输入：</strong>p = [1,2], q = [1,null,2]<strong><br />输出：</strong>false</pre><p><strong>示例 3：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0100-0199/0100.Same%20Tree/images/ex3.jpg" style="width: 622px; height: 182px;" /><pre><strong>输入：</strong>p = [1,2,1], q = [1,1,2]<strong><br />输出：</strong>false</pre><p> </p><p><strong>提示：</strong></p><ul>	<li>两棵树上的节点数目都在范围 <code>[0, 100]</code> 内</li>	<li><code>-10<sup>4</sup> <= Node.val <= 10<sup>4</sup></code></li></ul>
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+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:
+	bool isSameTree(TreeNode *p, TreeNode *q)
+	{
+		if (p == nullptr && q == nullptr)
+		{
+			return true;
+		}
+		if (p == nullptr || q == nullptr)
+		{
+			return false;
+		}
+		if (p->val != q->val)
+		{
+			return false;
+		}
+		return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
+	}
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/83.exercises/config.json

+{
+  "node_id": "dailycode-ed97f5d02dcb4060a214abf12ffeb9c9",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/83.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "5feffaf9331a467ba63a2b3f664a30e6"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/83.exercises/solution.md

+# 两数之和
+
+<p>给定一个整数数组 <code>nums</code> 和一个整数目标值 <code>target</code>，请你在该数组中找出 <strong>和为目标值</strong> 的那 <strong>两个</strong> 整数，并返回它们的数组下标。</p><p>你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。</p><p>你可以按任意顺序返回答案。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>nums = [2,7,11,15], target = 9<strong><br />输出：</strong>[0,1]<strong><br />解释：</strong>因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>nums = [3,2,4], target = 6<strong><br />输出：</strong>[1,2]</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>nums = [3,3], target = 6<strong><br />输出：</strong>[0,1]</pre><p> </p><p><strong>提示：</strong></p><ul>	<li><code>2 <= nums.length <= 10<sup>3</sup></code></li>	<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>	<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>	<li><strong>只会存在一个有效答案</strong></li></ul>
+
+## template
+
+```cpp
+#include <unordered_map>
+class Solution
+{
+public:
+	vector<int> twoSum(vector<int> &nums, int target)
+	{
+		std::unordered_map<int, int> hset;
+		vector<int> r;
+		for (int i = 0; i < nums.size(); ++i)
+		{
+			int c = target - nums[i];
+			auto iter = hset.find(c);
+			if (iter != hset.end() && iter->second != i)
+			{
+				r.push_back(i);
+				r.push_back(iter->second);
+				return r;
+			}
+			hset.insert(std::make_pair(nums[i], i));
+		}
+		return r;
+	}
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/84.exercises/config.json

+{
+  "node_id": "dailycode-0e2b647ac84544f9920a79176a283316",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/84.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "https://github.com/begeekmyfriend/leetcode",
+  "source": "solution.md",
+  "exercise_id": "b0ddeec257e645f7a5abbe2406ff3688"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/84.exercises/solution.md

+# 移除元素
+
+<div class="notranslate">
+    <p>给你一个数组 <code>nums</code><em>&nbsp;</em>和一个值 <code>val</code>，你需要 <strong><a
+                href="https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95">原地</a></strong>
+        移除所有数值等于&nbsp;<code>val</code><em>&nbsp;</em>的元素，并返回移除后数组的新长度。</p>
+
+    <p>不要使用额外的数组空间，你必须仅使用 <code>O(1)</code> 额外空间并 <strong><a
+                href="https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95">原地 </a>修改输入数组</strong>。</p>
+
+    <p>元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。</p>
+
+    <p>&nbsp;</p>
+
+    <p><strong>说明:</strong></p>
+
+    <p>为什么返回数值是整数，但输出的答案是数组呢?</p>
+
+    <p>请注意，输入数组是以<strong>「引用」</strong>方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。</p>
+
+    <p>你可以想象内部操作如下:</p>
+
+    <pre>// <strong>nums</strong> 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
+int len = removeElement(nums, val);
+
+// 在函数里修改输入数组对于调用者是可见的。
+// 根据你的函数返回的长度, 它会打印出数组中<strong> 该长度范围内</strong> 的所有元素。
+for (int i = 0; i &lt; len; i++) {
+&nbsp; &nbsp; print(nums[i]);
+}
+</pre>
+
+    <p>&nbsp;</p>
+
+    <p><strong>示例 1：</strong></p>
+
+    <pre><strong>输入：</strong>nums = [3,2,2,3], val = 3
+<strong><br />输出：</strong>2, nums = [2,2]
+<strong><br />解释：</strong>函数应该返回新的长度 <strong>2</strong>, 并且 nums<em> </em>中的前两个元素均为 <strong>2</strong>。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。
+    </pre>
+
+    <p><strong>示例 2：</strong></p>
+
+    <pre><strong>输入：</strong>nums = [0,1,2,2,3,0,4,2], val = 2
+<strong><br />输出：</strong>5, nums = [0,1,4,0,3]
+<strong><br />解释：</strong>函数应该返回新的长度 <strong>5</strong>, 并且 nums 中的前五个元素为 <strong>0</strong>, <strong>1</strong>, <strong>3</strong>, <strong>0</strong>, <strong>4</strong>。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
+    </pre>
+
+    <p>&nbsp;</p>
+
+    <p><strong>提示：</strong></p>
+
+    <ul>
+        <li><code>0 &lt;= nums.length &lt;= 100</code></li>
+        <li><code>0 &lt;= nums[i] &lt;= 50</code></li>
+        <li><code>0 &lt;= val &lt;= 100</code></li>
+    </ul>
+</div>
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+class Solution
+{
+public:
+	int removeElement(vector<int> &nums, int val)
+	{
+		int count = 0;
+		for (int i = 0; i < nums.size(); i++)
+		{
+			if (nums[i] != val)
+			{
+				nums[count++] = nums[i];
+			}
+		}
+		return count;
+	}
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/85.exercises/config.json

+{
+  "node_id": "dailycode-7ca3b3eb885c434aaf79d149fbb01125",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/85.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "https://github.com/begeekmyfriend/leetcode",
+  "source": "solution.md",
+  "exercise_id": "3be9aec2ef9941e3b0666d3241dbbf8c"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/85.exercises/solution.md

+# 二进制求和
+
+<p>给你两个二进制字符串，返回它们的和（用二进制表示）。</p><p>输入为 <strong>非空 </strong>字符串且只包含数字&nbsp;<code>1</code>&nbsp;和&nbsp;<code>0</code>。</p><p>&nbsp;</p><p><strong>示例&nbsp;1:</strong></p><pre><strong>输入:</strong> a = &quot;11&quot;, b = &quot;1&quot;<strong><br />输出:</strong> &quot;100&quot;</pre><p><strong>示例&nbsp;2:</strong></p><pre><strong>输入:</strong> a = &quot;1010&quot;, b = &quot;1011&quot;<strong><br />输出:</strong> &quot;10101&quot;</pre><p>&nbsp;</p><p><strong>提示：</strong></p><ul>	<li>每个字符串仅由字符 <code>&#39;0&#39;</code> 或 <code>&#39;1&#39;</code> 组成。</li>	<li><code>1 &lt;= a.length, b.length &lt;= 10^4</code></li>	<li>字符串如果不是 <code>&quot;0&quot;</code> ，就都不含前导零。</li></ul>
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+class Solution
+{
+public:
+	string addBinary(string a, string b)
+	{
+		string res;
+		int carry = 0;
+		int i = a.length() - 1;
+		int j = b.length() - 1;
+		for (; i >= 0 && j >= 0; i--, j--)
+		{
+			if (a[i] == '1' && b[j] == '1')
+			{
+				if (carry > 0)
+				{
+					res.push_back('1');
+				}
+				else
+				{
+					res.push_back('0');
+				}
+				carry = 1;
+			}
+			else if (a[i] == '0' && b[j] == '0')
+			{
+				if (carry > 0)
+				{
+					res.push_back('1');
+				}
+				else
+				{
+					res.push_back('0');
+				}
+				carry = 0;
+			}
+			else
+			{
+				if (carry > 0)
+				{
+					res.push_back('0');
+					carry = 1;
+				}
+				else
+				{
+					res.push_back('1');
+					carry = 0;
+				}
+			}
+		}
+		while (i >= 0)
+		{
+			if (a[i--] == '1')
+			{
+				if (carry > 0)
+				{
+					res.push_back('0');
+					carry = 1;
+				}
+				else
+				{
+					res.push_back('1');
+					carry = 0;
+				}
+			}
+			else
+			{
+				res.push_back(carry + '0');
+				carry = 0;
+			}
+		}
+		while (j >= 0)
+		{
+			if (b[j--] == '1')
+			{
+				if (carry > 0)
+				{
+					res.push_back('0');
+					carry = 1;
+				}
+				else
+				{
+					res.push_back('1');
+					carry = 0;
+				}
+			}
+			else
+			{
+				res.push_back(carry + '0');
+				carry = 0;
+			}
+		}
+		if (carry > 0)
+		{
+			res.push_back('1');
+		}
+		reverse(res.begin(), res.end());
+		return res;
+	}
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/86.exercises/config.json

+{
+  "node_id": "dailycode-16292aaccf4c4364afac2d5a7422d944",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/86.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "https://github.com/begeekmyfriend/leetcode",
+  "source": "solution.md",
+  "exercise_id": "ff05c8260e354e8fb308ace3d4a979bc"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/86.exercises/solution.md

+# 二叉树的中序遍历
+
+<p>给定一个二叉树的根节点 <code>root</code> ，返回它的 <strong>中序</strong> 遍历。</p><p> </p><p><strong>示例 1：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0094.Binary%20Tree%20Inorder%20Traversal/images/inorder_1.jpg" style="width: 202px; height: 324px;" /><pre><strong>输入：</strong>root = [1,null,2,3]<strong><br />输出：</strong>[1,3,2]</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>root = []<strong><br />输出：</strong>[]</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>root = [1]<strong><br />输出：</strong>[1]</pre><p><strong>示例 4：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0094.Binary%20Tree%20Inorder%20Traversal/images/inorder_5.jpg" style="width: 202px; height: 202px;" /><pre><strong>输入：</strong>root = [1,2]<strong><br />输出：</strong>[2,1]</pre><p><strong>示例 5：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0094.Binary%20Tree%20Inorder%20Traversal/images/inorder_4.jpg" style="width: 202px; height: 202px;" /><pre><strong>输入：</strong>root = [1,null,2]<strong><br />输出：</strong>[1,2]</pre><p> </p><p><strong>提示：</strong></p><ul>	<li>树中节点数目在范围 <code>[0, 100]</code> 内</li>	<li><code>-100 <= Node.val <= 100</code></li></ul><p> </p><p><strong>进阶:</strong> 递归算法很简单，你可以通过迭代算法完成吗？</p>
+
+## template
+
+```cpp
+#include <stdio.h>
+#include <stdlib.h>
+struct TreeNode
+{
+	int val;
+	struct TreeNode *left;
+	struct TreeNode *right;
+};
+static void traverse(struct TreeNode *node, int *result, int *count)
+{
+	if (node == NULL)
+	{
+		return;
+	}
+	traverse(node->left, result, count);
+	result[*count] = node->val;
+	(*count)++;
+	traverse(node->right, result, count);
+}
+static int *inorderTraversal(struct TreeNode *root, int *returnSize)
+{
+	if (root == NULL)
+	{
+		*returnSize = 0;
+		return NULL;
+	}
+	int count = 0;
+	int *result = malloc(5000 * sizeof(int));
+	traverse(root, result, &count);
+	*returnSize = count;
+	return result;
+}
+int main()
+{
+	int count = 0;
+	inorderTraversal(NULL, &count);
+	return 0;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/87.exercises/config.json

+{
+  "node_id": "dailycode-9b161201e7ea49c0ae6fc36917dc39f4",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/87.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "https://github.com/begeekmyfriend/leetcode",
+  "source": "solution.md",
+  "exercise_id": "06e011e2d19146f197fc3e063b1675b9"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/87.exercises/solution.md

+# 爬楼梯
+
+<p>假设你正在爬楼梯。需要 <em>n</em>&nbsp;阶你才能到达楼顶。</p><p>每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？</p><p><strong>注意：</strong>给定 <em>n</em> 是一个正整数。</p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong> 2<strong><br />输出：</strong> 2<strong><br />解释：</strong> 有两种方法可以爬到楼顶。1.  1 阶 + 1 阶2.  2 阶</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong> 3<strong><br />输出：</strong> 3<strong><br />解释：</strong> 有三种方法可以爬到楼顶。1.  1 阶 + 1 阶 + 1 阶2.  1 阶 + 2 阶3.  2 阶 + 1 阶</pre>
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+class Solution
+{
+public:
+	int climbStairs(int n)
+	{
+		int a = 1;
+		int b = 2;
+		int c = 0;
+		for (int i = 3; i <= n; i++)
+		{
+			c = a + b;
+			a = b;
+			b = c;
+		}
+		return n == 1 ? a : (n == 2 ? b : c);
+	}
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/88.exercises/config.json

+{
+  "node_id": "dailycode-ac8e483d856f4a0289ed197afb19dbfa",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/88.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "62541471885b4c6da4789a2e6379ab55"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/88.exercises/solution.md

+# 罗马数字转整数
+
+<div class="notranslate">
+    <p>罗马数字包含以下七种字符：&nbsp;<code>I</code>，&nbsp;<code>V</code>，&nbsp;<code>X</code>，&nbsp;<code>L</code>，<code>C</code>，<code>D</code>&nbsp;和&nbsp;<code>M</code>。
+    </p>
+
+    <pre><strong>字符</strong>          <strong>数值</strong>
+I             1
+V             5
+X             10
+L             50
+C             100
+D             500
+M             1000</pre>
+
+    <p>例如， 罗马数字 2 写做&nbsp;<code>II</code>&nbsp;，即为两个并列的 1。12
+        写做&nbsp;<code>XII</code>&nbsp;，即为&nbsp;<code>X</code>&nbsp;+&nbsp;<code>II</code>&nbsp;。 27
+        写做&nbsp;&nbsp;<code>XXVII</code>,
+        即为&nbsp;<code>XX</code>&nbsp;+&nbsp;<code>V</code>&nbsp;+&nbsp;<code>II</code>&nbsp;。</p>
+
+    <p>通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做&nbsp;<code>IIII</code>，而是&nbsp;<code>IV</code>。数字 1 在数字 5 的左边，所表示的数等于大数 5
+        减小数 1 得到的数值 4 。同样地，数字 9 表示为&nbsp;<code>IX</code>。这个特殊的规则只适用于以下六种情况：</p>
+
+    <ul>
+        <li><code>I</code>&nbsp;可以放在&nbsp;<code>V</code>&nbsp;(5) 和&nbsp;<code>X</code>&nbsp;(10) 的左边，来表示 4 和 9。</li>
+        <li><code>X</code>&nbsp;可以放在&nbsp;<code>L</code>&nbsp;(50) 和&nbsp;<code>C</code>&nbsp;(100) 的左边，来表示 40
+            和&nbsp;90。&nbsp;</li>
+        <li><code>C</code>&nbsp;可以放在&nbsp;<code>D</code>&nbsp;(500) 和&nbsp;<code>M</code>&nbsp;(1000) 的左边，来表示&nbsp;400
+            和&nbsp;900。</li>
+    </ul>
+
+    <p>给你一个整数，将其转为罗马数字。</p>
+
+    <p>&nbsp;</p>
+
+    <p><strong>示例&nbsp;1:</strong></p>
+
+    <pre><strong>输入:</strong>&nbsp;num = 3
+<strong><br />输出:</strong> "III"</pre>
+
+    <p><strong>示例&nbsp;2:</strong></p>
+
+    <pre><strong>输入:</strong>&nbsp;num = 4
+<strong><br />输出:</strong> "IV"</pre>
+
+    <p><strong>示例&nbsp;3:</strong></p>
+
+    <pre><strong>输入:</strong>&nbsp;num = 9
+<strong><br />输出:</strong> "IX"</pre>
+
+    <p><strong>示例&nbsp;4:</strong></p>
+
+    <pre><strong>输入:</strong>&nbsp;num = 58
+<strong><br />输出:</strong> "LVIII"
+<strong><br />解释:</strong> L = 50, V = 5, III = 3.
+    </pre>
+
+    <p><strong>示例&nbsp;5:</strong></p>
+
+    <pre><strong>输入:</strong>&nbsp;num = 1994
+<strong><br />输出:</strong> "MCMXCIV"
+<strong><br />解释:</strong> M = 1000, CM = 900, XC = 90, IV = 4.</pre>
+
+    <p>&nbsp;</p>
+
+    <p><strong>提示：</strong></p>
+
+    <ul>
+        <li><code>1 &lt;= num &lt;= 3999</code></li>
+    </ul>
+</div>
+
+## template
+
+```cpp
+struct rmap
+{
+	char *r;
+	int v;
+	int l;
+} units[] = {
+	{"M", 1000, 1},
+	{"CM", 900, 2},
+	{"D", 500, 1},
+	{"CD", 400, 2},
+	{"C", 100, 1},
+	{"XC", 90, 2},
+	{"L", 50, 1},
+	{"XL", 40, 2},
+	{"X", 10, 1},
+	{"IX", 9, 2},
+	{"V", 5, 1},
+	{"IV", 4, 2},
+	{"I", 1, 1}};
+#include <string.h>
+int romanToInt(char *s)
+{
+	int len = strlen(s);
+	char *end = s + len;
+	int i = 0;
+	int r = 0;
+	while (i < 13)
+	{
+		if (end - s >= units[i].l && memcmp(s, units[i].r, units[i].l) == 0)
+		{
+			r += units[i].v;
+			s += units[i].l;
+		}
+		else
+			i++;
+	}
+	return r;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/89.exercises/config.json

+{
+  "node_id": "dailycode-6fd7f55fc75346a79d86180dfced2647",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/89.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "https://github.com/begeekmyfriend/leetcode",
+  "source": "solution.md",
+  "exercise_id": "ddc7227b307247a98c306ca0724f5104"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/89.exercises/solution.md

+# 加一
+
+<p>给定一个由 <strong>整数 </strong>组成的<strong> 非空</strong> 数组所表示的非负整数，在该数的基础上加一。</p><p>最高位数字存放在数组的首位， 数组中每个元素只存储<strong>单个</strong>数字。</p><p>你可以假设除了整数 0 之外，这个整数不会以零开头。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>digits = [1,2,3]<strong><br />输出：</strong>[1,2,4]<strong><br />解释：</strong>输入数组表示数字 123。</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>digits = [4,3,2,1]<strong><br />输出：</strong>[4,3,2,2]<strong><br />解释：</strong>输入数组表示数字 4321。</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>digits = [0]<strong><br />输出：</strong>[1]</pre><p> </p><p><strong>提示：</strong></p><ul>	<li><code>1 <= digits.length <= 100</code></li>	<li><code>0 <= digits[i] <= 9</code></li></ul>
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+class Solution
+{
+public:
+	vector<int> plusOne(vector<int> &digits)
+	{
+		int carry = 1;
+		vector<int> res;
+		for (int i = digits.size() - 1; i >= 0; i--)
+		{
+			int d = digits[i] + carry;
+			res.push_back(d % 10);
+			carry = d / 10;
+		}
+		if (carry > 0)
+		{
+			res.push_back(carry);
+		}
+		reverse(res.begin(), res.end());
+		return res;
+	}
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/90.exercises/config.json

+{
+  "node_id": "dailycode-af8c46da0fd44d8ea538ddd35ded9d31",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/90.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "https://github.com/begeekmyfriend/leetcode",
+  "source": "solution.md",
+  "exercise_id": "d85116829b2a4fb2b1988b3574df01a8"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/90.exercises/solution.md

+# 删除有序数组中的重复项
+
+<div class="notranslate">
+    <p>给你一个有序数组 <code>nums</code> ，请你<strong><a href="http://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95">
+                原地</a></strong> 删除重复出现的元素，使每个元素 <strong>只出现一次</strong> ，返回删除后数组的新长度。</p>
+
+    <p>不要使用额外的数组空间，你必须在 <strong><a href="https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95">原地
+            </a>修改输入数组 </strong>并在使用 O(1) 额外空间的条件下完成。</p>
+
+    <p>&nbsp;</p>
+
+    <p><strong>说明:</strong></p>
+
+    <p>为什么返回数值是整数，但输出的答案是数组呢?</p>
+
+    <p>请注意，输入数组是以<strong>「引用」</strong>方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。</p>
+
+    <p>你可以想象内部操作如下:</p>
+
+    <pre>// <strong>nums</strong> 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
+int len = removeDuplicates(nums);
+
+// 在函数里修改输入数组对于调用者是可见的。
+// 根据你的函数返回的长度, 它会打印出数组中<strong> 该长度范围内</strong> 的所有元素。
+for (int i = 0; i &lt; len; i++) {
+&nbsp; &nbsp; print(nums[i]);
+}
+</pre>
+    &nbsp;
+
+    <p><strong>示例 1：</strong></p>
+
+    <pre><strong>输入：</strong>nums = [1,1,2]
+<strong><br />输出：</strong>2, nums = [1,2]
+<strong><br />解释：</strong>函数应该返回新的长度 <strong>2</strong> ，并且原数组 <em>nums </em>的前两个元素被修改为 <strong>1</strong>, <strong>2 </strong>。不需要考虑数组中超出新长度后面的元素。
+    </pre>
+
+    <p><strong>示例 2：</strong></p>
+
+    <pre><strong>输入：</strong>nums = [0,0,1,1,1,2,2,3,3,4]
+<strong><br />输出：</strong>5, nums = [0,1,2,3,4]
+<strong><br />解释：</strong>函数应该返回新的长度 <strong>5</strong> ， 并且原数组 <em>nums </em>的前五个元素被修改为 <strong>0</strong>, <strong>1</strong>, <strong>2</strong>, <strong>3</strong>, <strong>4</strong> 。不需要考虑数组中超出新长度后面的元素。
+    </pre>
+
+    <p>&nbsp;</p>
+
+    <p><strong>提示：</strong></p>
+
+    <ul>
+        <li><code>0 &lt;= nums.length &lt;= 3 * 10<sup>4</sup></code></li>
+        <li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+        <li><code>nums</code> 已按升序排列</li>
+    </ul>
+
+    <p>&nbsp;</p>
+</div>
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+class Solution
+{
+public:
+	int removeDuplicates(vector<int> &nums)
+	{
+		if (nums.size() == 0)
+		{
+			return 0;
+		}
+		int count = 1;
+		for (int i = 1; i < nums.size(); i++)
+		{
+			if (nums[i - 1] != nums[i])
+			{
+				nums[count++] = nums[i];
+			}
+		}
+		return count;
+	}
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/91.exercises/config.json

+{
+  "node_id": "dailycode-57d9689619c24c7f9f8866dcba6abc07",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/91.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "b1ef2c6993234bfe9cc84664980879a8"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/91.exercises/solution.md

+# 最长公共前缀
+
+<p>编写一个函数来查找字符串数组中的最长公共前缀。</p><p>如果不存在公共前缀，返回空字符串 <code>""</code>。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>strs = ["flower","flow","flight"]<strong><br />输出：</strong>"fl"</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>strs = ["dog","racecar","car"]<strong><br />输出：</strong>""<strong><br />解释：</strong>输入不存在公共前缀。</pre><p> </p><p><strong>提示：</strong></p><ul>	<li><code>0 <= strs.length <= 200</code></li>	<li><code>0 <= strs[i].length <= 200</code></li>	<li><code>strs[i]</code> 仅由小写英文字母组成</li></ul>
+
+## template
+
+```cpp
+class Solution
+{
+public:
+	string longestCommonPrefix(vector<string> &strs)
+	{
+		string lcp;
+		if (strs.size() == 0)
+			return lcp;
+		int min_len = INT_MAX;
+		int min_idx = 0;
+		for (int i = 0; i < strs.size(); ++i)
+		{
+			auto &s = strs[i];
+			if (s.size() < min_len)
+			{
+				min_len = s.size();
+				min_idx = i;
+			}
+		}
+		auto &smin = strs[min_idx];
+		for (int i = 0; i < min_len; ++i)
+		{
+			char c = smin[i];
+			int j;
+			for (j = 0; j < strs.size(); ++j)
+			{
+				auto &cs = strs[j];
+				if (c != cs[i])
+					break;
+			}
+			if (j == strs.size())
+				lcp += c;
+			else
+				break;
+		}
+		return lcp;
+	}
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/92.exercises/config.json

+{
+  "node_id": "dailycode-ba1669ba67774ce7b96566a3b440560e",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/92.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "https://github.com/begeekmyfriend/leetcode",
+  "source": "solution.md",
+  "exercise_id": "46f877111e4b48b48b5b00a2533251c7"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/92.exercises/solution.md

+# 最大子序和
+
+<p>给定一个整数数组 <code>nums</code> ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>nums = [-2,1,-3,4,-1,2,1,-5,4]<strong><br />输出：</strong>6<strong><br />解释：</strong>连续子数组 [4,-1,2,1] 的和最大，为 6 。</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>nums = [1]<strong><br />输出：</strong>1</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>nums = [0]<strong><br />输出：</strong>0</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>nums = [-1]<strong><br />输出：</strong>-1</pre><p><strong>示例 5：</strong></p><pre><strong>输入：</strong>nums = [-100000]<strong><br />输出：</strong>-100000</pre><p> </p><p><strong>提示：</strong></p><ul>	<li><code>1 <= nums.length <= 3 * 10<sup>4</sup></code></li>	<li><code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code></li></ul><p> </p><p><strong>进阶：</strong>如果你已经实现复杂度为 <code>O(n)</code> 的解法，尝试使用更为精妙的 <strong>分治法</strong> 求解。</p>
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+class Solution
+{
+public:
+	int maxSubArray(vector<int> &nums)
+	{
+		int sum = 0, max_sum = INT_MIN;
+		for (int i = 0; i < nums.size(); i++)
+		{
+			if (sum < 0)
+			{
+				sum = nums[i];
+			}
+			else
+			{
+				sum += nums[i];
+			}
+			max_sum = max(sum, max_sum);
+		}
+		return max_sum;
+	}
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/93.exercises/config.json

+{
+  "node_id": "dailycode-90a4e4b0fd9f4c499d1c0243459e8fec",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/93.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "https://github.com/begeekmyfriend/leetcode",
+  "source": "solution.md",
+  "exercise_id": "61f11c4ed47441e58765ebdb7651c3dd"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/93.exercises/solution.md

+# x 的平方根
+
+<p>实现&nbsp;<code>int sqrt(int x)</code>&nbsp;函数。</p>
+<p>计算并返回&nbsp;<em>x</em>&nbsp;的平方根，其中&nbsp;<em>x </em>是非负整数。</p>
+<p>由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。</p>
+<p><strong>示例 1:</strong></p>
+<pre><strong>输入:</strong> 4<strong><br />输出:</strong> 2</pre>
+<p><strong>示例 2:</strong></p>
+<pre><strong>输入:</strong> 8<strong><br />输出:</strong> 2<strong><br />说明:</strong> 8 的平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。</pre>
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+class Solution
+{
+public:
+	int mySqrt(int x)
+	{
+		if (x == 0)
+		{
+			return 0;
+		}
+		unsigned int lo = 1, hi = x;
+		unsigned int mid = (lo + hi) / 2;
+		for (;;)
+		{
+			if (mid > x / mid)
+			{
+				hi = mid;
+			}
+			else
+			{
+				if (mid + 1 > x / (mid + 1))
+				{
+					break;
+				}
+				else
+				{
+					lo = mid;
+				}
+			}
+			mid = (lo + hi) / 2;
+		}
+		return mid;
+	}
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/94.exercises/config.json

+{
+  "node_id": "dailycode-87f69ccc9963410daeef13f9ebe40b62",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/94.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "https://github.com/begeekmyfriend/leetcode",
+  "source": "solution.md",
+  "exercise_id": "e17223f3f0914739909403b6c2c210bf"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/94.exercises/solution.md

+# 合并两个有序数组
+
+<p>给你两个有序整数数组 <code>nums1</code><em> </em>和 <code>nums2</code>，请你将 <code>nums2</code><em> </em>合并到 <code>nums1</code><em> </em>中<em>，</em>使 <code>nums1</code><em> </em>成为一个有序数组。</p><p>初始化 <code>nums1</code> 和 <code>nums2</code> 的元素数量分别为 <code>m</code> 和 <code>n</code><em> </em>。你可以假设 <code>nums1</code><em> </em>的空间大小等于 <code>m + n</code>，这样它就有足够的空间保存来自 <code>nums2</code> 的元素。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3<strong><br />输出：</strong>[1,2,2,3,5,6]</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>nums1 = [1], m = 1, nums2 = [], n = 0<strong><br />输出：</strong>[1]</pre><p> </p><p><strong>提示：</strong></p><ul>	<li><code>nums1.length == m + n</code></li>	<li><code>nums2.length == n</code></li>	<li><code>0 <= m, n <= 200</code></li>	<li><code>1 <= m + n <= 200</code></li>	<li><code>-10<sup>9</sup> <= nums1[i], nums2[i] <= 10<sup>9</sup></code></li></ul>
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+class Solution
+{
+public:
+	void merge(vector<int> &nums1, int m, vector<int> &nums2, int n)
+	{
+		int i = m - 1;
+		int j = n - 1;
+		int k = nums1.size() - 1;
+		while (i >= 0 && j >= 0)
+		{
+			if (nums1[i] < nums2[j])
+			{
+				nums1[k--] = nums2[j--];
+			}
+			else
+			{
+				nums1[k--] = nums1[i--];
+			}
+		}
+		while (j >= 0)
+		{
+			nums1[k--] = nums2[j--];
+		}
+	}
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/95.exercises/config.json

+{
+  "node_id": "dailycode-39b054895565431f9abb655290420ef6",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/95.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "https://github.com/begeekmyfriend/leetcode",
+  "source": "solution.md",
+  "exercise_id": "58dbe67b6b94425393240a137e84b6df"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/95.exercises/solution.md

+# 搜索插入位置
+
+<p>给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。</p><p>你可以假设数组中无重复元素。</p><p><strong>示例 1:</strong></p><pre><strong>输入:</strong> [1,3,5,6], 5<strong><br />输出:</strong> 2</pre><p><strong>示例&nbsp;2:</strong></p><pre><strong>输入:</strong> [1,3,5,6], 2<strong><br />输出:</strong> 1</pre><p><strong>示例 3:</strong></p><pre><strong>输入:</strong> [1,3,5,6], 7<strong><br />输出:</strong> 4</pre><p><strong>示例 4:</strong></p><pre><strong>输入:</strong> [1,3,5,6], 0<strong><br />输出:</strong> 0</pre>
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+class Solution
+{
+public:
+	int searchInsert(vector<int> &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;
+			}
+		}
+		return hi;
+	}
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/96.exercises/config.json

+{
+  "node_id": "dailycode-3f9bee77ffa14445bcbdeccdfc9d8999",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/96.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "6bfdb268efd0451d815311a3e13ed748"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/96.exercises/solution.md

+# 回文数
+
+<p>给你一个整数 <code>x</code> ，如果 <code>x</code> 是一个回文整数，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p><p>回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，<code>121</code> 是回文，而 <code>123</code> 不是。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>x = 121<strong><br />输出：</strong>true</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>x = -121<strong><br />输出：</strong>false<strong><br />解释：</strong>从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>x = 10<strong><br />输出：</strong>false<strong><br />解释：</strong>从右向左读, 为 01 。因此它不是一个回文数。</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>x = -101<strong><br />输出：</strong>false</pre><p> </p><p><strong>提示：</strong></p><ul>	<li><code>-2<sup>31</sup> <= x <= 2<sup>31</sup> - 1</code></li></ul><p> </p><p><strong>进阶：</strong>你能不将整数转为字符串来解决这个问题吗？</p>
+
+## template
+
+```cpp
+bool isPalindrome(int x)
+{
+	if (x < 0)
+		return false;
+	char r[11];
+	int n = snprintf(r, 11, "%d", x);
+	int i;
+	for (i = 0; i < n / 2; i++)
+	{
+		if (r[i] != r[n - i - 1])
+			return false;
+	}
+	return true;
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/1.cpp/97.exercises/config.json

+{
+  "node_id": "dailycode-7c185a60846747898557661fb914b567",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/97.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "87b8a7b259d9495b8227d76d8a704436"
+}
\ No newline at end of file

data/1.dailycode初阶/1.cpp/97.exercises/solution.md

+# 有效的括号
+
+<p>给定一个只包括 <code>'('</code>，<code>')'</code>，<code>'{'</code>，<code>'}'</code>，<code>'['</code>，<code>']'</code> 的字符串 <code>s</code> ，判断字符串是否有效。</p><p>有效字符串需满足：</p><ol>	<li>左括号必须用相同类型的右括号闭合。</li>	<li>左括号必须以正确的顺序闭合。</li></ol><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>s = "()"<strong><br />输出：</strong>true</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>s = "()[]{}"<strong><br />输出：</strong>true</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>s = "(]"<strong><br />输出：</strong>false</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>s = "([)]"<strong><br />输出：</strong>false</pre><p><strong>示例 5：</strong></p><pre><strong>输入：</strong>s = "{[]}"<strong><br />输出：</strong>true</pre><p> </p><p><strong>提示：</strong></p><ul>	<li><code>1 <= s.length <= 10<sup>4</sup></code></li>	<li><code>s</code> 仅由括号 <code>'()[]{}'</code> 组成</li></ul>
+
+## template
+
+```cpp
+#include <stack>
+char ascii_tab[128];
+class Solution
+{
+public:
+	bool isValid(string s)
+	{
+		if (s.size() == 0)
+			return true;
+		std::stack<char> st;
+		ascii_tab['('] = 11;
+		ascii_tab['{'] = 12;
+		ascii_tab['['] = 13;
+		ascii_tab[')'] = 21;
+		ascii_tab['}'] = 22;
+		ascii_tab[']'] = 23;
+		for (auto c : s)
+		{
+			char n = ascii_tab[c];
+			if (n < 20)
+				st.push(n);
+			else
+			{
+				if (st.empty())
+					return false;
+				if (n != st.top() + 10)
+					return false;
+				st.pop();
+			}
+		}
+		if (st.empty())
+			return true;
+		return false;
+	}
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data/1.dailycode初阶/2.java/29.exercises/config.json

+{
+  "node_id": "dailycode-79825ba736e2491eba7fa79d17fee5cc",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/29.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "1ba2a81cf8f54c199de23ea06e68388b"
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/29.exercises/solution.md

+# 合并两个有序链表
+
+<p>将两个升序链表合并为一个新的 <strong>升序</strong> 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 </p><p> </p><p><strong>示例 1：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0021.Merge%20Two%20Sorted%20Lists/images/merge_ex1.jpg" style="width: 662px; height: 302px;" /><pre><strong>输入：</strong>l1 = [1,2,4], l2 = [1,3,4]<strong><br />输出：</strong>[1,1,2,3,4,4]</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>l1 = [], l2 = []<strong><br />输出：</strong>[]</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>l1 = [], l2 = [0]<strong><br />输出：</strong>[0]</pre><p> </p><p><strong>提示：</strong></p><ul>	<li>两个链表的节点数目范围是 <code>[0, 50]</code></li>	<li><code>-100 <= Node.val <= 100</code></li>	<li><code>l1</code> 和 <code>l2</code> 均按 <strong>非递减顺序</strong> 排列</li></ul>
+
+## template
+
+```java
+public 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 mergeTwoLists(ListNode l1, ListNode l2) {
+		ListNode h = new ListNode(0, null);
+		ListNode p = h;
+		while (l1 != null && l2 != null) {
+			if (l1.val < l2.val) {
+				p.next = l1;
+				p = l1;
+				l1 = l1.next;
+			} else {
+				p.next = l2;
+				p = l2;
+				l2 = l2.next;
+			}
+		}
+		if (l1 != null) {
+			p.next = l1;
+		} else {
+			p.next = l2;
+		}
+		return h.next;
+	}
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file

data/1.dailycode初阶/2.java/30.exercises/config.json

+{
+  "node_id": "dailycode-f183ba2c39864169b9a6ed97716e5cbe",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/30.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "bf91a030cce14ed6a9000500c43d3444"
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/30.exercises/solution.md

+# 最后一个单词的长度
+
+<p>给你一个字符串 <code>s</code>，由若干单词组成，单词之间用空格隔开。返回字符串中最后一个单词的长度。如果不存在最后一个单词，请返回 0 。</p><p><strong>单词</strong> 是指仅由字母组成、不包含任何空格字符的最大子字符串。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>s = "Hello World"<strong><br />输出：</strong>5</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>s = " "<strong><br />输出：</strong>0</pre><p> </p><p><strong>提示：</strong></p><ul>	<li><code>1 <= s.length <= 10<sup>4</sup></code></li>	<li><code>s</code> 仅有英文字母和空格 <code>' '</code> 组成</li></ul>
+
+## template
+
+```java
+class Solution {
+	public int lengthOfLastWord(String s) {
+		int count = 0;
+		for (int i = s.length() - 1; i >= 0; i--) {
+			if (s.charAt(i) != ' ') {
+				count++;
+			} else if (count > 0) {
+				return count;
+			}
+		}
+		return count;
+	}
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file

data/1.dailycode初阶/2.java/31.exercises/config.json

+{
+  "node_id": "dailycode-2a13f5f56d9143b697bf4e9993fc43e0",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/31.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "ce7fcea6474f4e9295f4de3fe4c3678b"
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/31.exercises/solution.md

+# 删除排序链表中的重复元素
+
+<p>存在一个按升序排列的链表，给你这个链表的头节点 <code>head</code> ，请你删除所有重复的元素，使每个元素 <strong>只出现一次</strong> 。</p><p>返回同样按升序排列的结果链表。</p><p> </p><p><strong>示例 1：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0083.Remove%20Duplicates%20from%20Sorted%20List/images/list1.jpg" style="width: 302px; height: 242px;" /><pre><strong>输入：</strong>head = [1,1,2]<strong><br />输出：</strong>[1,2]</pre><p><strong>示例 2：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0083.Remove%20Duplicates%20from%20Sorted%20List/images/list2.jpg" style="width: 542px; height: 222px;" /><pre><strong>输入：</strong>head = [1,1,2,3,3]<strong><br />输出：</strong>[1,2,3]</pre><p> </p><p><strong>提示：</strong></p><ul>	<li>链表中节点数目在范围 <code>[0, 300]</code> 内</li>	<li><code>-100 <= Node.val <= 100</code></li>	<li>题目数据保证链表已经按升序排列</li></ul>
+
+## template
+
+```java
+public class ListNode {
+	int val;
+	ListNode next;
+	ListNode(int x) {
+		val = x;
+	}
+}
+class Solution {
+	public ListNode deleteDuplicates(ListNode head) {
+		if (head == null || head.next == null) {
+			return head;
+		}
+		head.next = deleteDuplicates(head.next);
+		if (head.val == head.next.val)
+			head = head.next;
+		return head;
+	}
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file

data/1.dailycode初阶/2.java/32.exercises/config.json

+{
+  "node_id": "dailycode-0bd05a83155447e3a502e650c18ce7d4",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/32.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "1b3f572ac66b4de3ae2cc64a31250347"
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/32.exercises/solution.md

+# 整数反转
+
+<p>给你一个 32 位的有符号整数 <code>x</code> ，返回将 <code>x</code> 中的数字部分反转后的结果。</p><p>如果反转后整数超过 32 位的有符号整数的范围 <code>[−2<sup>31</sup>,  2<sup>31 </sup>− 1]</code> ，就返回 0。</p><strong>假设环境不允许存储 64 位整数（有符号或无符号）。</strong><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>x = 123<strong><br />输出：</strong>321</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>x = -123<strong><br />输出：</strong>-321</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>x = 120<strong><br />输出：</strong>21</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>x = 0<strong><br />输出：</strong>0</pre><p> </p><p><strong>提示：</strong></p><ul>	<li><code>-2<sup>31</sup> <= x <= 2<sup>31</sup> - 1</code></li></ul>
+
+## template
+
+```java
+class Solution {
+	public int reverse(int x) {
+		long xx = x;
+		long r;
+		long y = 0;
+		boolean sign = xx < 0;
+		while (xx != 0) {
+			r = xx % 10;
+			y = y * 10 + r;
+			if (sign) {
+				xx = (long) Math.ceil(xx / 10);
+			} else {
+				xx = (long) Math.floor(xx / 10);
+			}
+		}
+		return y > Integer.MAX_VALUE || y < Integer.MIN_VALUE ? 0 : (int) y;
+	}
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file

data/1.dailycode初阶/2.java/33.exercises/config.json

+{
+  "node_id": "dailycode-b79f19cc66174f4c9f98c05591dee625",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/33.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "9481c9692be8440aa11e46926b482400"
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/33.exercises/solution.md

+# 相同的树
+
+<p>给你两棵二叉树的根节点 <code>p</code> 和 <code>q</code> ，编写一个函数来检验这两棵树是否相同。</p><p>如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。</p><p> </p><p><strong>示例 1：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0100-0199/0100.Same%20Tree/images/ex1.jpg" style="width: 622px; height: 182px;" /><pre><strong>输入：</strong>p = [1,2,3], q = [1,2,3]<strong><br />输出：</strong>true</pre><p><strong>示例 2：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0100-0199/0100.Same%20Tree/images/ex2.jpg" style="width: 382px; height: 182px;" /><pre><strong>输入：</strong>p = [1,2], q = [1,null,2]<strong><br />输出：</strong>false</pre><p><strong>示例 3：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0100-0199/0100.Same%20Tree/images/ex3.jpg" style="width: 622px; height: 182px;" /><pre><strong>输入：</strong>p = [1,2,1], q = [1,1,2]<strong><br />输出：</strong>false</pre><p> </p><p><strong>提示：</strong></p><ul>	<li>两棵树上的节点数目都在范围 <code>[0, 100]</code> 内</li>	<li><code>-10<sup>4</sup> <= Node.val <= 10<sup>4</sup></code></li></ul>
+
+## template
+
+```java
+public class TreeNode {
+	int val;
+	TreeNode left;
+	TreeNode right;
+
+	TreeNode() {
+	}
+
+	TreeNode(int val) {
+		this.val = val;
+	}
+
+	TreeNode(int val, TreeNode left, TreeNode right) {
+		this.val = val;
+		this.left = left;
+		this.right = right;
+	}
+}
+
+class Solution {
+	public boolean isSameTree(TreeNode p, TreeNode q) {
+		if (p == null && q == null) {
+			return true;
+		}
+		if (p != null && q != null && p.val == q.val) {
+			return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+		} else {
+			return false;
+		}
+	}
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file

data/1.dailycode初阶/2.java/34.exercises/config.json

+{
+  "node_id": "dailycode-d8565e4b363749c0940b45c69f3dcd97",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/34.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "a2d8971de0804ac99686ba33d3ab7a60"
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/34.exercises/solution.md

+# 两数之和
+
+<p>给定一个整数数组 <code>nums</code> 和一个整数目标值 <code>target</code>，请你在该数组中找出 <strong>和为目标值</strong> 的那 <strong>两个</strong> 整数，并返回它们的数组下标。</p><p>你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。</p><p>你可以按任意顺序返回答案。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>nums = [2,7,11,15], target = 9<strong><br />输出：</strong>[0,1]<strong><br />解释：</strong>因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>nums = [3,2,4], target = 6<strong><br />输出：</strong>[1,2]</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>nums = [3,3], target = 6<strong><br />输出：</strong>[0,1]</pre><p> </p><p><strong>提示：</strong></p><ul>	<li><code>2 <= nums.length <= 10<sup>3</sup></code></li>	<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>	<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>	<li><strong>只会存在一个有效答案</strong></li></ul>
+
+## template
+
+```java
+class Solution {
+	public int[] twoSum(int[] nums, int target) {
+		Map<Integer, Integer> cache = new HashMap<>();
+		for (int i = 0; i < nums.length; i++) {
+			int distance = target - nums[i];
+			if (cache.containsKey(distance)) {
+				return new int[] { cache.get(distance), i };
+			} else {
+				cache.put(nums[i], i);
+			}
+		}
+		return new int[] {};
+	}
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file

data/1.dailycode初阶/2.java/35.exercises/config.json

+{
+  "node_id": "dailycode-bf0a6a2dd04c4a3ba85c57476e8b26db",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/35.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "0f9d647aa15c49ec8d407eb7e5224214"
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/35.exercises/solution.md

+# 移除元素
+
+<div class="notranslate">
+    <p>给你一个数组 <code>nums</code><em>&nbsp;</em>和一个值 <code>val</code>，你需要 <strong><a
+                href="https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95">原地</a></strong>
+        移除所有数值等于&nbsp;<code>val</code><em>&nbsp;</em>的元素，并返回移除后数组的新长度。</p>
+
+    <p>不要使用额外的数组空间，你必须仅使用 <code>O(1)</code> 额外空间并 <strong><a
+                href="https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95">原地 </a>修改输入数组</strong>。</p>
+
+    <p>元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。</p>
+
+    <p>&nbsp;</p>
+
+    <p><strong>说明:</strong></p>
+
+    <p>为什么返回数值是整数，但输出的答案是数组呢?</p>
+
+    <p>请注意，输入数组是以<strong>「引用」</strong>方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。</p>
+
+    <p>你可以想象内部操作如下:</p>
+
+    <pre>// <strong>nums</strong> 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
+int len = removeElement(nums, val);
+
+// 在函数里修改输入数组对于调用者是可见的。
+// 根据你的函数返回的长度, 它会打印出数组中<strong> 该长度范围内</strong> 的所有元素。
+for (int i = 0; i &lt; len; i++) {
+&nbsp; &nbsp; print(nums[i]);
+}
+</pre>
+
+    <p>&nbsp;</p>
+
+    <p><strong>示例 1：</strong></p>
+
+    <pre><strong>输入：</strong>nums = [3,2,2,3], val = 3
+<strong><br />输出：</strong>2, nums = [2,2]
+<strong><br />解释：</strong>函数应该返回新的长度 <strong>2</strong>, 并且 nums<em> </em>中的前两个元素均为 <strong>2</strong>。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。
+    </pre>
+
+    <p><strong>示例 2：</strong></p>
+
+    <pre><strong>输入：</strong>nums = [0,1,2,2,3,0,4,2], val = 2
+<strong><br />输出：</strong>5, nums = [0,1,4,0,3]
+<strong><br />解释：</strong>函数应该返回新的长度 <strong>5</strong>, 并且 nums 中的前五个元素为 <strong>0</strong>, <strong>1</strong>, <strong>3</strong>, <strong>0</strong>, <strong>4</strong>。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
+    </pre>
+
+    <p>&nbsp;</p>
+
+    <p><strong>提示：</strong></p>
+
+    <ul>
+        <li><code>0 &lt;= nums.length &lt;= 100</code></li>
+        <li><code>0 &lt;= nums[i] &lt;= 50</code></li>
+        <li><code>0 &lt;= val &lt;= 100</code></li>
+    </ul>
+</div>
+
+## template
+
+```java
+class Solution {
+	public int removeElement(int[] nums, int val) {
+
+		int len = nums.length;
+		for (int i = 0; i < len;) {
+			if (nums[i] == val) {
+				nums[i] = nums[len - 1];
+				len--;
+			} else {
+				i++;
+			}
+
+		}
+		return len;
+	}
+}
+
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file

data/1.dailycode初阶/2.java/36.exercises/config.json

+{
+  "node_id": "dailycode-9b564171d7c14b87b6b01b3fdb8e4ddc",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/36.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "e73f678b535c4b27a53a97d413ae326b"
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/36.exercises/solution.md

+# 二进制求和
+
+<p>给你两个二进制字符串，返回它们的和（用二进制表示）。</p><p>输入为 <strong>非空 </strong>字符串且只包含数字&nbsp;<code>1</code>&nbsp;和&nbsp;<code>0</code>。</p><p>&nbsp;</p><p><strong>示例&nbsp;1:</strong></p><pre><strong>输入:</strong> a = &quot;11&quot;, b = &quot;1&quot;<strong><br />输出:</strong> &quot;100&quot;</pre><p><strong>示例&nbsp;2:</strong></p><pre><strong>输入:</strong> a = &quot;1010&quot;, b = &quot;1011&quot;<strong><br />输出:</strong> &quot;10101&quot;</pre><p>&nbsp;</p><p><strong>提示：</strong></p><ul>	<li>每个字符串仅由字符 <code>&#39;0&#39;</code> 或 <code>&#39;1&#39;</code> 组成。</li>	<li><code>1 &lt;= a.length, b.length &lt;= 10^4</code></li>	<li>字符串如果不是 <code>&quot;0&quot;</code> ，就都不含前导零。</li></ul>
+
+## template
+
+```java
+class Solution {
+	public String addBinary(String a, String b) {
+
+		StringBuffer s1 = new StringBuffer(a);
+		s1.reverse();
+		StringBuffer s2 = new StringBuffer(b);
+		s2.reverse();
+
+		if (s1.length() > s2.length()) {
+			int n = s1.length() - s2.length();
+			for (int i = 0; i < n; i++) {
+				s2.append('0');
+			}
+		} else if (s1.length() < s2.length()) {
+			int n = s2.length() - s1.length();
+			for (int i = 0; i < n; i++) {
+				s1.append('0');
+			}
+		}
+
+		StringBuffer stringBuffer = new StringBuffer("");
+		int i = 0;
+		char flag = '0';
+		while (i < s1.length() && i < s2.length()) {
+			if (flag == '0') {
+				if (s1.charAt(i) == s2.charAt(i) && s1.charAt(i) == '1') {
+					flag = '1';
+					stringBuffer.append('0');
+				} else if (s1.charAt(i) == s2.charAt(i) && s1.charAt(i) == '0') {
+					stringBuffer.append('0');
+				} else {
+					stringBuffer.append('1');
+				}
+			} else {
+				if (s1.charAt(i) == s2.charAt(i) && s1.charAt(i) == '1') {
+					flag = '1';
+					stringBuffer.append('1');
+				} else if (s1.charAt(i) == s2.charAt(i) && s1.charAt(i) == '0') {
+					flag = '0';
+					stringBuffer.append('1');
+				} else {
+					flag = '1';
+					stringBuffer.append('0');
+				}
+			}
+			i++;
+		}
+		if (flag == '1') {
+			stringBuffer.append(flag);
+		}
+		stringBuffer.reverse();
+		return stringBuffer.toString();
+	}
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file

data/1.dailycode初阶/2.java/37.exercises/config.json

+{
+  "node_id": "dailycode-80b8bca4019b47e482bfb940010535b1",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/37.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "d2415dab730e4e27ae1a40c9c99eb3d5"
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/37.exercises/solution.md

+# 二叉树的中序遍历
+
+<p>给定一个二叉树的根节点 <code>root</code> ，返回它的 <strong>中序</strong> 遍历。</p><p> </p><p><strong>示例 1：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0094.Binary%20Tree%20Inorder%20Traversal/images/inorder_1.jpg" style="width: 202px; height: 324px;" /><pre><strong>输入：</strong>root = [1,null,2,3]<strong><br />输出：</strong>[1,3,2]</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>root = []<strong><br />输出：</strong>[]</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>root = [1]<strong><br />输出：</strong>[1]</pre><p><strong>示例 4：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0094.Binary%20Tree%20Inorder%20Traversal/images/inorder_5.jpg" style="width: 202px; height: 202px;" /><pre><strong>输入：</strong>root = [1,2]<strong><br />输出：</strong>[2,1]</pre><p><strong>示例 5：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0094.Binary%20Tree%20Inorder%20Traversal/images/inorder_4.jpg" style="width: 202px; height: 202px;" /><pre><strong>输入：</strong>root = [1,null,2]<strong><br />输出：</strong>[1,2]</pre><p> </p><p><strong>提示：</strong></p><ul>	<li>树中节点数目在范围 <code>[0, 100]</code> 内</li>	<li><code>-100 <= Node.val <= 100</code></li></ul><p> </p><p><strong>进阶:</strong> 递归算法很简单，你可以通过迭代算法完成吗？</p>
+
+## template
+
+```java
+
+public class TreeNode {
+	int val;
+	TreeNode left;
+	TreeNode right;
+
+	TreeNode(int x) {
+		val = x;
+	}
+}
+
+class Solution {
+	public List<Integer> inorderTraversal(TreeNode root) {
+		List<Integer> list = new ArrayList<>();
+		Stack<TreeNode> stack = new Stack<>();
+		TreeNode cur = root;
+		while (cur != null || !stack.isEmpty()) {
+			if (cur != null) {
+				stack.push(cur);
+				cur = cur.left;
+			} else {
+				cur = stack.pop();
+				list.add(cur.val);
+				cur = cur.right;
+			}
+		}
+		return list;
+	}
+}
+
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file

data/1.dailycode初阶/2.java/38.exercises/config.json

+{
+  "node_id": "dailycode-750be61c5c3d4a8593e131e6bc01b265",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/38.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "fc6e5fcd26ec4e82af2abf51e85899ae"
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/38.exercises/solution.md

+# 爬楼梯
+
+<p>假设你正在爬楼梯。需要 <em>n</em>&nbsp;阶你才能到达楼顶。</p><p>每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？</p><p><strong>注意：</strong>给定 <em>n</em> 是一个正整数。</p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong> 2<strong><br />输出：</strong> 2<strong><br />解释：</strong> 有两种方法可以爬到楼顶。1.  1 阶 + 1 阶2.  2 阶</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong> 3<strong><br />输出：</strong> 3<strong><br />解释：</strong> 有三种方法可以爬到楼顶。1.  1 阶 + 1 阶 + 1 阶2.  1 阶 + 2 阶3.  2 阶 + 1 阶</pre>
+
+## template
+
+```java
+class Solution {
+	public int climbStairs(int n) {
+		int[] num = new int[n + 1];
+		num[0] = 1;
+		num[1] = 1;
+		for (int i = 2; i <= n; i++) {
+			num[i] = num[i - 1] + num[i - 2];
+		}
+		return num[n];
+	}
+}
+
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file

data/1.dailycode初阶/2.java/39.exercises/config.json

+{
+  "node_id": "dailycode-9c76a186f2db4ad8a38b3168c0894d48",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/39.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "370027f8c2c749d4bbdd2131203bec37"
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/39.exercises/solution.md

+# 罗马数字转整数
+
+<div class="notranslate">
+    <p>罗马数字包含以下七种字符：&nbsp;<code>I</code>，&nbsp;<code>V</code>，&nbsp;<code>X</code>，&nbsp;<code>L</code>，<code>C</code>，<code>D</code>&nbsp;和&nbsp;<code>M</code>。
+    </p>
+
+    <pre><strong>字符</strong>          <strong>数值</strong>
+I             1
+V             5
+X             10
+L             50
+C             100
+D             500
+M             1000</pre>
+
+    <p>例如， 罗马数字 2 写做&nbsp;<code>II</code>&nbsp;，即为两个并列的 1。12
+        写做&nbsp;<code>XII</code>&nbsp;，即为&nbsp;<code>X</code>&nbsp;+&nbsp;<code>II</code>&nbsp;。 27
+        写做&nbsp;&nbsp;<code>XXVII</code>,
+        即为&nbsp;<code>XX</code>&nbsp;+&nbsp;<code>V</code>&nbsp;+&nbsp;<code>II</code>&nbsp;。</p>
+
+    <p>通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做&nbsp;<code>IIII</code>，而是&nbsp;<code>IV</code>。数字 1 在数字 5 的左边，所表示的数等于大数 5
+        减小数 1 得到的数值 4 。同样地，数字 9 表示为&nbsp;<code>IX</code>。这个特殊的规则只适用于以下六种情况：</p>
+
+    <ul>
+        <li><code>I</code>&nbsp;可以放在&nbsp;<code>V</code>&nbsp;(5) 和&nbsp;<code>X</code>&nbsp;(10) 的左边，来表示 4 和 9。</li>
+        <li><code>X</code>&nbsp;可以放在&nbsp;<code>L</code>&nbsp;(50) 和&nbsp;<code>C</code>&nbsp;(100) 的左边，来表示 40
+            和&nbsp;90。&nbsp;</li>
+        <li><code>C</code>&nbsp;可以放在&nbsp;<code>D</code>&nbsp;(500) 和&nbsp;<code>M</code>&nbsp;(1000) 的左边，来表示&nbsp;400
+            和&nbsp;900。</li>
+    </ul>
+
+    <p>给你一个整数，将其转为罗马数字。</p>
+
+    <p>&nbsp;</p>
+
+    <p><strong>示例&nbsp;1:</strong></p>
+
+    <pre><strong>输入:</strong>&nbsp;num = 3
+<strong><br />输出:</strong> "III"</pre>
+
+    <p><strong>示例&nbsp;2:</strong></p>
+
+    <pre><strong>输入:</strong>&nbsp;num = 4
+<strong><br />输出:</strong> "IV"</pre>
+
+    <p><strong>示例&nbsp;3:</strong></p>
+
+    <pre><strong>输入:</strong>&nbsp;num = 9
+<strong><br />输出:</strong> "IX"</pre>
+
+    <p><strong>示例&nbsp;4:</strong></p>
+
+    <pre><strong>输入:</strong>&nbsp;num = 58
+<strong><br />输出:</strong> "LVIII"
+<strong><br />解释:</strong> L = 50, V = 5, III = 3.
+    </pre>
+
+    <p><strong>示例&nbsp;5:</strong></p>
+
+    <pre><strong>输入:</strong>&nbsp;num = 1994
+<strong><br />输出:</strong> "MCMXCIV"
+<strong><br />解释:</strong> M = 1000, CM = 900, XC = 90, IV = 4.</pre>
+
+    <p>&nbsp;</p>
+
+    <p><strong>提示：</strong></p>
+
+    <ul>
+        <li><code>1 &lt;= num &lt;= 3999</code></li>
+    </ul>
+</div>
+
+## template
+
+```java
+class Solution {
+	public int romanToInt(String s) {
+		int n = 0;
+		for (int i = 0; i < s.length();) {
+			char c = s.charAt(i);
+			if (c == 'I') {
+				if (i + 1 < s.length()) {
+					if (s.charAt(i + 1) == 'V') {
+						n += 4;
+						i += 2;
+					} else if (s.charAt(i + 1) == 'X') {
+						n += 9;
+						i += 2;
+					} else {
+						n += 1;
+						i++;
+					}
+				} else {
+					n += 1;
+					i++;
+				}
+			} else if (c == 'X') {
+				if (i + 1 < s.length()) {
+					if (s.charAt(i + 1) == 'L') {
+						n += 40;
+						i += 2;
+					} else if (s.charAt(i + 1) == 'C') {
+						n += 90;
+						i += 2;
+					} else {
+						n += 10;
+						i++;
+					}
+				} else {
+					n += 10;
+					i++;
+				}
+			} else if (c == 'C') {
+				if (i + 1 < s.length()) {
+					if (s.charAt(i + 1) == 'D') {
+						n += 400;
+						i += 2;
+					} else if (s.charAt(i + 1) == 'M') {
+						n += 900;
+						i += 2;
+					} else {
+						n += 100;
+						i++;
+					}
+				} else {
+					n += 100;
+					i++;
+				}
+			} else if (c == 'V') {
+				n += 5;
+				i++;
+			} else if (c == 'L') {
+				n += 50;
+				i++;
+			} else if (c == 'D') {
+				n += 500;
+				i++;
+			} else if (c == 'M') {
+				n += 1000;
+				i++;
+			}
+		}
+		return n;
+	}
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file

data/1.dailycode初阶/2.java/40.exercises/config.json

+{
+  "node_id": "dailycode-91beb8ab1dc344a7b37703775f6c8509",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/40.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "ec09729c69c242748331fedfaff60803"
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/40.exercises/solution.md

+# 加一
+
+<p>给定一个由 <strong>整数 </strong>组成的<strong> 非空</strong> 数组所表示的非负整数，在该数的基础上加一。</p><p>最高位数字存放在数组的首位， 数组中每个元素只存储<strong>单个</strong>数字。</p><p>你可以假设除了整数 0 之外，这个整数不会以零开头。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>digits = [1,2,3]<strong><br />输出：</strong>[1,2,4]<strong><br />解释：</strong>输入数组表示数字 123。</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>digits = [4,3,2,1]<strong><br />输出：</strong>[4,3,2,2]<strong><br />解释：</strong>输入数组表示数字 4321。</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>digits = [0]<strong><br />输出：</strong>[1]</pre><p> </p><p><strong>提示：</strong></p><ul>	<li><code>1 <= digits.length <= 100</code></li>	<li><code>0 <= digits[i] <= 9</code></li></ul>
+
+## template
+
+```java
+class Solution {
+	public int[] plusOne(int[] digits) {
+		int i = digits.length - 1;
+		while (i >= 0 && (digits[i] = digits[i] + 1) == 10) {
+			digits[i] = 0;
+			i--;
+		}
+		if (digits[0] == 0) {
+			int[] temp = new int[digits.length + 1];
+			temp[0] = 1;
+			return temp;
+		}
+		return digits;
+	}
+}
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file

data/1.dailycode初阶/2.java/41.exercises/config.json

+{
+  "node_id": "dailycode-849fbcc215a6416db0db45225ec3d51a",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/41.exercises/solution.json

+{
+  "type": "code_options",
+  "author": "csdn.net",
+  "source": "solution.md",
+  "exercise_id": "2d8b0c5a16364b9c92c4df3758a2b4e7"
+}
\ No newline at end of file

data/1.dailycode初阶/2.java/41.exercises/solution.md

+# 删除有序数组中的重复项
+
+<div class="notranslate">
+    <p>给你一个有序数组 <code>nums</code> ，请你<strong><a href="http://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95">
+                原地</a></strong> 删除重复出现的元素，使每个元素 <strong>只出现一次</strong> ，返回删除后数组的新长度。</p>
+
+    <p>不要使用额外的数组空间，你必须在 <strong><a href="https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95">原地
+            </a>修改输入数组 </strong>并在使用 O(1) 额外空间的条件下完成。</p>
+
+    <p>&nbsp;</p>
+
+    <p><strong>说明:</strong></p>
+
+    <p>为什么返回数值是整数，但输出的答案是数组呢?</p>
+
+    <p>请注意，输入数组是以<strong>「引用」</strong>方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。</p>
+
+    <p>你可以想象内部操作如下:</p>
+
+    <pre>// <strong>nums</strong> 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
+int len = removeDuplicates(nums);
+
+// 在函数里修改输入数组对于调用者是可见的。
+// 根据你的函数返回的长度, 它会打印出数组中<strong> 该长度范围内</strong> 的所有元素。
+for (int i = 0; i &lt; len; i++) {
+&nbsp; &nbsp; print(nums[i]);
+}
+</pre>
+    &nbsp;
+
+    <p><strong>示例 1：</strong></p>
+
+    <pre><strong>输入：</strong>nums = [1,1,2]
+<strong><br />输出：</strong>2, nums = [1,2]
+<strong><br />解释：</strong>函数应该返回新的长度 <strong>2</strong> ，并且原数组 <em>nums </em>的前两个元素被修改为 <strong>1</strong>, <strong>2 </strong>。不需要考虑数组中超出新长度后面的元素。
+    </pre>
+
+    <p><strong>示例 2：</strong></p>
+
+    <pre><strong>输入：</strong>nums = [0,0,1,1,1,2,2,3,3,4]
+<strong><br />输出：</strong>5, nums = [0,1,2,3,4]
+<strong><br />解释：</strong>函数应该返回新的长度 <strong>5</strong> ， 并且原数组 <em>nums </em>的前五个元素被修改为 <strong>0</strong>, <strong>1</strong>, <strong>2</strong>, <strong>3</strong>, <strong>4</strong> 。不需要考虑数组中超出新长度后面的元素。
+    </pre>
+
+    <p>&nbsp;</p>
+
+    <p><strong>提示：</strong></p>
+
+    <ul>
+        <li><code>0 &lt;= nums.length &lt;= 3 * 10<sup>4</sup></code></li>
+        <li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+        <li><code>nums</code> 已按升序排列</li>
+    </ul>
+
+    <p>&nbsp;</p>
+</div>
+
+## template
+
+```java
+class Solution {
+	public int removeDuplicates(int[] nums) {
+		if (nums == null || nums.length == 0) {
+			return 0;
+		}
+		int a = 0;
+		for (int b = 1; b < nums.length; b++) {
+			if (nums[a] != nums[b]) {
+				a++;
+				nums[a] = nums[b];
+			}
+		}
+		return a + 1;
+	}
+}
+
+```
+
+## 答案
+
+```java
+
+```
+
+## 选项
+
+### A
+
+```java
+
+```
+
+### B
+
+```java
+
+```
+
+### C
+
+```java
+
+```
\ No newline at end of file

data/1.dailycode初阶/2.java/42.exercises/config.json

+{
+  "node_id": "dailycode-f70a1d0780f44b21b13937a341ef804b",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file