修复习题数量

data_source/exercises/中等/cpp/156.exercises/config.json → data/1.dailycode初阶/1.cpp/100.exercises/config.json

 {
-  "node_id": "dailycode-3ff87eb146d34897b954ad46df29bcb6",
+  "node_id": "dailycode-d335de511b684c29bfea723f6d33a0e4",
   "keywords": [],
   "children": [],
   "keywords_must": [],

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "930f3279f4384794846104506be93185",
+  "author": "csdn.net",
+  "keywords": "树,二叉搜索树,数组,分治,二叉树",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 将有序数组转换为二叉搜索树
+
+<p>给你一个整数数组 <code>nums</code> ，其中元素已经按 <strong>升序</strong> 排列，请你将其转换为一棵 <strong>高度平衡</strong> 二叉搜索树。</p>
+
+<p><strong>高度平衡 </strong>二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/btree1.jpg" style="width: 302px; height: 222px;" />
+<pre>
+<strong>输入：</strong>nums = [-10,-3,0,5,9]
+<strong>输出：</strong>[0,-3,9,-10,null,5]
+<strong>解释：</strong>[0,-10,5,null,-3,null,9] 也将被视为正确答案：
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/btree2.jpg" style="width: 302px; height: 222px;" />
+</pre>
+
+<p><strong>示例 2：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/btree.jpg" style="width: 342px; height: 142px;" />
+<pre>
+<strong>输入：</strong>nums = [1,3]
+<strong>输出：</strong>[3,1]
+<strong>解释：</strong>[1,3] 和 [3,1] 都是高度平衡二叉搜索树。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= nums.length <= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code></li>
+	<li><code>nums</code> 按 <strong>严格递增</strong> 顺序排列</li>
+</ul>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    TreeNode *sortedArrayToBST(vector<int> &nums)
+    {
+        return dfs(nums, 0, nums.size() - 1);
+    }
+
+    TreeNode *dfs(vector<int> &nums, int left, int right)
+    {
+        if (left > right)
+            return NULL;
+        int mid = (left + right) / 2;
+        TreeNode *t = new TreeNode(nums[mid]);
+        t->left = dfs(nums, left, mid - 1);
+        t->right = dfs(nums, mid + 1, right);
+        return t;
+    }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data_source/exercises/中等/cpp/161.exercises/config.json → data/1.dailycode初阶/1.cpp/101.exercises/config.json

 {
-  "node_id": "dailycode-97e15a0f1bdf4c899838b347b1983dc5",
+  "node_id": "dailycode-a83634532b824c769445b10d596917f6",
   "keywords": [],
   "children": [],
   "keywords_must": [],

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "15135e7668e043e7bb577426de5369b2",
+  "author": "csdn.net",
+  "keywords": "树,深度优先搜索,二叉树",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 平衡二叉树
+
+<p>给定一个二叉树，判断它是否是高度平衡的二叉树。</p>
+
+<p>本题中，一棵高度平衡二叉树定义为：</p>
+
+<blockquote>
+<p>一个二叉树<em>每个节点 </em>的左右两个子树的高度差的绝对值不超过 1 。</p>
+</blockquote>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/06/balance_1.jpg" style="width: 342px; height: 221px;" />
+<pre>
+<strong>输入：</strong>root = [3,9,20,null,null,15,7]
+<strong>输出：</strong>true
+</pre>
+
+<p><strong>示例 2：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/06/balance_2.jpg" style="width: 452px; height: 301px;" />
+<pre>
+<strong>输入：</strong>root = [1,2,2,3,3,null,null,4,4]
+<strong>输出：</strong>false
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>root = []
+<strong>输出：</strong>true
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>树中的节点数在范围 <code>[0, 5000]</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(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    int depth(TreeNode *root)
+    {
+        if (root == NULL)
+            return 0;
+        int left = depth(root->left);
+        int right = depth(root->right);
+        return max(left, right) + 1;
+    }
+
+    bool isBalanced(TreeNode *root)
+    {
+        if (root == NULL)
+            return true;
+        if (abs(depth(root->left) - depth(root->right)) > 1)
+            return false;
+        else
+            return isBalanced(root->left) && isBalanced(root->right);
+    }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data_source/exercises/中等/cpp/177.exercises/config.json → data/1.dailycode初阶/1.cpp/102.exercises/config.json

 {
-  "node_id": "dailycode-451470417dde4c61a764f65ac405267d",
+  "node_id": "dailycode-c8023cfe856c4678aa96956db32b5470",
   "keywords": [],
   "children": [],
   "keywords_must": [],

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "c0299f55bbee4aceb2c6c6ffc245db84",
+  "author": "csdn.net",
+  "keywords": "树,深度优先搜索,广度优先搜索,二叉树",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 二叉树的最小深度
+
+<p>给定一个二叉树，找出其最小深度。</p>
+
+<p>最小深度是从根节点到最近叶子节点的最短路径上的节点数量。</p>
+
+<p><strong>说明：</strong>叶子节点是指没有子节点的节点。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/12/ex_depth.jpg" style="width: 432px; height: 302px;" />
+<pre>
+<strong>输入：</strong>root = [3,9,20,null,null,15,7]
+<strong>输出：</strong>2
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>root = [2,null,3,null,4,null,5,null,6]
+<strong>输出：</strong>5
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>树中节点数的范围在 <code>[0, 10<sup>5</sup>]</code> 内</li>
+	<li><code>-1000 <= Node.val <= 1000</code></li>
+</ul>
+
+
+## template
+
+```cpp
+
+
+#include <bits/stdc++.h>
+using namespace std;
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    int minDepth(TreeNode *root)
+    {
+        if (!root)
+            return 0;
+        int left = minDepth(root->left);
+        int right = minDepth(root->right);
+        return (left && right) ? 1 + min(left, right) : 1 + left + right;
+    }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

data_source/exercises/中等/cpp/159.exercises/config.json → data/1.dailycode初阶/1.cpp/103.exercises/config.json

 {
-  "node_id": "dailycode-a38c1abb007e45c38ff0968c13fd28ac",
+  "node_id": "dailycode-fb518fd9317c4e229cee01ac248ce804",
   "keywords": [],
   "children": [],
   "keywords_must": [],

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "3e479d9fb28042b89d7b21dbd2029d20",
+  "author": "csdn.net",
+  "keywords": "树,深度优先搜索,二叉树",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 路径总和
+
+<p>给你二叉树的根节点 <code>root</code> 和一个表示目标和的整数 <code>targetSum</code> ，判断该树中是否存在 <strong>根节点到叶子节点</strong> 的路径，这条路径上所有节点值相加等于目标和 <code>targetSum</code> 。</p>
+
+<p><strong>叶子节点</strong> 是指没有子节点的节点。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/pathsum1.jpg" style="width: 500px; height: 356px;" />
+<pre>
+<strong>输入：</strong>root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
+<strong>输出：</strong>true
+</pre>
+
+<p><strong>示例 2：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/pathsum2.jpg" />
+<pre>
+<strong>输入：</strong>root = [1,2,3], targetSum = 5
+<strong>输出：</strong>false
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>root = [1,2], targetSum = 0
+<strong>输出：</strong>false
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>树中节点的数目在范围 <code>[0, 5000]</code> 内</li>
+	<li><code>-1000 <= Node.val <= 1000</code></li>
+	<li><code>-1000 <= targetSum <= 1000</code></li>
+</ul>
+
+
+## template
+
+```cpp
+
+#include <bits/stdc++.h>
+using namespace std;
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    bool hasPathSum(TreeNode *root, int sum)
+    {
+        bool flag = false;
+        backTrack(root, sum, flag);
+        return flag;
+    }
+
+    void backTrack(TreeNode *root, int sum, bool &flag)
+    {
+        if (!root)
+        {
+            return;
+        }
+
+        if (!root->left && !root->right)
+        {
+            sum -= root->val;
+            if (sum == 0)
+            {
+                flag = true;
+            }
+            sum += root->val;
+            return;
+        }
+
+        sum -= root->val;
+        backTrack(root->left, sum, flag);
+        backTrack(root->right, sum, flag);
+        sum += root->val;
+    }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "5f4adb247b224514bbb0d937491de500",
+  "author": "csdn.net",
+  "keywords": "数组,动态规划",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 杨辉三角
+
+<p>给定一个非负整数 <em><code>numRows</code>，</em>生成「杨辉三角」的前 <em><code>numRows</code> </em>行。</p>
+
+<p><small>在「杨辉三角」中，每个数是它左上方和右上方的数的和。</small></p>
+
+<p><img alt="" src="https://pic.leetcode-cn.com/1626927345-DZmfxB-PascalTriangleAnimated2.gif" /></p>
+
+<p> </p>
+
+<p><strong>示例 1:</strong></p>
+
+<pre>
+<strong>输入:</strong> numRows = 5
+<strong>输出:</strong> [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
+</pre>
+
+<p><strong>示例 2:</strong></p>
+
+<pre>
+<strong>输入:</strong> numRows = 1
+<strong>输出:</strong> [[1]]
+</pre>
+
+<p> </p>
+
+<p><strong>提示:</strong></p>
+
+<ul>
+	<li><code>1 <= numRows <= 30</code></li>
+</ul>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    vector<vector<int>> generate(int numRows)
+    {
+
+        if (numRows <= 0)
+        {
+            return {};
+        }
+        if (numRows == 1)
+        {
+            return {{1}};
+        }
+        if (numRows == 2)
+        {
+            return {{1}, {1, 1}};
+        }
+
+        vector<vector<int>> res = {{1}, {1, 1}};
+        vector<int> arr;
+        int row = 1;
+        while (row < numRows - 1)
+        {
+            arr.push_back(1);
+            for (int i = 0; i < res[row].size() - 1; i++)
+            {
+                int temp = 0;
+                temp = res[row][i] + res[row][i + 1];
+                arr.push_back(temp);
+            }
+            arr.push_back(1);
+            res.push_back(arr);
+            arr.clear();
+            row++;
+        }
+        return res;
+    }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "bbfbabf7e95e4c9b884d37ee321dfe98",
+  "author": "csdn.net",
+  "keywords": "数组,动态规划",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 杨辉三角 II
+
+<p>给定一个非负索引 <code>rowIndex</code>，返回「杨辉三角」的第 <code>rowIndex</code><em> </em>行。</p>
+
+<p><small>在「杨辉三角」中，每个数是它左上方和右上方的数的和。</small></p>
+
+<p><img alt="" src="https://pic.leetcode-cn.com/1626927345-DZmfxB-PascalTriangleAnimated2.gif" /></p>
+
+<p> </p>
+
+<p><strong>示例 1:</strong></p>
+
+<pre>
+<strong>输入:</strong> rowIndex = 3
+<strong>输出:</strong> [1,3,3,1]
+</pre>
+
+<p><strong>示例 2:</strong></p>
+
+<pre>
+<strong>输入:</strong> rowIndex = 0
+<strong>输出:</strong> [1]
+</pre>
+
+<p><strong>示例 3:</strong></p>
+
+<pre>
+<strong>输入:</strong> rowIndex = 1
+<strong>输出:</strong> [1,1]
+</pre>
+
+<p> </p>
+
+<p><strong>提示:</strong></p>
+
+<ul>
+	<li><code>0 <= rowIndex <= 33</code></li>
+</ul>
+
+<p> </p>
+
+<p><strong>进阶：</strong></p>
+
+<p>你可以优化你的算法到 <code><em>O</em>(<i>rowIndex</i>)</code> 空间复杂度吗？</p>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    vector<int> getRow(int rowIndex)
+    {
+        vector<int> res(rowIndex + 1, 1);
+        for (int i = 0; i < rowIndex + 1; ++i)
+        {
+            for (int j = i - 1; j > 0; --j)
+            {
+                res[j] = res[j] + res[j - 1];
+            }
+        }
+        return res;
+    }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "9e7555f4e1674542b7f3a4de8eb56e17",
+  "author": "csdn.net",
+  "keywords": "数组,动态规划",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 买卖股票的最佳时机
+
+<p>给定一个数组 <code>prices</code> ，它的第 <code>i</code> 个元素 <code>prices[i]</code> 表示一支给定股票第 <code>i</code> 天的价格。</p>
+
+<p>你只能选择 <strong>某一天</strong> 买入这只股票，并选择在 <strong>未来的某一个不同的日子</strong> 卖出该股票。设计一个算法来计算你所能获取的最大利润。</p>
+
+<p>返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 <code>0</code> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>[7,1,5,3,6,4]
+<strong>输出：</strong>5
+<strong>解释：</strong>在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
+     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>prices = [7,6,4,3,1]
+<strong>输出：</strong>0
+<strong>解释：</strong>在这种情况下, 没有交易完成, 所以最大利润为 0。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= prices.length <= 10<sup>5</sup></code></li>
+	<li><code>0 <= prices[i] <= 10<sup>4</sup></code></li>
+</ul>
+
+
+## template
+
+```cpp
+
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    int maxProfit(vector<int> &prices)
+    {
+        int profit = INT_MIN;
+        int buy = INT_MAX;
+        for (int i = 0; i < prices.size(); i++)
+        {
+            int temp = prices[i] - buy;
+            if (temp > profit)
+            {
+                profit = temp;
+            }
+            if (temp < 0)
+            {
+                buy = prices[i];
+            }
+        }
+        return (profit > 0) ? profit : 0;
+    }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "b91fef5ce7a146aabae6bd7bb2a99add",
+  "author": "csdn.net",
+  "keywords": "贪心,数组,动态规划",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 买卖股票的最佳时机 II
+
+<p>给定一个数组 <code>prices</code> ，其中 <code>prices[i]</code> 是一支给定股票第 <code>i</code> 天的价格。</p>
+
+<p>设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。</p>
+
+<p><strong>注意：</strong>你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。</p>
+
+<p> </p>
+
+<p><strong>示例 1:</strong></p>
+
+<pre>
+<strong>输入:</strong> prices = [7,1,5,3,6,4]
+<strong>输出:</strong> 7
+<strong>解释:</strong> 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
+     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
+</pre>
+
+<p><strong>示例 2:</strong></p>
+
+<pre>
+<strong>输入:</strong> prices = [1,2,3,4,5]
+<strong>输出:</strong> 4
+<strong>解释:</strong> 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
+     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
+</pre>
+
+<p><strong>示例 3:</strong></p>
+
+<pre>
+<strong>输入:</strong> prices = [7,6,4,3,1]
+<strong>输出:</strong> 0
+<strong>解释:</strong> 在这种情况下, 没有交易完成, 所以最大利润为 0。</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= prices.length <= 3 * 10<sup>4</sup></code></li>
+	<li><code>0 <= prices[i] <= 10<sup>4</sup></code></li>
+</ul>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    int maxProfit(vector<int> &prices)
+    {
+        if (prices.empty())
+            return 0;
+        int cnt = 0;
+        for (int i = 0; i < prices.size() - 1; ++i)
+        {
+            if (prices[i] < prices[i + 1])
+                cnt += prices[i + 1] - prices[i];
+        }
+        return cnt;
+    }
+};
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "b38a53d95a234b7db1ab99300bb7acc3",
+  "author": "csdn.net",
+  "keywords": "双指针,字符串",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 验证回文串
+
+<p>给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。</p>
+
+<p><strong>说明：</strong>本题中，我们将空字符串定义为有效的回文串。</p>
+
+<p> </p>
+
+<p><strong>示例 1:</strong></p>
+
+<pre>
+<strong>输入:</strong> "A man, a plan, a canal: Panama"
+<strong>输出:</strong> true
+<strong>解释：</strong>"amanaplanacanalpanama" 是回文串
+</pre>
+
+<p><strong>示例 2:</strong></p>
+
+<pre>
+<strong>输入:</strong> "race a car"
+<strong>输出:</strong> false
+<strong>解释：</strong>"raceacar" 不是回文串
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= s.length <= 2 * 10<sup>5</sup></code></li>
+	<li>字符串 <code>s</code> 由 ASCII 字符组成</li>
+</ul>
+
+
+## template
+
+```cpp
+
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    bool isPalindrome(string s)
+    {
+        int left = 0, right;
+        if ((right = s.size()) == 0)
+        {
+            return true;
+        }
+        while (left < right)
+        {
+            while (left < right && !isalnum(s[left]))
+            {
+                left++;
+            }
+            while (left < right && !isalnum(s[right]))
+            {
+                right--;
+            }
+            if (left < right)
+            {
+                if (tolower(s[left]) != tolower(s[right]))
+                {
+                    return false;
+                }
+            }
+            left++;
+            right--;
+        }
+        return true;
+    }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "d2339dc4d7f441a8b34f9e4b08c5c6f4",
+  "author": "csdn.net",
+  "keywords": "位运算,数组",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 只出现一次的数字
+
+<p>给定一个<strong>非空</strong>整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。</p>
+
+<p><strong>说明：</strong></p>
+
+<p>你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？</p>
+
+<p><strong>示例 1:</strong></p>
+
+<pre><strong>输入:</strong> [2,2,1]
+<strong>输出:</strong> 1
+</pre>
+
+<p><strong>示例&nbsp;2:</strong></p>
+
+<pre><strong>输入:</strong> [4,1,2,1,2]
+<strong>输出:</strong> 4</pre>
+
+
+## template
+
+```cpp
+
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    int singleNumber(vector<int> &nums)
+    {
+        int res = 0;
+        for (int i = 0; i < nums.size(); i++)
+        {
+            res ^= nums[i];
+        }
+        return res;
+    }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "3294f78b036849119b70d3638940a8d6",
+  "author": "csdn.net",
+  "keywords": "哈希表,链表,双指针",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 环形链表
+
+<p>给定一个链表，判断链表中是否有环。</p>
+
+<p>如果链表中有某个节点，可以通过连续跟踪 <code>next</code> 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 <code>pos</code> 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 <code>pos</code> 是 <code>-1</code>，则在该链表中没有环。<strong>注意：<code>pos</code> 不作为参数进行传递</strong>，仅仅是为了标识链表的实际情况。</p>
+
+<p>如果链表中存在环，则返回 <code>true</code> 。 否则，返回 <code>false</code> 。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>进阶：</strong></p>
+
+<p>你能用 <em>O(1)</em>（即，常量）内存解决此问题吗？</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist.png" style="height: 97px; width: 300px;"></p>
+
+<pre><strong>输入：</strong>head = [3,2,0,-4], pos = 1
+<strong>输出：</strong>true
+<strong>解释：</strong>链表中有一个环，其尾部连接到第二个节点。
+</pre>
+
+<p><strong>示例&nbsp;2：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist_test2.png" style="height: 74px; width: 141px;"></p>
+
+<pre><strong>输入：</strong>head = [1,2], pos = 0
+<strong>输出：</strong>true
+<strong>解释：</strong>链表中有一个环，其尾部连接到第一个节点。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist_test3.png" style="height: 45px; width: 45px;"></p>
+
+<pre><strong>输入：</strong>head = [1], pos = -1
+<strong>输出：</strong>false
+<strong>解释：</strong>链表中没有环。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>链表中节点的数目范围是 <code>[0, 10<sup>4</sup>]</code></li>
+	<li><code>-10<sup>5</sup> &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+	<li><code>pos</code> 为 <code>-1</code> 或者链表中的一个 <strong>有效索引</strong> 。</li>
+</ul>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+struct ListNode
+{
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+class Solution
+{
+public:
+    bool hasCycle(ListNode *head)
+    {
+
+        ListNode *faster = head;
+        ListNode *slower = head;
+
+        if (head == NULL)
+            return false;
+
+        while (faster != NULL && faster->next != NULL)
+        {
+            faster = faster->next->next;
+            slower = slower->next;
+            if (faster == slower)
+                return true;
+        }
+        return false;
+    }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "d171b0899a7d4fa9b685c5aa42d83779",
+  "author": "csdn.net",
+  "keywords": "栈,树,深度优先搜索,二叉树",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 二叉树的前序遍历
+
+<p>给你二叉树的根节点 <code>root</code> ，返回它节点值的 <strong>前序</strong><em> </em>遍历。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg" style="width: 202px; height: 324px;" />
+<pre>
+<strong>输入：</strong>root = [1,null,2,3]
+<strong>输出：</strong>[1,2,3]
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>root = []
+<strong>输出：</strong>[]
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>root = [1]
+<strong>输出：</strong>[1]
+</pre>
+
+<p><strong>示例 4：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_5.jpg" style="width: 202px; height: 202px;" />
+<pre>
+<strong>输入：</strong>root = [1,2]
+<strong>输出：</strong>[1,2]
+</pre>
+
+<p><strong>示例 5：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_4.jpg" style="width: 202px; height: 202px;" />
+<pre>
+<strong>输入：</strong>root = [1,null,2]
+<strong>输出：</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 <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+private:
+    void rec(TreeNode *root, vector<int> &ret)
+    {
+        if (root != NULL)
+        {
+            rec(root->right, ret);
+            rec(root->left, ret);
+            ret.push_back(root->val);
+        }
+    }
+
+public:
+    vector<int> postorderTraversal(TreeNode *root)
+    {
+        vector<int> ret;
+        rec(root, ret);
+        return ret;
+    }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "01609a836c924ff6beb0ecc2881f99ef",
+  "author": "csdn.net",
+  "keywords": "栈,树,深度优先搜索,二叉树",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 二叉树的后序遍历
+
+<p>给定一个二叉树，返回它的 <em>后序&nbsp;</em>遍历。</p>
+
+<p><strong>示例:</strong></p>
+
+<pre><strong>输入:</strong> [1,null,2,3]  
+   1
+    \
+     2
+    /
+   3 
+
+<strong>输出:</strong> [3,2,1]</pre>
+
+<p><strong>进阶:</strong>&nbsp;递归算法很简单，你可以通过迭代算法完成吗？</p>
+
+
+## template
+
+```cpp
+
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    vector<int> postorderTraversal(TreeNode *root)
+    {
+        dfs(root);
+        return temp;
+    }
+    void dfs(TreeNode *root)
+    {
+        if (root == NULL)
+            return;
+        dfs(root->left);
+        dfs(root->right);
+        temp.push_back(root->val);
+    }
+    vector<int> temp;
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

data_source/exercises/中等/cpp/177.exercises/solution.json → data/1.dailycode初阶/1.cpp/113.exercises/solution.json

 {
   "type": "code_options",
   "source": "solution.md",
-  "exercise_id": "423a11a1e52a42bfaf4c5664486742f3",
+  "exercise_id": "27b8c45d6f09499fac37e611062195b0",
   "author": "csdn.net",
-  "keywords": "数据库"
+  "keywords": "栈,设计",
+  "notebook_enable": true
 }
\ No newline at end of file

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

+# 最小栈
+
+<p>设计一个支持 <code>push</code> ，<code>pop</code> ，<code>top</code> 操作，并能在常数时间内检索到最小元素的栈。</p>
+
+<ul>
+	<li><code>push(x)</code> &mdash;&mdash; 将元素 x 推入栈中。</li>
+	<li><code>pop()</code>&nbsp;&mdash;&mdash; 删除栈顶的元素。</li>
+	<li><code>top()</code>&nbsp;&mdash;&mdash; 获取栈顶元素。</li>
+	<li><code>getMin()</code> &mdash;&mdash; 检索栈中的最小元素。</li>
+</ul>
+
+<p>&nbsp;</p>
+
+<p><strong>示例:</strong></p>
+
+<pre><strong>输入：</strong>
+[&quot;MinStack&quot;,&quot;push&quot;,&quot;push&quot;,&quot;push&quot;,&quot;getMin&quot;,&quot;pop&quot;,&quot;top&quot;,&quot;getMin&quot;]
+[[],[-2],[0],[-3],[],[],[],[]]
+
+<strong>输出：</strong>
+[null,null,null,null,-3,null,0,-2]
+
+<strong>解释：</strong>
+MinStack minStack = new MinStack();
+minStack.push(-2);
+minStack.push(0);
+minStack.push(-3);
+minStack.getMin();   --&gt; 返回 -3.
+minStack.pop();
+minStack.top();      --&gt; 返回 0.
+minStack.getMin();   --&gt; 返回 -2.
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>pop</code>、<code>top</code> 和 <code>getMin</code> 操作总是在 <strong>非空栈</strong> 上调用。</li>
+</ul>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class MinStack
+{
+public:
+    stack<int> s;
+    stack<int> min;
+    /** initialize your data structure here. */
+    MinStack()
+    {
+    }
+
+    void push(int x)
+    {
+        s.push(x);
+        if (min.empty() || x <= min.top())
+        {
+            min.push(x);
+        }
+    }
+
+    void pop()
+    {
+        if (s.top() == min.top())
+            min.pop();
+        s.pop();
+    }
+
+    int top()
+    {
+        return s.top();
+    }
+    int getMin()
+    {
+        return min.top();
+    }
+};
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "2450b377ecaa4e0a9dd4f7d682a4af21",
+  "author": "csdn.net",
+  "keywords": "哈希表,链表,双指针",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 相交链表
+
+<p>给你两个单链表的头节点 <code>headA</code> 和 <code>headB</code> ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 <code>null</code> 。</p>
+
+<p>图示两个链表在节点 <code>c1</code> 开始相交<strong>：</strong></p>
+
+<p><a href="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_statement.png" target="_blank"><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_statement.png" style="height: 130px; width: 400px;" /></a></p>
+
+<p>题目数据 <strong>保证</strong> 整个链式结构中不存在环。</p>
+
+<p><strong>注意</strong>，函数返回结果后，链表必须 <strong>保持其原始结构</strong> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<p><a href="https://assets.leetcode.com/uploads/2018/12/13/160_example_1.png" target="_blank"><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_example_1.png" style="height: 130px; width: 400px;" /></a></p>
+
+<pre>
+<strong>输入：</strong>intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
+<strong>输出：</strong>Intersected at '8'
+<strong>解释：</strong>相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
+从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
+在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<p><a href="https://assets.leetcode.com/uploads/2018/12/13/160_example_2.png" target="_blank"><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_example_2.png" style="height: 136px; width: 350px;" /></a></p>
+
+<pre>
+<strong>输入：</strong>intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
+<strong>输出：</strong>Intersected at '2'
+<strong>解释：</strong>相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
+从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
+在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<p><a href="https://assets.leetcode.com/uploads/2018/12/13/160_example_3.png" target="_blank"><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_example_3.png" style="height: 126px; width: 200px;" /></a></p>
+
+<pre>
+<strong>输入：</strong>intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
+<strong>输出：</strong>null
+<strong>解释：</strong>从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
+由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
+这两个链表不相交，因此返回 null 。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>listA</code> 中节点数目为 <code>m</code></li>
+	<li><code>listB</code> 中节点数目为 <code>n</code></li>
+	<li><code>0 <= m, n <= 3 * 10<sup>4</sup></code></li>
+	<li><code>1 <= Node.val <= 10<sup>5</sup></code></li>
+	<li><code>0 <= skipA <= m</code></li>
+	<li><code>0 <= skipB <= n</code></li>
+	<li>如果 <code>listA</code> 和 <code>listB</code> 没有交点，<code>intersectVal</code> 为 <code>0</code></li>
+	<li>如果 <code>listA</code> 和 <code>listB</code> 有交点，<code>intersectVal == listA[skipA + 1] == listB[skipB + 1]</code></li>
+</ul>
+
+<p> </p>
+
+<p><strong>进阶：</strong>你能否设计一个时间复杂度 <code>O(n)</code> 、仅用 <code>O(1)</code> 内存的解决方案？</p>
+
+
+## template
+
+```cpp
+
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB)
+    {
+
+        if (!headA || !headB)
+        {
+            return NULL;
+        }
+
+        ListNode *cur1 = headA;
+        ListNode *cur2 = headB;
+        while (cur1 != cur2)
+        {
+            cur1 = cur1 ? cur1->next : headB;
+            cur2 = cur2 ? cur2->next : headA;
+        }
+        return cur1;
+    }
+};
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "e15e9d7a6a034088b2384779c02275af",
+  "author": "csdn.net",
+  "keywords": "数组,双指针,二分查找",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 两数之和 II 
+
+<p>给定一个已按照<strong><em> </em>非递减顺序排列&nbsp; </strong>的整数数组&nbsp;<code>numbers</code> ，请你从数组中找出两个数满足相加之和等于目标数&nbsp;<code>target</code> 。</p>
+
+<p>函数应该以长度为 <code>2</code> 的整数数组的形式返回这两个数的下标值<em>。</em><code>numbers</code> 的下标 <strong>从 1 开始计数</strong> ，所以答案数组应当满足 <code>1 &lt;= answer[0] &lt; answer[1] &lt;= numbers.length</code> 。</p>
+
+<p>你可以假设每个输入 <strong>只对应唯一的答案</strong> ，而且你 <strong>不可以</strong> 重复使用相同的元素。</p>
+&nbsp;
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>numbers = [2,7,11,15], target = 9
+<strong>输出：</strong>[1,2]
+<strong>解释：</strong>2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>numbers = [2,3,4], target = 6
+<strong>输出：</strong>[1,3]
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>numbers = [-1,0], target = -1
+<strong>输出：</strong>[1,2]
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>2 &lt;= numbers.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>-1000 &lt;= numbers[i] &lt;= 1000</code></li>
+	<li><code>numbers</code> 按 <strong>非递减顺序</strong> 排列</li>
+	<li><code>-1000 &lt;= target &lt;= 1000</code></li>
+	<li><strong>仅存在一个有效答案</strong></li>
+</ul>
+
+
+## template
+
+```cpp
+
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    vector<int> twoSum(vector<int> &numbers, int target)
+    {
+        int low = 0, high = numbers.size() - 1;
+        while (low < high)
+        {
+            int sum = numbers[low] + numbers[high];
+            if (sum == target)
+            {
+                return {low + 1, high + 1};
+            }
+            if (sum < target)
+            {
+                ++low;
+            }
+            else
+            {
+                --high;
+            }
+        }
+        return {-1, -1};
+    }
+}
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "787031c1bf0b4f81b66999b3f4b42146",
+  "author": "csdn.net",
+  "keywords": "数学,字符串",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# Excel表列名称
+
+<p>给你一个整数 <code>columnNumber</code> ，返回它在 Excel 表中相对应的列名称。</p>
+
+<p>例如：</p>
+
+<pre>
+A -> 1
+B -> 2
+C -> 3
+...
+Z -> 26
+AA -> 27
+AB -> 28 
+...
+</pre>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>columnNumber = 1
+<strong>输出：</strong>"A"
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>columnNumber = 28
+<strong>输出：</strong>"AB"
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>columnNumber = 701
+<strong>输出：</strong>"ZY"
+</pre>
+
+<p><strong>示例 4：</strong></p>
+
+<pre>
+<strong>输入：</strong>columnNumber = 2147483647
+<strong>输出：</strong>"FXSHRXW"
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= columnNumber <= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    string convertToTitle(int n)
+    {
+        string res;
+        while (n)
+        {
+            int temp = n % 26;
+            n /= 26;
+            if (temp)
+                res.push_back('A' + temp - 1);
+            else
+            {
+                res.push_back('Z');
+                n--;
+            }
+        }
+        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/117.exercises/config.json

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "3063239bef37448aaddac259ac4b4649",
+  "author": "csdn.net",
+  "keywords": "数组,哈希表,分治,计数,排序",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 多数元素
+
+<p>给定一个大小为 <em>n </em>的数组，找到其中的多数元素。多数元素是指在数组中出现次数 <strong>大于</strong> <code>⌊ n/2 ⌋</code> 的元素。</p>
+
+<p>你可以假设数组是非空的，并且给定的数组总是存在多数元素。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>[3,2,3]
+<strong>输出：</strong>3</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>[2,2,1,1,1,2,2]
+<strong>输出：</strong>2
+</pre>
+
+<p> </p>
+
+<p><strong>进阶：</strong></p>
+
+<ul>
+	<li>尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。</li>
+</ul>
+
+
+## template
+
+```cpp
+
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    int majorityElement(vector<int> &nums)
+    {
+        unordered_map<int, int> counts;
+        int majority = 0, cnt = 0;
+        for (int num : nums)
+        {
+            ++counts[num];
+            if (counts[num] > cnt)
+            {
+                majority = num;
+                cnt = counts[num];
+            }
+        }
+        return majority;
+    }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "ba1063921dbe41418dee9ce903777741",
+  "author": "csdn.net",
+  "keywords": "数学,字符串",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# Excel表列序号
+
+<p>给你一个字符串&nbsp;<code>columnTitle</code> ，表示 Excel 表格中的列名称。返回该列名称对应的列序号。</p>
+
+<p>&nbsp;</p>
+
+<p>例如，</p>
+
+<pre>
+    A -&gt; 1
+    B -&gt; 2
+    C -&gt; 3
+    ...
+    Z -&gt; 26
+    AA -&gt; 27
+    AB -&gt; 28 
+    ...
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1:</strong></p>
+
+<pre>
+<strong>输入:</strong> columnTitle = "A"
+<strong>输出:</strong> 1
+</pre>
+
+<p><strong>示例&nbsp;2:</strong></p>
+
+<pre>
+<strong>输入: </strong>columnTitle = "AB"
+<strong>输出:</strong> 28
+</pre>
+
+<p><strong>示例&nbsp;3:</strong></p>
+
+<pre>
+<strong>输入: </strong>columnTitle = "ZY"
+<strong>输出:</strong> 701</pre>
+
+<p><strong>示例 4:</strong></p>
+
+<pre>
+<strong>输入: </strong>columnTitle = "FXSHRXW"
+<strong>输出: </strong>2147483647
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= columnTitle.length &lt;= 7</code></li>
+	<li><code>columnTitle</code> 仅由大写英文组成</li>
+	<li><code>columnTitle</code> 在范围 <code>["A", "FXSHRXW"]</code> 内</li>
+</ul>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    int titleToNumber(string s)
+    {
+
+        long num = 0;
+
+        for (int i = 0; i < s.size(); i++)
+        {
+            num = (num * 26) + (s[i] - 64);
+        }
+        return num;
+    }
+};
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

data_source/exercises/中等/cpp/161.exercises/solution.json → data/1.dailycode初阶/1.cpp/119.exercises/solution.json

 {
   "type": "code_options",
   "source": "solution.md",
-  "exercise_id": "99f8cccc1b934f6e92b94a26f0ccc34c",
+  "exercise_id": "090510ef86b14cb08933325e85f553dd",
   "author": "csdn.net",
-  "keywords": "双指针,字符串"
+  "keywords": "数学",
+  "notebook_enable": true
 }
\ No newline at end of file

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

+# 阶乘后的零
+
+<p>给定一个整数 <code>n</code> ，返回 <code>n!</code> 结果中尾随零的数量。</p>
+
+<p>提示&nbsp;<code>n! = n * (n - 1) * (n - 2) * ... * 3 * 2 * 1</code></p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 3
+<strong>输出：</strong>0
+<strong>解释：</strong>3! = 6 ，不含尾随 0
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 5
+<strong>输出：</strong>1
+<strong>解释：</strong>5! = 120 ，有一个尾随 0
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 0
+<strong>输出：</strong>0
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt;= 10<sup>4</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+
+<p><b>进阶：</b>你可以设计并实现对数时间复杂度的算法来解决此问题吗？</p>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    int trailingZeroes(int n)
+    {
+        int numOfZeros = 0;
+
+        while (n > 0)
+        {
+            numOfZeros += numOf5(n);
+            n--;
+        }
+
+        return numOfZeros;
+    }
+    int numOf5(int num)
+    {
+        int count = 0;
+        while ((num > 1) && (num % 5 == 0))
+        {
+            count++;
+            num /= 5;
+        }
+        return count;
+    }
+};
+
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "1bf7c916bc354627b654aff938342c0f",
+  "author": "csdn.net",
+  "keywords": "位运算,分治",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 颠倒二进制位
+
+<p>颠倒给定的 32 位无符号整数的二进制位。</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。</li>
+	<li>在 Java 中，编译器使用<a href="https://baike.baidu.com/item/二进制补码/5295284" target="_blank">二进制补码</a>记法来表示有符号整数。因此，在 <strong>示例 2</strong>&nbsp;中，输入表示有符号整数 <code>-3</code>，输出表示有符号整数 <code>-1073741825</code>。</li>
+</ul>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 00000010100101000001111010011100
+<strong>输出：</strong>964176192 (00111001011110000010100101000000)
+<strong>解释：</strong>输入的二进制串 <strong>00000010100101000001111010011100 </strong>表示无符号整数<strong> 43261596</strong><strong>，
+    </strong> 因此返回 964176192，其二进制表示形式为 <strong>00111001011110000010100101000000</strong>。</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 11111111111111111111111111111101
+<strong>输出：</strong>3221225471 (10111111111111111111111111111111)
+<strong>解释：</strong>输入的二进制串 <strong>11111111111111111111111111111101</strong> 表示无符号整数 4294967293，
+   &nbsp; 因此返回 3221225471 其二进制表示形式为 <strong>10111111111111111111111111111111 。</strong></pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>输入是一个长度为 <code>32</code> 的二进制字符串</li>
+</ul>
+
+<p>&nbsp;</p>
+
+<p><strong>进阶</strong>: 如果多次调用这个函数，你将如何优化你的算法？</p>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    uint32_t reverseBits(uint32_t n)
+    {
+        uint32_t res = 0;
+
+        for (int i = 0; i < 32; i++)
+        {
+            res <<= 1;
+            res |= n & 1;
+            n >>= 1;
+        }
+
+        return res;
+    }
+};
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

data_source/exercises/中等/cpp/159.exercises/solution.json → data/1.dailycode初阶/1.cpp/121.exercises/solution.json

 {
   "type": "code_options",
   "source": "solution.md",
-  "exercise_id": "12b418be49d0440d80d23d1498d77aea",
+  "exercise_id": "e9ed6c10cc8046fdb9c2f303c9827372",
   "author": "csdn.net",
-  "keywords": "哈希表,字符串,滑动窗口"
+  "keywords": "位运算",
+  "notebook_enable": true
 }
\ No newline at end of file

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

+# 位1的个数
+
+<p>编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为<a href="https://baike.baidu.com/item/%E6%B1%89%E6%98%8E%E9%87%8D%E9%87%8F" target="_blank">汉明重量</a>）。</p>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。</li>
+	<li>在 Java 中，编译器使用<a href="https://baike.baidu.com/item/二进制补码/5295284" target="_blank">二进制补码</a>记法来表示有符号整数。因此，在上面的 <strong>示例 3</strong> 中，输入表示有符号整数 <code>-3</code>。</li>
+</ul>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>00000000000000000000000000001011
+<strong>输出：</strong>3
+<strong>解释：</strong>输入的二进制串 <code><strong>00000000000000000000000000001011</strong> 中，共有三位为 '1'。</code>
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>00000000000000000000000010000000
+<strong>输出：</strong>1
+<strong>解释：</strong>输入的二进制串 <strong>00000000000000000000000010000000</strong> 中，共有一位为 '1'。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>11111111111111111111111111111101
+<strong>输出：</strong>31
+<strong>解释：</strong>输入的二进制串 <strong>11111111111111111111111111111101</strong> 中，共有 31 位为 '1'。</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>输入必须是长度为 <code>32</code> 的 <strong>二进制串</strong> 。</li>
+</ul>
+
+<ul>
+</ul>
+
+<p> </p>
+
+<p><strong>进阶</strong>：</p>
+
+<ul>
+	<li>如果多次调用这个函数，你将如何优化你的算法？</li>
+</ul>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    int hammingWeight(uint32_t n)
+    {
+        int count = 0;
+        uint32_t res = 1;
+        for (int i = 0; i < 32; i++)
+        {
+            if (res & n)
+            {
+                count++;
+            }
+            n >>= 1;
+        }
+        return count;
+    }
+};
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "dd2a5b9e9ed849f5b905fbbd20b230ea",
+  "author": "csdn.net",
+  "keywords": "哈希表,数学,双指针",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 快乐数
+
+<p>编写一个算法来判断一个数 <code>n</code> 是不是快乐数。</p>
+
+<p>「快乐数」定义为：</p>
+
+<ul>
+	<li>对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。</li>
+	<li>然后重复这个过程直到这个数变为 1，也可能是 <strong>无限循环</strong> 但始终变不到 1。</li>
+	<li>如果 <strong>可以变为</strong>  1，那么这个数就是快乐数。</li>
+</ul>
+
+<p>如果 <code>n</code> 是快乐数就返回 <code>true</code> ；不是，则返回 <code>false</code> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>19
+<strong>输出：</strong>true
+<strong>解释：
+</strong>1<sup>2</sup> + 9<sup>2</sup> = 82
+8<sup>2</sup> + 2<sup>2</sup> = 68
+6<sup>2</sup> + 8<sup>2</sup> = 100
+1<sup>2</sup> + 0<sup>2</sup> + 0<sup>2</sup> = 1
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 2
+<strong>输出：</strong>false
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= n <= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+
+## template
+
+```cpp
+
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    bool isHappy(int n)
+    {
+        set<int> s;
+        while (n != 1)
+        {
+            int t = 0;
+            while (n)
+            {
+                t += (n % 10) * (n % 10);
+                n /= 10;
+            }
+
+            int size = s.size();
+            s.insert(t);
+            if (size == s.size())
+                return false;
+            n = t;
+        }
+        return true;
+    }
+};
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "764671b466ae41c7918438e006b78d38",
+  "author": "csdn.net",
+  "keywords": "递归,链表",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 移除链表元素
+
+给你一个链表的头节点 <code>head</code> 和一个整数 <code>val</code> ，请你删除链表中所有满足 <code>Node.val == val</code> 的节点，并返回 <strong>新的头节点</strong> 。
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/06/removelinked-list.jpg" style="width: 500px; height: 142px;" />
+<pre>
+<strong>输入：</strong>head = [1,2,6,3,4,5,6], val = 6
+<strong>输出：</strong>[1,2,3,4,5]
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>head = [], val = 1
+<strong>输出：</strong>[]
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>head = [7,7,7,7], val = 7
+<strong>输出：</strong>[]
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>列表中的节点数目在范围 <code>[0, 10<sup>4</sup>]</code> 内</li>
+	<li><code>1 <= Node.val <= 50</code></li>
+	<li><code>0 <= val <= 50</code></li>
+</ul>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+struct ListNode
+{
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+class Solution
+{
+public:
+    ListNode *removeElements(ListNode *head, int val)
+    {
+        ListNode *dumynode = new ListNode(0);
+        dumynode->next = head;
+        ListNode *fast = dumynode->next;
+        ListNode *slow = dumynode;
+        while (fast != NULL)
+        {
+            if (fast->val == val)
+            {
+                slow->next = slow->next->next;
+            }
+            else
+            {
+                slow = slow->next;
+            }
+            fast = fast->next;
+        }
+        ListNode *ret = dumynode->next;
+        delete dumynode;
+        return ret;
+    }
+};
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "27936a1703b94c82bcc9f781c9194893",
+  "author": "csdn.net",
+  "keywords": "数组,数学,枚举,数论",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 计数质数
+
+<p>统计所有小于非负整数&nbsp;<em><code>n</code>&nbsp;</em>的质数的数量。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>n = 10
+<strong>输出：</strong>4
+<strong>解释：</strong>小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>n = 0
+<strong>输出：</strong>0
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>n = 1
+<strong>输出</strong>：0
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt;= 5 * 10<sup>6</sup></code></li>
+</ul>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    int countPrimes(int n)
+    {
+        vector<bool> primesMap(n, true);
+        int count = 0;
+        for (int i = 2; i < n; i++)
+        {
+            if (primesMap[i])
+            {
+                count++;
+                for (int j = 2 * i; j < n; j += i)
+                {
+                    primesMap[j] = false;
+                }
+            }
+        }
+        return count;
+    }
+};
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "a240d4ffd705492787e87d9cf88bcab4",
+  "author": "csdn.net",
+  "keywords": "哈希表,字符串",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 同构字符串
+
+<p>给定两个字符串 <em><strong>s </strong></em>和 <strong><em>t</em></strong>，判断它们是否是同构的。</p>
+
+<p>如果 <em><strong>s </strong></em>中的字符可以按某种映射关系替换得到 <strong><em>t </em></strong>，那么这两个字符串是同构的。</p>
+
+<p>每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。</p>
+
+<p> </p>
+
+<p><strong>示例 1:</strong></p>
+
+<pre>
+<strong>输入：</strong><strong><em>s</em></strong> = <code>"egg", </code><strong><em>t = </em></strong><code>"add"</code>
+<strong>输出：</strong>true
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong><strong><em>s</em></strong> = <code>"foo", </code><strong><em>t = </em></strong><code>"bar"</code>
+<strong>输出：</strong>false</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong><strong><em>s</em></strong> = <code>"paper", </code><strong><em>t = </em></strong><code>"title"</code>
+<strong>输出：</strong>true</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>可以假设 <em><strong>s </strong></em>和 <strong><em>t </em></strong>长度相同。</li>
+</ul>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    bool isIsomorphic(string s, string t)
+    {
+        vector<int> m(128, -1);
+        for (int i = 0; i < s.size(); ++i)
+        {
+            if (m[s[i]] != -1)
+            {
+                if (m[s[i]] != t[i])
+                    return false;
+            }
+            else
+            {
+                for (auto v : m)
+                {
+                    if (v == t[i])
+                        return false;
+                }
+                m[s[i]] = t[i];
+            }
+        }
+        return true;
+    }
+};
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "d26956dec2844546a98f1ea107b00a65",
+  "author": "csdn.net",
+  "keywords": "递归,链表",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 反转链表
+
+给你单链表的头节点 <code>head</code> ，请你反转链表，并返回反转后的链表。
+<div class="original__bRMd">
+<div>
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/rev1ex1.jpg" style="width: 542px; height: 222px;" />
+<pre>
+<strong>输入：</strong>head = [1,2,3,4,5]
+<strong>输出：</strong>[5,4,3,2,1]
+</pre>
+
+<p><strong>示例 2：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/rev1ex2.jpg" style="width: 182px; height: 222px;" />
+<pre>
+<strong>输入：</strong>head = [1,2]
+<strong>输出：</strong>[2,1]
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>head = []
+<strong>输出：</strong>[]
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>链表中节点的数目范围是 <code>[0, 5000]</code></li>
+	<li><code>-5000 <= Node.val <= 5000</code></li>
+</ul>
+
+<p> </p>
+
+<p><strong>进阶：</strong>链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？</p>
+</div>
+</div>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+struct ListNode
+{
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+class Solution
+{
+public:
+    ListNode *reverseList(ListNode *head)
+    {
+        if (head == NULL)
+            return NULL;
+        ListNode *node = NULL;
+        ListNode *temp = head;
+        ListNode *temp1 = head;
+        while (true)
+        {
+            if (temp->next == NULL)
+            {
+                temp1 = temp;
+                temp1->next = node;
+                break;
+            }
+            temp1 = temp;
+            temp = temp->next;
+            temp1->next = node;
+            node = temp1;
+        }
+        return temp1;
+    }
+};
+
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "c1b8804fd7a14cef8cd5f20e0f4ff762",
+  "author": "csdn.net",
+  "keywords": "数组,哈希表,排序",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 存在重复元素
+
+<p>给定一个整数数组，判断是否存在重复元素。</p>
+
+<p>如果存在一值在数组中出现至少两次，函数返回 <code>true</code> 。如果数组中每个元素都不相同，则返回 <code>false</code> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1:</strong></p>
+
+<pre>
+<strong>输入:</strong> [1,2,3,1]
+<strong>输出:</strong> true</pre>
+
+<p><strong>示例 2:</strong></p>
+
+<pre>
+<strong>输入: </strong>[1,2,3,4]
+<strong>输出:</strong> false</pre>
+
+<p><strong>示例 3:</strong></p>
+
+<pre>
+<strong>输入: </strong>[1,1,1,3,3,4,3,2,4,2]
+<strong>输出:</strong> true</pre>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    bool containsDuplicate(vector<int> &nums)
+    {
+        if (nums.empty())
+        {
+            return false;
+        }
+        sort(nums.begin(), nums.begin() + nums.size());
+        for (int i = 0; i < nums.size() - 1; i++)
+        {
+            if (nums[i] == nums[i + 1])
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+};
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "243066531cd64f568c3a8386611c0089",
+  "author": "csdn.net",
+  "keywords": "数组,哈希表,滑动窗口",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 存在重复元素 II
+
+<p>给定一个整数数组和一个整数&nbsp;<em>k</em>，判断数组中是否存在两个不同的索引<em>&nbsp;i</em>&nbsp;和<em>&nbsp;j</em>，使得&nbsp;<strong>nums [i] = nums [j]</strong>，并且 <em>i</em> 和 <em>j</em>&nbsp;的差的 <strong>绝对值</strong> 至多为 <em>k</em>。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例&nbsp;1:</strong></p>
+
+<pre><strong>输入:</strong> nums = [1,2,3,1], k<em> </em>= 3
+<strong>输出:</strong> true</pre>
+
+<p><strong>示例 2:</strong></p>
+
+<pre><strong>输入: </strong>nums = [1,0,1,1], k<em> </em>=<em> </em>1
+<strong>输出:</strong> true</pre>
+
+<p><strong>示例 3:</strong></p>
+
+<pre><strong>输入: </strong>nums = [1,2,3,1,2,3], k<em> </em>=<em> </em>2
+<strong>输出:</strong> false</pre>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    bool containsNearbyDuplicate(vector<int> &nums, int k)
+    {
+        int n = nums.size(), idx = 0;
+        unordered_map<int, int> nmap;
+        for (int i = 0; i < n; ++i)
+        {
+            auto iter = nmap.find(nums[i]);
+            if (iter != nmap.end())
+            {
+                if (i - iter->second <= k)
+                    return true;
+                else
+                    iter->second = i;
+            }
+            else
+                nmap[nums[i]] = i;
+        }
+        return false;
+    }
+};
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "86948c5e7a8a44ce9a4c9acc737a3770",
+  "author": "csdn.net",
+  "keywords": "栈,设计,队列",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 用队列实现栈
+
+<p>请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（<code>push</code>、<code>top</code>、<code>pop</code> 和 <code>empty</code>）。</p>
+
+<p>实现 <code>MyStack</code> 类：</p>
+
+<ul>
+	<li><code>void push(int x)</code> 将元素 x 压入栈顶。</li>
+	<li><code>int pop()</code> 移除并返回栈顶元素。</li>
+	<li><code>int top()</code> 返回栈顶元素。</li>
+	<li><code>boolean empty()</code> 如果栈是空的，返回 <code>true</code> ；否则，返回 <code>false</code> 。</li>
+</ul>
+
+<p> </p>
+
+<p><strong>注意：</strong></p>
+
+<ul>
+	<li>你只能使用队列的基本操作 —— 也就是 <code>push to back</code>、<code>peek/pop from front</code>、<code>size</code> 和 <code>is empty</code> 这些操作。</li>
+	<li>你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。</li>
+</ul>
+
+<p> </p>
+
+<p><strong>示例：</strong></p>
+
+<pre>
+<strong>输入：</strong>
+["MyStack", "push", "push", "top", "pop", "empty"]
+[[], [1], [2], [], [], []]
+<strong>输出：</strong>
+[null, null, null, 2, 2, false]
+
+<strong>解释：</strong>
+MyStack myStack = new MyStack();
+myStack.push(1);
+myStack.push(2);
+myStack.top(); // 返回 2
+myStack.pop(); // 返回 2
+myStack.empty(); // 返回 False
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= x <= 9</code></li>
+	<li>最多调用<code>100</code> 次 <code>push</code>、<code>pop</code>、<code>top</code> 和 <code>empty</code></li>
+	<li>每次调用 <code>pop</code> 和 <code>top</code> 都保证栈不为空</li>
+</ul>
+
+<p> </p>
+
+<p><strong>进阶：</strong>你能否实现每种操作的均摊时间复杂度为 <code>O(1)</code> 的栈？换句话说，执行 <code>n</code> 个操作的总时间复杂度 <code>O(n)</code> ，尽管其中某个操作可能需要比其他操作更长的时间。你可以使用两个以上的队列。</p>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class MyStack
+{
+public:
+    MyStack()
+    {
+    }
+    void push(int x)
+    {
+        std::queue<int> temp_queue;
+        temp_queue.push(x);
+        while (!_data.empty())
+        {
+            temp_queue.push(_data.front());
+            _data.pop();
+        }
+        while (!temp_queue.empty())
+        {
+            _data.push(temp_queue.front());
+            temp_queue.pop();
+        }
+    }
+    int pop()
+    {
+        int x = _data.front();
+        _data.pop();
+        return x;
+    }
+    int top()
+    {
+        return _data.front();
+    }
+    bool empty()
+    {
+        return _data.empty();
+    }
+
+private:
+    std::queue<int> _data;
+};
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "68c7ad63c6ac42af89a763d04013e0f2",
+  "author": "csdn.net",
+  "keywords": "树,深度优先搜索,广度优先搜索,二叉树",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 翻转二叉树
+
+<p>翻转一棵二叉树。</p>
+
+<p><strong>示例：</strong></p>
+
+<p>输入：</p>
+
+<pre>     4
+   /   \
+  2     7
+ / \   / \
+1   3 6   9</pre>
+
+<p>输出：</p>
+
+<pre>     4
+   /   \
+  7     2
+ / \   / \
+9   6 3   1</pre>
+
+<p><strong>备注:</strong><br>
+这个问题是受到 <a href="https://twitter.com/mxcl" target="_blank">Max Howell </a>的 <a href="https://twitter.com/mxcl/status/608682016205344768" target="_blank">原问题</a> 启发的 ：</p>
+
+<blockquote>谷歌：我们90％的工程师使用您编写的软件(Homebrew)，但是您却无法在面试时在白板上写出翻转二叉树这道题，这太糟糕了。</blockquote>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    TreeNode *invertTree(TreeNode *root)
+    {
+        if (!root)
+        {
+            return root;
+        }
+        TreeNode *temp = root->left;
+        root->left = invertTree(root->right);
+        root->right = invertTree(temp);
+        return root;
+    }
+};
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

data_source/exercises/中等/cpp/156.exercises/solution.json → data/1.dailycode初阶/1.cpp/131.exercises/solution.json

 {
   "type": "code_options",
   "source": "solution.md",
-  "exercise_id": "d61ff566c89342b888c5df90a0fa5007",
+  "exercise_id": "79ea6f8b6f134986bb083e68baeb4266",
   "author": "csdn.net",
-  "keywords": "树,深度优先搜索,二叉树"
+  "keywords": "数组",
+  "notebook_enable": true
 }
\ No newline at end of file

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

+# 汇总区间
+
+<p>给定一个无重复元素的有序整数数组 <code>nums</code> 。</p>
+
+<p>返回 <strong>恰好覆盖数组中所有数字</strong> 的 <strong>最小有序</strong> 区间范围列表。也就是说，<code>nums</code> 的每个元素都恰好被某个区间范围所覆盖，并且不存在属于某个范围但不属于 <code>nums</code> 的数字 <code>x</code> 。</p>
+
+<p>列表中的每个区间范围 <code>[a,b]</code> 应该按如下格式输出：</p>
+
+<ul>
+	<li><code>"a->b"</code> ，如果 <code>a != b</code></li>
+	<li><code>"a"</code> ，如果 <code>a == b</code></li>
+</ul>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [0,1,2,4,5,7]
+<strong>输出：</strong>["0->2","4->5","7"]
+<strong>解释：</strong>区间范围是：
+[0,2] --> "0->2"
+[4,5] --> "4->5"
+[7,7] --> "7"
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [0,2,3,4,6,8,9]
+<strong>输出：</strong>["0","2->4","6","8->9"]
+<strong>解释：</strong>区间范围是：
+[0,0] --> "0"
+[2,4] --> "2->4"
+[6,6] --> "6"
+[8,9] --> "8->9"
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = []
+<strong>输出：</strong>[]
+</pre>
+
+<p><strong>示例 4：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [-1]
+<strong>输出：</strong>["-1"]
+</pre>
+
+<p><strong>示例 5：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [0]
+<strong>输出：</strong>["0"]
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>0 <= nums.length <= 20</code></li>
+	<li><code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code></li>
+	<li><code>nums</code> 中的所有值都 <strong>互不相同</strong></li>
+	<li><code>nums</code> 按升序排列</li>
+</ul>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    vector<string> summaryRanges(vector<int> &nums)
+    {
+        int n = nums.size();
+        vector<string> ans;
+        int i = 0;
+        while (i < n)
+        {
+            int j = i;
+            while (j + 1 < n && nums[j + 1] == nums[j] + 1)
+                j++;
+            if (i == j)
+                ans.push_back(to_string(nums[i]));
+            else
+                ans.push_back(to_string(nums[i]) + "->" + to_string(nums[j]));
+            i = j + 1;
+        }
+        return ans;
+    }
+};
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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

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

+{
+  "type": "code_options",
+  "source": "solution.md",
+  "exercise_id": "4ca1d7d6fdc3440390e82ed46d4bed70",
+  "author": "csdn.net",
+  "keywords": "位运算,递归,数学",
+  "notebook_enable": true
+}
\ No newline at end of file

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

+# 2 的幂
+
+<p>给你一个整数 <code>n</code>，请你判断该整数是否是 2 的幂次方。如果是，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
+
+<p>如果存在一个整数 <code>x</code> 使得 <code>n == 2<sup>x</sup></code> ，则认为 <code>n</code> 是 2 的幂次方。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 1
+<strong>输出：</strong>true
+<strong>解释：</strong>2<sup>0</sup> = 1
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 16
+<strong>输出：</strong>true
+<strong>解释：</strong>2<sup>4</sup> = 16
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 3
+<strong>输出：</strong>false
+</pre>
+
+<p><strong>示例 4：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 4
+<strong>输出：</strong>true
+</pre>
+
+<p><strong>示例 5：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 5
+<strong>输出：</strong>false
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+<p> </p>
+
+<p><strong>进阶：</strong>你能够不使用循环/递归解决此问题吗？</p>
+
+
+## template
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    bool isPowerOfTwo(int n)
+    {
+        int cur = 0;
+        for (int i = 0; i < 31; i++)
+        {
+            cur += (n >> i) & 1;
+        }
+        return n > 0 && cur == 1;
+    }
+};
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
\ No newline at end of file

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

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