optimize exercises

data/1.dailycode初阶/3.python/1.exercises/solution.md

@@ -20,7 +20,7 @@ for i in range(n,n+1):
 	if i % 2 == 0:
 		for k in range(2, i):
 			if a(k) == 1 and a(i - k) == 1:
-				________________
+				________________;
 ```
 
 ## template

data/1.dailycode初阶/3.python/2.exercises/solution.md

@@ -8,7 +8,7 @@
 n = int(input("输入数字："))
 factor = [n]   
 num = 1
-__________________
+__________________;
 print(factor)
 m = [str(i) for i in factor]
 count4 = 0

data/1.dailycode初阶/3.python/3.exercises/solution.md

@@ -12,7 +12,7 @@ K=0
 for i in range(1,N+1):
 	x,y=random(),random()
 	dist =sqrt(x**2+y**2)
-	_____________________
+	_____________________;
 pi=4*(K/N)	
 print("圆周率值：{}".format(pi))
 ```

data/1.dailycode初阶/3.python/4.exercises/solution.md

@@ -41,7 +41,7 @@ x2 = x1.split(",")
 a = []
 b = []
 for i in x2:
-	______________
+	______________;
 if a == []:
 	print("NONE")
 else:

data/2.dailycode中阶/1.cpp/22.exercises/solution.md

@@ -26,7 +26,7 @@ int main()
     {
         for (int j = 0; j < N - i; j++)
             printf(" ");
-        ______________________
+        ______________________;
         printf("\n");
     }
     return 0;

data/2.dailycode中阶/1.cpp/23.exercises/solution.md

@@ -29,7 +29,7 @@ int main()
 		return 0;
 	}
     int *a = (int *)malloc(sizeof(int) * n);
-    __________________
+    __________________;
     scanf("%d", &m);
     if (m < 0 || m >= n)
     {

data/2.dailycode中阶/1.cpp/24.exercises/solution.md

@@ -12,7 +12,7 @@ void funShift(int m, char *p, int n)
     char c;
     for (int j = 0; j < m; j++)
     {
-		_____________________
+		_____________________;
     }
 }
 int main()

data/2.dailycode中阶/1.cpp/25.exercises/solution.md

@@ -44,7 +44,7 @@ int main()
     sum = 0;
     while (a < n)
     {
-        __________________
+        __________________;
         if (j == i)
         {
             sum += i;

data/2.dailycode中阶/1.cpp/26.exercises/solution.md

@@ -22,7 +22,7 @@ int fun(string str)
     int score = 0;
     for (int i = 0; i < str.length(); i++)
     {
-        _____________________
+        _____________________;
     }
     if (index == -1)
     {

data/2.dailycode中阶/1.cpp/27.exercises/solution.md

@@ -40,7 +40,7 @@ double sin(double x)
 {
     int i = 0;
     double result = 0, n = 0;
-    ____________________
+    ____________________;
     return result;
 }
 double nResult(double x, double n)

data/2.dailycode中阶/1.cpp/28.exercises/solution.md

@@ -20,7 +20,7 @@ int main()
         }
         break;
     }
-    __________________
+    __________________;
     printf("sum=%d\n", sum);
     return 0;
 }

data/2.dailycode中阶/1.cpp/29.exercises/solution.md

@@ -37,7 +37,7 @@ private:
 		{
 			return;
 		}
-		_____________________
+		_____________________;
 	}
 };
 ```

data/2.dailycode中阶/1.cpp/30.exercises/solution.md

@@ -23,7 +23,7 @@ private:
 		res.push_back(stack);
 		for (int i = start; i < nums.size(); i++)
 		{
-			______________
+			______________;
 		}
 	}
 };

data/2.dailycode中阶/1.cpp/31.exercises/solution.md

@@ -41,7 +41,7 @@ static int uniquePaths(int m, int n)
 	{
 		for (col = 1; col < m; col++)
 		{
-			______________________________
+			______________________________;
 		}
 	}
 	return grids[m * n - 1];

data/2.dailycode中阶/1.cpp/32.exercises/solution.md

@@ -29,7 +29,7 @@ public:
         }
         for ( auto& it : str[k] ) {
             ans.push_back( it );
-            _____________________
+            _____________________;
             ans.pop_back();
         }
     }

data/2.dailycode中阶/1.cpp/33.exercises/solution.md

@@ -69,7 +69,7 @@ static struct TreeNode *dfs(int low, int high, int *count)
 		for (i = low; i <= high; i++)
 		{
 			int left_cnt, right_cnt;
-			________________________________
+			________________________________;
 			if (left_cnt == 0)
 				left_cnt = 1;
 			if (right_cnt == 0)

data/2.dailycode中阶/1.cpp/34.exercises/solution.md

@@ -128,7 +128,7 @@ public static int myAtoi(String str) {
         if (base > Integer.MAX_VALUE / 10 || (base == Integer.MAX_VALUE / 10 && str.charAt(i) - '0' > 7)) {
             return (sign == 1) ? Integer.MAX_VALUE : Integer.MIN_VALUE;
         }
-        ____________________
+        ____________________;
     }
     return base * sign;
 }

data/2.dailycode中阶/1.cpp/35.exercises/solution.md

@@ -44,7 +44,7 @@ public:
 		{
 			for (int j = 0; j < i; j++)
 			{
-				___________________
+				___________________;
 			}
 		}
 		return sum[n];

data/2.dailycode中阶/1.cpp/36.exercises/solution.md

@@ -56,7 +56,7 @@ int **insert(int **intervals, int intervalsSize, int *intervalsColSize, int *new
 		if (tmp[i * 2] > results[len][1])
 		{
 			len++;
-			________________________
+			________________________;
 		}
 		else if (tmp[i * 2 + 1] > results[len][1])
 		{

data/2.dailycode中阶/1.cpp/37.exercises/solution.md

@@ -26,7 +26,7 @@ public:
 				{
 					if (k > j + 1 && nums[k] == nums[k - 1])
 						continue;
-					_____________________________
+					_____________________________;
 					if (k >= l)
 					{
 						break;

data/2.dailycode中阶/1.cpp/38.exercises/solution.md

@@ -90,7 +90,7 @@ static void parse(char *input, char *output)
 			n += count % 10;
 			count /= 10;
 		}
-		____________________
+		____________________;
 		*q++ = p[0];
 		p++;
 	}

data/2.dailycode中阶/1.cpp/39.exercises/solution.md

@@ -36,7 +36,7 @@ public:
 		ListNode *prev = &dummy;
 		ListNode *p = head;
 		k = k % len;
-		_______________________
+		_______________________;
 		if (p != nullptr)
 		{
 			prev->next = tail->next;

data/2.dailycode中阶/1.cpp/40.exercises/solution.md

@@ -32,7 +32,7 @@ private:
 			for (int i = start; i <= n; i++)
 			{
 				stack.push_back(i);
-				_____________________
+				_____________________;
 				stack.pop_back();
 			}
 		}

data/2.dailycode中阶/1.cpp/41.exercises/solution.md

@@ -24,7 +24,7 @@ public:
 		lc--;
 		if (lc > rc)
 		{
-			_________________
+			_________________;
 		}
 	}
 	vector<string> generateParenthesis(int n)

data/2.dailycode中阶/1.cpp/42.exercises/solution.md

@@ -19,7 +19,7 @@ public:
 			for (int j = low; j < high; j++)
 			{
 				int tmp = matrix[i][j];
-				_________________________
+				_________________________;
 			}
 		}
 	}

data/2.dailycode中阶/1.cpp/43.exercises/solution.md

@@ -15,7 +15,7 @@ public:
         for (int i = 0, j = height.size() - 1; i < j;)
         {
             temp = min(height[i], height[j]) * (j - i);
-            ______________________
+            ______________________;
         }
         return ret;
     }

data/2.dailycode中阶/1.cpp/44.exercises/solution.md

@@ -38,7 +38,7 @@ static void dfs(char *s, int start, char *stack, int num, char **results, int *c
 			for (j = 0; j < num; j++)
 			{
 				char *q = stack + j * WIDTH;
-				______________________
+				______________________;
 			}
 			(*count)++;
 		}

data/2.dailycode中阶/1.cpp/45.exercises/solution.md

@@ -22,7 +22,7 @@ int *grayCode(int n, int *returnSize)
 	}
 	int i, count = 1 << n;
 	int *codes = malloc(count * sizeof(int));
-	_________________
+	_________________;
 	return codes;
 }
 int main(int argc, char **argv)

data/2.dailycode中阶/1.cpp/46.exercises/solution.md

@@ -24,7 +24,7 @@ public:
 		if (i >= 0)
 		{
 			int j = nums.size() - 1;
-			________________________
+			________________________;
 			swap(nums.begin() + i, nums.begin() + j);
 		}
 		reverse(nums.begin() + i + 1, nums.end());

data/2.dailycode中阶/1.cpp/47.exercises/solution.md

@@ -28,7 +28,7 @@ private:
 			if (last != nums[i])
 			{
 				stack.push_back(nums[i]);
-				____________________
+				____________________;
 				stack.pop_back();
 			}
 			last = nums[i];

data/2.dailycode中阶/1.cpp/48.exercises/solution.md

@@ -77,7 +77,7 @@ static char *simplifyPath(char *path)
 	{
 		for (i = 0; i < depth; i++)
 		{
-			____________________
+			____________________;
 		}
 	}
 	*q = '\0';

data/2.dailycode中阶/1.cpp/49.exercises/solution.md

@@ -34,7 +34,7 @@ struct ListNode *addTwoNumbers(struct ListNode *l1, struct ListNode *l2)
 		pp->next = p = q;
 		qp->next = NULL;
 	}
-	____________________
+	____________________;
 	if (carry)
 	{
 		struct ListNode *n = (struct ListNode *)malloc(sizeof(struct ListNode));

data/2.dailycode中阶/1.cpp/50.exercises/solution.md

@@ -31,7 +31,7 @@ struct ListNode *partition(struct ListNode *head, int x)
 	{
 		if (p->val < x)
 		{
-			__________________
+			__________________;
 		}
 		else
 		{

data/2.dailycode中阶/1.cpp/51.exercises/solution.md

@@ -100,7 +100,7 @@ char *intToRoman(int num)
 	int i = 0;
 	while (num)
 	{
-        ______________
+        ______________;
 		else
 		{
 			i++;

data/2.dailycode中阶/1.cpp/52.exercises/solution.md

@@ -32,7 +32,7 @@ private:
 			{
 				if (!used[i])
 				{
-					_____________________
+					_____________________;
 					stack.push_back(nums[i]);
 					used[i] = true;
 					dfs(nums, used, res);

data/2.dailycode中阶/1.cpp/53.exercises/solution.md

@@ -14,7 +14,7 @@ int lengthOfLongestSubstring(char *s)
 	memset(hset, 0, sizeof hset);
 	for (; s[j]; j++)
 	{
-		___________________
+		___________________;
 	}
 	return m;
 }

data/2.dailycode中阶/1.cpp/54.exercises/solution.md

@@ -46,7 +46,7 @@ static int numDecodings(char *s)
 	int c = b;
 	for (int i = 2; i <= len; i++)
 	{
-		_________________
+		_________________;
 		a = b;
 		b = c;
 	}

data/2.dailycode中阶/1.cpp/55.exercises/solution.md

@@ -33,7 +33,7 @@ public:
 		unsigned int res = 0;
 		while (dvd >= dvs)
 		{
-			________________
+			________________;
 		}
 		if (signal == 1 && res >= INT_MAX)
 		{

data/2.dailycode中阶/1.cpp/56.exercises/solution.md

@@ -30,7 +30,7 @@ public:
             {
                 ans.push_back(matrix[i][col - 1 - cir]);
             }
-            __________________
+            __________________;
             for (int i = row - 2 - cir; i > cir && (col - 1 - cir != cir); i--)
             {
                 ans.push_back(matrix[i][cir]);

data/2.dailycode中阶/1.cpp/57.exercises/solution.md

@@ -31,7 +31,7 @@ private:
 			{
 				if (!used[i])
 				{
-					_______________
+					_______________;
 				}
 			}
 		}

data/2.dailycode中阶/1.cpp/58.exercises/solution.md

@@ -48,7 +48,7 @@ public:
 			}
 			if (nums[lo] <= nums[mid])
 			{
-				____________
+				____________;
 			}
 			else
 			{

data/2.dailycode中阶/1.cpp/59.exercises/solution.md

@@ -24,7 +24,7 @@ static int binary_search(int *nums, int len, int target)
 			high = mid;
 		}
 	}
-	______________________
+	______________________;
 	else
 	{
 		return high;

data/2.dailycode中阶/1.cpp/60.exercises/solution.md

@@ -19,7 +19,7 @@ public:
 		}
 		else
 		{
-			___________________
+			___________________;
 		}
 	}
 private:

data/2.dailycode中阶/1.cpp/61.exercises/solution.md

@@ -31,7 +31,7 @@ public:
 			string key;
 			for (int i : counts)
 			{
-				________________
+				________________;
 			}
 			ht[key].push_back(str);
 		}

data/2.dailycode中阶/1.cpp/62.exercises/solution.md

@@ -30,7 +30,7 @@ public:
         {
             for (int n = 0; n < j; n++)
             {
-				__________________
+				__________________;
             }
         }
     }

data/2.dailycode中阶/1.cpp/63.exercises/solution.md

@@ -70,7 +70,7 @@ private:
 		while (lo + 1 < hi)
 		{
 			int mid = lo + (hi - lo) / 2;
-			______________
+			______________;
 		}
 		if (lo == -1 || nums[lo] != target)
 		{

data/2.dailycode中阶/1.cpp/64.exercises/solution.md

@@ -23,7 +23,7 @@ public:
 		while (hi < nums.size() - 1)
 		{
 			int right = 0;
-			_______________________
+			_______________________;
 			hi = right;
 			steps++;
 		}

data/2.dailycode中阶/1.cpp/65.exercises/solution.md

@@ -26,7 +26,7 @@ static struct ListNode *reverseBetween(struct ListNode *head, int m, int n)
 	for (i = m; i < n; i++)
 	{
 		struct ListNode *q = p->next;
-		__________________
+		__________________;
 	}
 	return dummy.next;
 }

data/2.dailycode中阶/1.cpp/66.exercises/solution.md

@@ -37,7 +37,7 @@ int minPathSum(int **grid, int gridRowSize, int gridColSize)
 	{
 		for (j = 1; j < gridColSize; j++)
 		{
-			_____________________
+			_____________________;
 		}
 	}
 	return dp[gridRowSize - 1][gridColSize - 1];

data/2.dailycode中阶/1.cpp/67.exercises/solution.md

@@ -27,7 +27,7 @@ public:
 			pv.push_back(p);
 			p = p->next;
 		}
-		_________________
+		_________________;
 		p->next = p->next->next;
 		return empty_node.next;
 	}

data/2.dailycode中阶/1.cpp/68.exercises/solution.md

@@ -52,7 +52,7 @@ private:
 			for (int i = start; i < candidates.size(); i++)
 			{
 				stack.push_back(candidates[i]);
-				_____________________________
+				_____________________________;
 				stack.pop_back();
 			}
 		}

data/2.dailycode中阶/1.cpp/69.exercises/solution.md

@@ -39,7 +39,7 @@ public:
 					break;
 			}
 			t--;
-			________________
+			________________;
 		}
 		s[ti + maxlen] = 0;
 		return s.c_str() + ti;

data/2.dailycode中阶/1.cpp/70.exercises/solution.md

@@ -55,7 +55,7 @@ static bool search(int *nums, int numsSize, int target)
 		}
 		else if (nums[lo] <= nums[mid])
 		{
-			___________________
+			___________________;
 		}
 		else
 		{

data/2.dailycode中阶/1.cpp/71.exercises/solution.md

@@ -47,7 +47,7 @@ static int removeDuplicates(int *nums, int numsSize)
 	{
 		if (nums[len] == nums[i])
 		{
-			_____________________
+			_____________________;
 		}
 		else
 		{

data/2.dailycode中阶/1.cpp/72.exercises/solution.md

@@ -32,7 +32,7 @@ static bool isInterleave(char *s1, char *s2, char *s3)
 	}
 	for (i = 1; i < len2 + 1; i++)
 	{
-		____________________
+		____________________;
 	}
 	for (i = 1; i < len1 + 1; i++)
 	{

data/2.dailycode中阶/1.cpp/73.exercises/solution.md

@@ -34,7 +34,7 @@ int **merge(int **intervals, int intervalsSize, int *intervalsColSize, int *retu
 		if (tmp[i * 2] > intervals[len][1])
 		{
 			len++;
-			___________________________
+			___________________________;
 		}
 		else if (tmp[i * 2 + 1] > intervals[len][1])
 		{

data/2.dailycode中阶/1.cpp/74.exercises/solution.md

@@ -31,7 +31,7 @@ public:
 				{
 					r.emplace_back(vector<int>({nums[cur], nums[left], nums[right]}));
 					int t = left + 1;
-					__________________________
+					__________________________;
 				}
 				else if (n > 0)
 				{

data/2.dailycode中阶/1.cpp/75.exercises/solution.md

@@ -18,7 +18,7 @@ public:
 			int j, carry = 0;
 			for (j = num1.length() - 1; j >= 0; j--)
 			{
-				_____________________
+				_____________________;
 			}
 			res[i + j + 1] = carry + '0';
 		}

data/2.dailycode中阶/1.cpp/76.exercises/solution.md

@@ -31,7 +31,7 @@ public:
 				{
 					break;
 				}
-				____________________________
+				____________________________;
 				else
 				{
 					int t = left + 1;

data/2.dailycode中阶/1.cpp/77.exercises/solution.md

@@ -17,7 +17,7 @@ static bool canJump(int *nums, int numsSize)
 	int i, pos = 0;
 	for (i = 0; i < numsSize - 1; i++)
 	{
-		___________________
+		___________________;
 		pos = max(i + nums[i], pos);
 	}
 	return pos >= numsSize - 1;

data/2.dailycode中阶/1.cpp/78.exercises/solution.md

@@ -36,7 +36,7 @@ static bool dfs(char *word, char **board, bool *used,
 	}
 	if (!result && col < col_size - 1 && !used[row * col_size + col + 1])
 	{
-		__________________________
+		__________________________;
 	}
 	used[row * col_size + col] = false;
 	return result;

data/2.dailycode中阶/1.cpp/79.exercises/solution.md

@@ -69,7 +69,7 @@ public:
 			{
 				root = stk.top();
 				stk.pop();
-				_______________________
+				_______________________;
 			}
 		}
 		return true;

data/2.dailycode中阶/1.cpp/80.exercises/solution.md

@@ -21,7 +21,7 @@ struct ListNode *deleteDuplicates(struct ListNode *head)
 	p = q = head;
 	while (p != NULL)
 	{
-		_____________________
+		_____________________;
 	}
 	return dummy.next;
 }

data/2.dailycode中阶/1.cpp/81.exercises/solution.md

@@ -85,7 +85,7 @@ public:
 			}
 			if (left)
 			{
-				_____________________
+				_____________________;
 			}
 		}
 		for (i = 0; i < full_cycles; ++i)

data/2.dailycode中阶/1.cpp/82.exercises/solution.md

@@ -48,7 +48,7 @@ private:
 				if (last != candidates[i])
 				{
 					stack.push_back(candidates[i]);
-					_________________________________
+					_________________________________;
 					stack.pop_back();
 				}
 				last = candidates[i];

data/2.dailycode中阶/1.cpp/83.exercises/solution.md

@@ -17,7 +17,7 @@ public:
 		ans[0][0] = 1;
 		while (cnt < n * n)
 		{
-			___________________
+			___________________;
 			time++;
 		}
 		return ans;

data/2.dailycode中阶/1.cpp/84.exercises/solution.md

@@ -25,7 +25,7 @@ public:
 		while (p != nullptr && p->next != nullptr)
 		{
 			struct ListNode *q = p->next;
-			_____________________
+			_____________________;
 		}
 		return dummy.next;
 	}

data/2.dailycode中阶/1.cpp/85.exercises/solution.md

@@ -30,7 +30,7 @@ public:
 		j = nums.size() - 1;
 		while (i < j)
 		{
-			_____________________
+			_____________________;
 			swap(nums[i], nums[j]);
 		}
 	}

data/2.dailycode中阶/1.cpp/86.exercises/solution.md

@@ -76,7 +76,7 @@ static int uniquePathsWithObstacles(int **obstacleGrid, int obstacleGridRowSize,
 		int *line = obstacleGrid[row];
 		for (col = 1; col < obstacleGridColSize; col++)
 		{
-			________________________
+			________________________;
 		}
 	}
 	return obstacleGrid[obstacleGridRowSize - 1][obstacleGridColSize - 1];

data/2.dailycode中阶/1.cpp/87.exercises/solution.md

@@ -88,7 +88,7 @@ public:
 			vector<bool> mark(10);
 			for (int i = sr; i < sr + 3; i++)
 			{
-				________________________
+				________________________;
 			}
 		}
 		return true;

data/2.dailycode中阶/3.python/1.exercises/solution.md

@@ -23,7 +23,7 @@ def deal(data,flag):
 		elif a==[]:
 			a.append([i])
 		else:
-			_______________________
+			_______________________;
 			a.append([i])
 	target=sum(max(a,key=sum))
 	return list(filter(lambda x:sum(x)==target,a))

data/2.dailycode中阶/3.python/2.exercises/solution.md

@@ -30,7 +30,7 @@ def lcm(x, y):
    else:
 	   greater = y
    while(True):
-	   ____________________
+	   ____________________;
 	   greater += 1
    return lcm
 num1 = int(input("输入第一个数字: "))

data/3.dailycode高阶/1.cpp/1.exercises/solution.md

@@ -26,7 +26,7 @@ int main()
         temp = 0;
         cin >> n1 >> n2 >> n3;
         temp += n1 * x + n2 * y + n3 * z;
-		__________________
+		__________________;
     }
     cout << t << " " << min;
     return 0;

data/3.dailycode高阶/1.cpp/10.exercises/solution.md

@@ -28,7 +28,7 @@ void solve()
     printf("\n");
     for (j = 0; j < n; j++)
     {
-		___________________
+		___________________;
         for (k = 1; k <= Y; k++)
             printf("%-3d", Min[k]);
         printf("\n");

data/3.dailycode高阶/1.cpp/11.exercises/solution.md

@@ -46,7 +46,7 @@ int main()
     auto status = 0;
     for (; j < n; ++j)
     {
-		______________
+		______________;
     }
     if (status == 0)
     {

data/3.dailycode高阶/1.cpp/12.exercises/solution.md

@@ -17,7 +17,7 @@ int main() {
 	return 0;
 }
 int total(int x) {
-	_________________
+	_________________;
 }
 ```
 

data/3.dailycode高阶/1.cpp/13.exercises/solution.md

@@ -32,7 +32,7 @@ int main()
     }
     for (i = 1; i < strlen(a); i++)
     {
-		________________
+		________________;
     }
     if (zyy && !fyy)
     {

data/3.dailycode高阶/1.cpp/14.exercises/solution.md

@@ -40,7 +40,7 @@ int main()
 		for (long long i = 2; i <= c; i = sum / k + 1)
 		{
 			int t = num;
-			________________
+			________________;
 		}
 		cout << "Case #" << count++ <<": " << num << endl;
 	}

data/3.dailycode高阶/1.cpp/15.exercises/solution.md

@@ -19,7 +19,7 @@ int sushu(int x)
     int i, j = 1;
     for (i = 2; i <= sqrt(x); i++)
     {
-		_______________
+		_______________;
     }
     return j;
 }

data/3.dailycode高阶/1.cpp/16.exercises/solution.md

@@ -26,7 +26,7 @@ int binary(int *a, int key, int n)
     mid = (left + right) / 2;
     while (left < right && a[mid] != key)
     {
-		_________________
+		_________________;
     }
     if (a[mid] == key)
         return mid;

data/3.dailycode高阶/1.cpp/18.exercises/solution.md

@@ -20,7 +20,7 @@ void paixu(float *p, int n)
             if (fabs(p[j]) < fabs(p[j + 1]))
             {
                 float tmp;
-				_______________
+				_______________;
             }
         }
     }

data/3.dailycode高阶/1.cpp/19.exercises/solution.md

@@ -49,7 +49,7 @@ void shuchu(char *a, int m, int n)
     else
     {
         cout << a[(m + n) / 2];
-		_______________________
+		_______________________;
     }
 }
 int main()

data/3.dailycode高阶/1.cpp/2.exercises/solution.md

@@ -31,7 +31,7 @@ void JosePhus(int n, int m, int start)
     {
         start--;
         int index = (start + m - 1) % sum;
-        ______________
+        ______________;
         sum--;
         count++;
     }

data/3.dailycode高阶/1.cpp/20.exercises/solution.md

@@ -19,7 +19,7 @@
 #include <complex>
 using namespace std;
 static const double e = 1e-12;
-_______________________________
+_______________________________;
 int main()
 {
     complex<double> a, b, c;

data/3.dailycode高阶/1.cpp/21.exercises/solution.md

@@ -112,7 +112,7 @@ private:
                         rows[row][i] = true;
                         cols[col][i] = true;
                         boxes[idx][i] = true;
-                        _______________________________
+                        _______________________________;
                         if (!ok)
                         {
                             rows[row][i] = false;

data/3.dailycode高阶/1.cpp/22.exercises/solution.md

@@ -17,7 +17,7 @@ public:
 		int right = height.size() - 1, right_max = 0;
 		while (left < right)
 		{
-			_____________________
+			_____________________;
 		}
 		return res;
 	}

data/3.dailycode高阶/1.cpp/23.exercises/solution.md

@@ -33,7 +33,7 @@ static int largestRectangleArea(int *heights, int heightsSize)
 		indexes[pos++] = i;
 	}
 	int max_area = 0;
-	_______________________
+	_______________________;
 	return max_area;
 }
 int main(void)

data/3.dailycode高阶/1.cpp/24.exercises/solution.md

@@ -19,7 +19,7 @@ public:
 		int i = 0;
 		while (i < nums.size())
 		{
-			____________________________
+			____________________________;
 		}
 		for (i = 0; i < nums.size(); i++)
 		{

data/3.dailycode高阶/1.cpp/25.exercises/solution.md

@@ -63,7 +63,7 @@ private:
 				if (row == 0 || !conflict(stack, row, i))
 				{
 					stack[row] = i;
-					_______________________
+					_______________________;
 				}
 			}
 			return count;

data/3.dailycode高阶/1.cpp/3.exercises/solution.md

@@ -116,7 +116,7 @@ int main()
             if (temp.time - 86400 >= old.time)
             {
                 int tc = old.country;
-				_________________________
+				_________________________;
                 q.pop();
             }
             else

data/3.dailycode高阶/1.cpp/4.exercises/solution.md

@@ -41,7 +41,7 @@ int main()
     t = -1;
     for (i = 0; i < n - 1; i++)
     {
-		____________________
+		____________________;
     }
     b[j] = n - 1 - t;
     c[j] = n - 1;

data/3.dailycode高阶/1.cpp/5.exercises/solution.md

@@ -65,7 +65,7 @@ void dfs(int x)
     }
     for (int i = 1; i < 13; ++i)
     {
-		________________
+		________________;
     }
 }
 int main()

data/3.dailycode高阶/1.cpp/6.exercises/solution.md

@@ -20,7 +20,7 @@ int main()
         a = j;
         while (j != 0)
         {
-            ______________
+            ______________;
         }
         j = a;
         if (sum == a)

data/3.dailycode高阶/1.cpp/7.exercises/solution.md

@@ -19,7 +19,7 @@ void InsertSort(int a[], int n)
         {
             int j = i - 1;
             int x = a[i];
-			________________
+			________________;
         }
     }
 }

data/3.dailycode高阶/1.cpp/8.exercises/solution.md

@@ -24,7 +24,7 @@ string StrCon(const string& a, const string& b)
 		c += a[i];
 		c += b[i];
 	}
-	__________________
+	__________________;
 	return c;
 }
 int main()

data/3.dailycode高阶/1.cpp/9.exercises/solution.md

@@ -18,7 +18,7 @@ int main()
         scanf("%d", &a[i]);
         if (i % 2 == 1)
         {
-			__________________
+			__________________;
         }
     }
     for (i = n - 1; i >= 0; i--)

data/3.dailycode高阶/3.python/1.exercises/solution.md

@@ -41,7 +41,7 @@ def maze(m, n, route, pos, export):
 		maze(m, n, route[:], (pos[0]+1,pos[1]), export)
 	if pos[1] > 0 and m[pos[0]][pos[1]-1] == 0 and (pos[0],pos[1]-1) not in route:
 		maze(m, n, route[:], (pos[0],pos[1]-1), export)
-	________________________________
+	________________________________;
 m = [
 	[1,1,1,0,1,1,1,1,1,1], 
 	[1,0,0,0,0,0,0,0,1,1], 

data/3.dailycode高阶/3.python/10.exercises/solution.md

@@ -16,7 +16,7 @@ class Solution(object):
 			if curr == '(':
 				stack.append(i)
 			else:
-				__________________
+				__________________;
 		tep, res = 0, 0
 		for t in data:
 			if t == 1:

data/3.dailycode高阶/3.python/11.exercises/solution.md

@@ -23,7 +23,7 @@ class Solution(object):
 		for i in range(pos):
 			for j in range(ls):
 				if board[i][j] == 'Q':
-					______________________
+					______________________;
 		for j in range(ls):
 			if check[j]:
 				board[pos][j] = 'Q'

data/3.dailycode高阶/3.python/12.exercises/solution.md

@@ -75,7 +75,7 @@ class Solution(object):
 			return memo[s1, s2]
 		n = len(s1)
 		for i in range(1, n):
-			___________________________
+			___________________________;
 		memo[s1, s2] = False
 		return False
 # %%