C语言精选100道编程题（附有图解和源码）

C语言精选100道编程题（附有图解和源码）

---

---

前面25道题都是在vs2019/vs2022本地环境下编写算法
后面25-100道题是在线OJ环境下编写算法

---

1. 打印 1~100 之间的奇数

---

代码如下（示例）：

// 1. 打印1-100的奇数
int main()
{int i = 0;for (i = 1; i <= 100; i++){if (i % 2 == 1)printf("%d ", i);}return 0;
}int main()
{int i = 0;for (i = 1; i <= 100; i += 2){printf("%d ", i);}return 0;
}

---

2. 打印9*9乘法⼝诀表

---

代码如下（示例）：

// 打印9*9乘法表
int main()
{int i, j;for (i = 1; i <= 9; i++){for (j = 1; j <= i; j++){printf("%d*%d=%2d ", i, j, i * j);}printf("\n");}
}

---

3. 打印素数

---

代码如下（示例）：

// 打印100-200的素数
//int main()
//{
//	int i = 0;
//	int j = 0;
//	for (i = 100; i <= 200; i++)
//	{
//		int flag = 1;
//		for (j = 2; j < i ; j++)
//		{
//			if (i % j == 0)
//			{
//				flag = 0;//不是素数
//				break;
//			}
//		}
//		if (flag == 1)
//			printf("%d ", i);
//	}
//}// 优化版本
#include<math.h>
int main()
{int i = 0;int j = 0;for (i = 101; i < 200; i+=2){int flag = 1;for (j = 2; j <= sqrt(i); j++){if (i % j == 0){flag = 0;break;}}if (flag == 1)printf("%d ", i);}
}

---

4. 判断三角形

---

代码如下（示例）：

// 判断三角形
//int main()
//{
//	int a, b, c;
//	scanf("%d %d %d", &a, &b, &c);
//	if ((a + b > c && a - b < c) || (b + c > a && b - c < a) || (a + c > b && a - c < b))
//	{
//		if ((a == b) && (a != c) || (a == c) && (a != b) || (b == c) && (b != a))
//			printf("等腰三角形\n");
//		else if (a == b && b == c)
//			printf("等边三角形\n");
//		else
//			printf("普通三角形\n");
//	}
//	else
//	{
//		printf("非三角形\n");
//	}
//}// 判断三角形
int main()
{int a, b, c;scanf("%d %d %d", &a, &b, &c);if (a + b > c && b + c > a && a + c > b){if (a == b && b == c)printf("等边三角形");else if (a == b || a == c || b == c)printf("等腰三角形");elseprintf("普通三角形");}else{printf("非三角形");}
}

---

5. 计算最⼤公约数

---

代码如下（示例）：

// 求最大公约数
int main()
{int a, b;int i = 0;scanf("%d %d", &a, &b);int c = (a > b ? b : a);for (i = c; i >=1; i--){if (a % i == 0 && b % i == 0){printf("%d\n", i);break;}}
}//int main()
//{
//	int a, b;
//	int i = 0;
//	scanf("%d %d", &a, &b);
//	int c = (a > b ? b : a);
//	while (1)
//	{
//		if (a % c == 0 && b % c == 0)
//		{
//			break;
//		}
//		c--;
//	}
//	printf("%d\n", c);
//	return 0;
//}

---

---

代码如下（示例）：

int main()
{int a, b;scanf("%d %d", &a, &b);int k = 0;while (k = a % b){a = b;b = k;}printf("%d\n", b);
}//辗转相除法递归实现
int gcd(int a, int b)
{if (b == 0)return a;return gcd(b, a % b);
}

---

6. 打印最⼩公倍数

---

代码如下（示例）：

// 求两个数的最小公倍数 方法一
//int main()
//{
//	int a = 0;
//	int b = 0;
//	scanf("%d %d", &a, &b);
//	int c = (a > b ? a : b);
//	for (int i = c; i < a * b; i++)
//	{
//		if (i % a == 0 && i % b == 0)
//		{
//			printf("%d\n", i);
//			break;
//		}
//	}
//}//求两个数的最小公倍数 方法二
int main()
{int a = 0;int b = 0;scanf("%d %d", &a, &b);int c = a * b;int k = 0;// 辗转相除法求最大公约数 bwhile (k = a % b){a = b;b = k;}printf("%d\n", c / b);
}

---

7. 分数求和

---

代码如下（示例）：

int main()
{int i = 0;double sum = 0;for (i = 1; i <= 100; i++){if (i % 2 == 1)sum += 1.0 / i;elsesum -= 1.0 / i;}printf("%lf\n", sum);
}

---

8. 计算最⼤值和最⼩值的差值

---

代码如下（示例）：

// 第一种方法
//void bubblesort(int arr[], int sz)
//{
//    int i = 0;
//    for (i = 0; i < sz - 1; i++)
//    {
//        int j = 0;
//        for (j = 0; j < sz - 1 - i; j++)
//        {
//            if (arr[j] > arr[j + 1])
//            {
//                int tmp = arr[j];
//                arr[j] = arr[j + 1];
//                arr[j + 1] = tmp;
//            }
//        }
//    }
//}
//int main()
//{
//	int arr[10] = { 0 };
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	int sz = sizeof(arr)/sizeof(arr[0]);
//    bubblesort(arr, sz);
//    printf("%d\n", arr[9] - arr[0]);
//
//}// 第二种方法
//int main()
//{
//	int arr[10] = { 0 };
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	int Max = arr[0];
//	int Min = arr[0];
//	for (i = 1; i < 10; i++)
//	{
//		if (arr[i] > Max)
//			Max = arr[i];
//		if (arr[i] < Min)
//			Min = arr[i];
//	}
//	printf("%d\n", Max - Min);
//	return 0;
//}// 第三种方法
int main()
{int arr;scanf("%d", &arr);int Max = arr;int Min = arr;int i = 0;for (i = 1; i < 10; i++){scanf("%d", &arr);if (arr > Max)Max = arr;if (arr < Min)Min = arr;}printf("%d\n", Max - Min);return 0;
}

---

9. 排序整形数组

---

代码如下（示例）：

// 冒泡排序
//void BubbleSort(int arr[], int sz)
//{
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < sz - 1; i++)
//	{
//		for (j = 0; j < sz - 1 - i; j++)
//		{
//			if (arr[j] > arr[j + 1])
//			{
//				int tmp = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = tmp;
//			}
//		}
//	}
//}
//void arrPrintf(int arr[], int sz)
//{
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//}
//int main()
//{
//	int arr[10] = { 0 };
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	for (i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	BubbleSort(arr, sz);
//	arrPrintf(arr, sz);
//}//#include <stdio.h>
//int main()
//{
//	int arr[10] = { 0 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	for (i = 0; i < sz - 1; i++)
//	{
//		int j = 0;
//		int flag = 1;//假设待排序的数据已经有序
//		for (j = 0; j < sz - 1 - i; j++)
//		{
//			if (arr[j] > arr[j + 1])
//			{
//				flag = 0;
//				int tmp = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = tmp;
//			}
//		}
//		if (flag == 1)
//			break;
//	}
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}#include <stdio.h>
int main()
{int arr[10] = { 0 };int sz = sizeof(arr) / sizeof(arr[0]);int i = 0;for (i = 0; i < sz; i++){scanf("%d", &arr[i]);}for (i = 0; i < sz - 1; i++){int j = 0;for (j = 0; j < sz - 1 - i; j++){if (arr[j] > arr[j + 1]){int tmp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = tmp;}}}for (i = 0; i < sz; i++){printf("%d ", arr[i]);}return 0;
}

---

10. 找出盗窃者

---

代码如下（示例）：

// 判断盗窃者
int main()
{int thieves = 0;for (thieves = 'a'; thieves <= 'd'; thieves++){if ((thieves != 'a') + (thieves == 'c') + (thieves == 'd') + (thieves != 'd') == 3)printf("盗窃者是: %c", thieves);}
}

---

11. ⾃幂数

---

代码如下（示例）：

// 判断自幂数
#include <math.h>
int main()
{int i = 0;for (i = 1; i <= 100000; i++){//判断i是否是⾃幂数//1. 计算i的位数nint n = 1;int tmp = i;while (tmp / 10){n++;tmp /= 10;}//2. 计算i的每⼀位的n次⽅之和tmp = i;int sum = 0;while (tmp){sum += (int)pow(tmp % 10, n);tmp /= 10;}//3. 输出if (sum == i)printf("%d ", i);}return 0;
}

---

12. 打印菱形

---

代码如下（示例）：

int main()
{int n = 0;scanf("%d", &n);//打印上半部分的n行int i = 0;for (i = 0; i < n; i++){int j = 0;for (j = 0; j < n - 1 - i; j++){printf(" ");}for (j = 0; j < 2 * i + 1; j++){printf("*");}printf("\n");}//打印下半部分的n-1⾏for (i = 0; i < n; i++){int j = 0;for (j = 0; j <= i; j++){printf(" ");}for (j = 0; j < 2 * (n - 1 - i) - 1; j++){printf("*");}printf("\n");}return 0;
}

---

13. 喝多少瓶汽⽔

---

代码如下（示例）：

// 喝多少汽水
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int total = 0;
//	int empty = 0;
//	total += n;
//	empty += n;
//	while (empty >= 2)
//	{
//		total += empty / 2;
//		empty = empty / 2 + empty % 2;
//	}
//	printf("%d\n", total);
//}// 第二种方法
int main()
{int n = 0;int total = 0;scanf("%d", &n);if (n == 0)total = 0;elsetotal = 2 * n - 1;printf("%d\n",total);return 0;
}

---

14. 字符转换

---

代码如下（示例）：

//方法一：不使用库函数
int main()
{char buf[31] = { 0 };scanf("%[^\n]", buf);int i = 0;while (buf[i]){if (buf[i] >= 'a' && buf[i] <= 'z')buf[i] -= 32;else if (buf[i] >= 'A' && buf[i] <= 'Z')buf[i] += 32;i++;}printf("%s\n", buf);return 0;
}
//⽅法2：使⽤库函数
#include <ctype.h>
int main()
{char buf[31] = { 0 };scanf("%[^\n]s", buf);int i = 0;while (buf[i]){if (islower(buf[i]))buf[i] = toupper(buf[i]);else if (isupper(buf[i]))buf[i] = tolower(buf[i]);i++;}printf("%s\n", buf);return 0;
}

---

15. 交换两个整数

---

代码如下（示例）：

// 交换两个整数
void Swap(int* pa, int* pb)
{int tmp = *pa;*pa = *pb;*pb = tmp;
}
int main()
{int a, b;scanf("%d %d", &a, &b);Swap(&a, &b);printf("%d %d\n", a, b);
}

---

16. 求两个整数的平均值

---

代码如下（示例）：

// 求两个整数的平均值
int average(int a, int b)
{return (a+b)/2;
}
int average(int a, int b)
{return a+(b-a)/2;
}
int main()
{int a, b;scanf("%d %d", &a, &b);int ret = average(a, b);printf("%d\n", ret);
}

---

17. 求字符串长度

18. 求字符串长度【进阶版】

---

代码如下（示例）：

// 求字符串长度
//模拟实现strlen函数的第一种方法
//#include<assert.h>
//size_t my_first_strlen(const char* string)
//{
//	assert(string);
//	int count = 0;
//	while (*string != '\0')
//	{
//		string++;
//		count++;
//	}
//	return count;
//}
//int main()
//{
//	char arr[10] = "abcdef";
//	int ret = my_first_strlen(arr);
//	printf("%d\n", ret);
//	return 0;
//}// 第二种方法：递归
//#include<assert.h>
//size_t my_second_strlen(const char* str)
//{
//	assert(str != NULL);
//	if (*str != '\0')
//	{
//		return 1 + my_second_strlen(str + 1);
//	}
//	else
//	{
//		return 0;
//	}
//}
//int main()
//{
//	char arr[10] = "abcdef";
//	int ret = my_second_strlen(arr);
//	printf("%d\n", ret);
//	return 0;
//}// 第三种方法：指针-指针
#include<assert.h>
size_t my_third_strlen(const char* str)
{assert(str != NULL);const char* start = str;while (*str != '\0'){str++;}return str - start;
}
int main()
{char arr[10] = "abcdef";int ret = my_third_strlen(arr);printf("%d\n", ret);return 0;
}

---

19. 逆序字符串

---

代码如下（示例）：

// 逆序字符串
#include<string.h>
void reverse(char* arr)
{int ret = strlen(arr);char* left = arr;char* right = arr + ret - 1;while (left < right){char tmp = *left;*left = *right;*right = tmp;left++;right--;}
}
int main()
{char arr[31] = { 0 };scanf("%[^\n]", arr);reverse(arr);printf("%s\n", arr);
}

---

20. 求数字的每⼀位之和

---

代码如下（示例）：

// 方法二
int digit_sum(int m)
{int sum = 0;while (m){sum += m % 10;m /= 10;}//返回每⼀位的和return sum;
}
// 求数字的每一位之和
// 方法一
int main()
{int n = 0;scanf("%d", &n);int sum = 0;while (n / 10){sum += n % 10;n /= 10;}sum += n % 10;printf("%d\n", sum);
}

---

21. 判断回⽂字符串

---

代码如下（示例）：

#include<string.h>
// 判断字符串
int main()
{char arr[31] = { 0 };scanf("%[^\n]s", arr);int len = strlen(arr);char* left = arr;char* right = arr + len - 1;while (left < right){if (*left != *right){printf("NO");return 0;}left++;right--;}printf("YES");
}

---

22. 计算天数

---

代码如下（示例）：

// 计算天数
#include <stdio.h>
int get_month_of_day(int y, int m)
{//将每个⽉份的天数记录在数组中int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };//获取⽉份的天数int day = days[m];//特判⼆⽉天数是29天的情况if ((y % 4 == 0 && y % 100 != 0) || (y % 400 == 0)){if (m == 2)day += 1;}return day;
}
int main()
{int y = 0;int m = 0;//输⼊scanf("%d %d", &y, &m);//获取y年m⽉的天数int ret = get_month_of_day(y, m);printf("%d\n", ret);return 0;
}

---

23. 删除指定的数

---

代码如下（示例）：

// 删除指定的数字
//int main()
//{
//	int count = 0;
//	int arr[10] = { 0 };
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	for (i = 0; i < sz; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	int n = 0;
//	scanf("%d", &n);
//	for (i = 0; i < sz; i++)
//	{
//		if (n == arr[i])
//		{
//			count++;
//			int j = 0;
//			for (j = i; j < sz -1; j++)
//			{
//				arr[j] = arr[j + 1];
//			}
//		}
//	}
//	for (i = 0; i < sz-count; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//}// 方法二
int main()
{int arr[10] = { 0 };int del = 0;int i = 0;//输⼊for (i = 0; i < 10; i++){scanf("%d", &arr[i]);}scanf("%d", &del);//删除int j = 0;for (i = 0; i < 10; i++){//若当前数与给定值不相同，不需要删除，//将其填⼊第j个位置，将j后移if (arr[i] != del)arr[j++] = arr[i];}//打印for (i = 0; i < j; i++){printf("%d ", arr[i]);}return 0;
}

---

24. 字符串拷贝

---

代码如下（示例）：

// 字符串拷贝--
//int main()
//{
//	char arr1[20] = "abcdef";
//	char arr2[20] = {0};
//	char* str1 = arr1;
//	char* str2 = arr2;
//	while (*str1 != '\0')
//	{
//		*str2 = *str1;
//		str1++;
//		str2++;
//	}
//	*str2 = '\0';
//	printf("%s\n", arr2);
//}// 方法一
//void my_strcpy(char* dest, const char* src)
//{
//	while (*src != '\0') {
//		*dest = *src;
//		dest++;
//		src++;
//	}
//	// 拷贝原字符串的结束标志
//	*dest = '\0';
//}
//int main()
//{
//	char arr1[] = "hello bite";
//	char arr2[20] = { 0 };
//
//	//将字符串arr1中的内容拷⻉到字符串arr2中
//	my_strcpy(arr2, arr1);
//	//打印字符串arr2
//	printf("%s\n", arr2);
//	return 0;
//}// 方法二
void my_strcpy(char* dest, const char* src)
{while (*dest++ = *src++){;}
}
int main()
{char arr1[] = "hello bite";char arr2[20] = { 0 };//将字符串arr1中的内容拷⻉到字符串arr2中my_strcpy(arr2, arr1);//打印字符串arr2printf("%s\n", arr2);return 0;
}

---

25. 合并有序数组

---

代码如下（示例）：

// 合并有序数组
int main()
{int n, m;scanf("%d %d", &n, &m);int arr1[30] = { 0 };int arr2[30] = { 0 };int arr3[60] = { 0 };int i, j, k = 0; //k最开始没有初始化为0for (i = 0; i < n; i++){scanf("%d", &arr1[i]);}for (j = 0; j < m; j++){scanf("%d", &arr2[j]);}i = 0, j = 0;while (i < n && j < m){if (arr1[i] < arr2[j]){arr3[k] = arr1[i];k++;i++;}else if (arr1[i] > arr2[j]){arr3[k] = arr2[j];k++;j++;}else{arr3[k] = arr1[i];k++;i++;}}if (i == n){for (; j < m; j++){arr3[k] = arr2[j];k++;}}if (j == m){for (; i < n; i++){arr3[k] = arr1[i];k++;}}for (k = 0; k < m + n; k++){printf("%d ", arr3[k]);}
}

---

前面25道题整体源代码：

代码如下（示例）：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>// 1. 打印1-100的奇数
//int main()
//{
//	int i = 0;
//	for (i = 1; i <= 100; i++)
//	{
//		if (i % 2 == 1)
//			printf("%d ", i);
//	}
//	return 0;
//}
//
//int main()
//{
//	int i = 0;
//	for (i = 1; i <= 100; i += 2)
//	{
//		printf("%d ", i);
//	}
//	return 0;
//}// 打印9*9乘法表
//int main()
//{
//	int i, j;
//	for (i = 1; i <= 9; i++)
//	{
//		for (j = 1; j <= i; j++)
//		{
//			printf("%d*%d=%2d ", i, j, i * j);
//		}
//		printf("\n");
//	}
//}// 打印100-200的素数
//int main()
//{
//	int i = 0;
//	int j = 0;
//	for (i = 100; i <= 200; i++)
//	{
//		int flag = 1;
//		for (j = 2; j < i ; j++)
//		{
//			if (i % j == 0)
//			{
//				flag = 0;//不是素数
//				break;
//			}
//		}
//		if (flag == 1)
//			printf("%d ", i);
//	}
//}// 优化版本
//#include<math.h>
//int main()
//{
//	int i = 0;
//	int j = 0;
//	for (i = 101; i < 200; i+=2)
//	{
//		int flag = 1;
//		for (j = 2; j <= sqrt(i); j++)
//		{
//			if (i % j == 0)
//			{
//				flag = 0;
//				break;
//			}
//		}
//		if (flag == 1)
//			printf("%d ", i);
//	}
//}// 判断三角形
//int main()
//{
//	int a, b, c;
//	scanf("%d %d %d", &a, &b, &c);
//	if ((a + b > c && a - b < c) || (b + c > a && b - c < a) || (a + c > b && a - c < b))
//	{
//		if ((a == b) && (a != c) || (a == c) && (a != b) || (b == c) && (b != a))
//			printf("等腰三角形\n");
//		else if (a == b && b == c)
//			printf("等边三角形\n");
//		else
//			printf("普通三角形\n");
//	}
//	else
//	{
//		printf("非三角形\n");
//	}
//}// 判断三角形
//int main()
//{
//	int a, b, c;
//	scanf("%d %d %d", &a, &b, &c);
//	if (a + b > c && b + c > a && a + c > b)
//	{
//		if (a == b && b == c)
//			printf("等边三角形");
//		else if (a == b || a == c || b == c)
//			printf("等腰三角形");
//		else
//			printf("普通三角形");
//	}
//	else
//	{
//		printf("非三角形");
//	}
//}// 求最大公约数
//int main()
//{
//	int a, b;
//	int i = 0;
//	scanf("%d %d", &a, &b);
//	int c = (a > b ? b : a);
//	for (i = c; i >=1; i--)
//	{
//		if (a % i == 0 && b % i == 0)
//		{
//			printf("%d\n", i);
//			break;
//		}
//	}
//}//int main()
//{
//	int a, b;
//	int i = 0;
//	scanf("%d %d", &a, &b);
//	int c = (a > b ? b : a);
//	while (1)
//	{
//		if (a % c == 0 && b % c == 0)
//		{
//			break;
//		}
//		c--;
//	}
//	printf("%d\n", c);
//	return 0;
//}//int main()
//{
//	int a, b;
//	scanf("%d %d", &a, &b);
//	int k = 0;
//	while (k = a % b)
//	{
//		a = b;
//		b = k;
//	}
//	printf("%d\n", b);
//}
//
//
////辗转相除法递归实现
//int gcd(int a, int b)
//{
//	if (b == 0)
//		return a;
//	return gcd(b, a % b);
//}// 求两个数的最小公倍数 方法一
//int main()
//{
//	int a = 0;
//	int b = 0;
//	scanf("%d %d", &a, &b);
//	int c = (a > b ? a : b);
//	for (int i = c; i < a * b; i++)
//	{
//		if (i % a == 0 && i % b == 0)
//		{
//			printf("%d\n", i);
//			break;
//		}
//	}
//}//求两个数的最小公倍数 方法二
//int main()
//{
//	int a = 0;
//	int b = 0;
//	scanf("%d %d", &a, &b);
//	int c = a * b;
//	int k = 0;
//	// 辗转相除法求最大公约数 b
//	while (k = a % b)
//	{
//		a = b;
//		b = k;
//	}
//	printf("%d\n", c / b);
//}// error
//int main()
//{
//	int i = 1;
//	int j = 1;
//	for (i = 1; i <= 100; i++)
//	{
//		if (i % 2 == 0)
//			i = i * (-1);
//		j = j + 1 / i;
//	}
//	printf("%d\n", j);
//}//int main()
//{
//	int i = 0;
//	double sum = 0;
//	for (i = 1; i <= 100; i++)
//	{
//		if (i % 2 == 1)
//			sum += 1.0 / i;
//		else
//			sum -= 1.0 / i;
//	}
//	printf("%lf\n", sum);
//}// 第一种方法
//void bubblesort(int arr[], int sz)
//{
//    int i = 0;
//    for (i = 0; i < sz - 1; i++)
//    {
//        int j = 0;
//        for (j = 0; j < sz - 1 - i; j++)
//        {
//            if (arr[j] > arr[j + 1])
//            {
//                int tmp = arr[j];
//                arr[j] = arr[j + 1];
//                arr[j + 1] = tmp;
//            }
//        }
//    }
//}
//int main()
//{
//	int arr[10] = { 0 };
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	int sz = sizeof(arr)/sizeof(arr[0]);
//    bubblesort(arr, sz);
//    printf("%d\n", arr[9] - arr[0]);
//
//}// 第二种方法
//int main()
//{
//	int arr[10] = { 0 };
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	int Max = arr[0];
//	int Min = arr[0];
//	for (i = 1; i < 10; i++)
//	{
//		if (arr[i] > Max)
//			Max = arr[i];
//		if (arr[i] < Min)
//			Min = arr[i];
//	}
//	printf("%d\n", Max - Min);
//	return 0;
//}// 第三种方法
//int main()
//{
//	int arr;
//	scanf("%d", &arr);
//	int Max = arr;
//	int Min = arr;
//	int i = 0;
//	for (i = 1; i < 10; i++)
//	{
//		scanf("%d", &arr);
//		if (arr > Max)
//			Max = arr;
//		if (arr < Min)
//			Min = arr;
//	}
//	printf("%d\n", Max - Min);
//	return 0;
//}// 冒泡排序
//void BubbleSort(int arr[], int sz)
//{
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < sz - 1; i++)
//	{
//		for (j = 0; j < sz - 1 - i; j++)
//		{
//			if (arr[j] > arr[j + 1])
//			{
//				int tmp = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = tmp;
//			}
//		}
//	}
//}
//void arrPrintf(int arr[], int sz)
//{
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//}
//int main()
//{
//	int arr[10] = { 0 };
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	for (i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	BubbleSort(arr, sz);
//	arrPrintf(arr, sz);
//}//#include <stdio.h>
//int main()
//{
//	int arr[10] = { 0 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	for (i = 0; i < sz - 1; i++)
//	{
//		int j = 0;
//		int flag = 1;//假设待排序的数据已经有序
//		for (j = 0; j < sz - 1 - i; j++)
//		{
//			if (arr[j] > arr[j + 1])
//			{
//				flag = 0;
//				int tmp = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = tmp;
//			}
//		}
//		if (flag == 1)
//			break;
//	}
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}//#include <stdio.h>
//int main()
//{
//	int arr[10] = { 0 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	for (i = 0; i < sz - 1; i++)
//	{
//		int j = 0;
//		for (j = 0; j < sz - 1 - i; j++)
//		{
//			if (arr[j] > arr[j + 1])
//			{
//				int tmp = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = tmp;
//			}
//		}
//	}
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}// 判断盗窃者
//int main()
//{
//	int thieves = 0;
//	for (thieves = 'a'; thieves <= 'd'; thieves++)
//	{
//		if ((thieves != 'a') + (thieves == 'c') + (thieves == 'd') + (thieves != 'd') == 3)
//			printf("盗窃者是: %c", thieves);
//	}
//}// 判断自幂数
//#include <math.h>
//int main()
//{
//	int i = 0;
//	for (i = 1; i <= 100000; i++)
//	{
//		//判断i是否是⾃幂数
//		//1. 计算i的位数n
//		int n = 1;
//		int tmp = i;
//		while (tmp / 10)
//		{
//			n++;
//			tmp /= 10;
//		}
//		//2. 计算i的每⼀位的n次⽅之和
//		tmp = i;
//		int sum = 0;
//		while (tmp)
//		{
//			sum += (int)pow(tmp % 10, n);
//			tmp /= 10;
//		}
//		//3. 输出
//		if (sum == i)
//			printf("%d ", i);
//	}
//	return 0;
//}//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	//打印上半部分的n行
//	int i = 0;
//	for (i = 0; i < n; i++)
//	{
//		int j = 0;
//		for (j = 0; j < n - 1 - i; j++)
//		{
//			printf(" ");
//		}
//		for (j = 0; j < 2 * i + 1; j++)
//		{
//			printf("*");
//		}
//		printf("\n");
//	}
//	//打印下半部分的n-1⾏
//	for (i = 0; i < n; i++)
//	{
//		int j = 0;
//		for (j = 0; j <= i; j++)
//		{
//			printf(" ");
//		}
//		for (j = 0; j < 2 * (n - 1 - i) - 1; j++)
//		{
//			printf("*");
//		}
//		printf("\n");
//	}
//	return 0;
//}// 喝多少汽水
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int total = 0;
//	int empty = 0;
//	total += n;
//	empty += n;
//	while (empty >= 2)
//	{
//		total += empty / 2;
//		empty = empty / 2 + empty % 2;
//	}
//	printf("%d\n", total);
//}// 第二种方法
//int main()
//{
//	int n = 0;
//	int total = 0;
//	scanf("%d", &n);
//	if (n == 0)
//		total = 0;
//	else
//		total = 2 * n - 1;
//	printf("%d\n",total);
//	return 0;
//}////方法一：不使用库函数
//int main()
//{
//	char buf[31] = { 0 };
//	scanf("%[^\n]", buf);
//	int i = 0;
//	while (buf[i])
//	{
//		if (buf[i] >= 'a' && buf[i] <= 'z')
//			buf[i] -= 32;
//
//		else if (buf[i] >= 'A' && buf[i] <= 'Z')
//			buf[i] += 32;
//		i++;
//	}
//	printf("%s\n", buf);
//	return 0;
//}
////⽅法2：使⽤库函数
//#include <ctype.h>
//int main()
//{
//	char buf[31] = { 0 };
//	scanf("%[^\n]s", buf);
//	int i = 0;
//	while (buf[i])
//	{
//		if (islower(buf[i]))
//			buf[i] = toupper(buf[i]);
//		else if (isupper(buf[i]))
//			buf[i] = tolower(buf[i]);
//		i++;
//	}
//	printf("%s\n", buf);
//	return 0;
//}// 交换两个整数
//void Swap(int* pa, int* pb)
//{
//	int tmp = *pa;
//	*pa = *pb;
//	*pb = tmp;
//}
//int main()
//{
//	int a, b;
//	scanf("%d %d", &a, &b);
//	Swap(&a, &b);
//	printf("%d %d\n", a, b);
//}// 求两个整数的平均值
//int average(int a, int b)
//{
//	return (a+b)/2;
//}
//int average(int a, int b)
//{
//	return a+(b-a)/2;
//}
//int main()
//{
//	int a, b;
//	scanf("%d %d", &a, &b);
//	int ret = average(a, b);
//	printf("%d\n", ret);
//}// 求字符串长度
//模拟实现strlen函数的第一种方法
//#include<assert.h>
//size_t my_first_strlen(const char* string)
//{
//	assert(string);
//	int count = 0;
//	while (*string != '\0')
//	{
//		string++;
//		count++;
//	}
//	return count;
//}
//int main()
//{
//	char arr[10] = "abcdef";
//	int ret = my_first_strlen(arr);
//	printf("%d\n", ret);
//	return 0;
//}// 第二种方法：递归
//#include<assert.h>
//size_t my_second_strlen(const char* str)
//{
//	assert(str != NULL);
//	if (*str != '\0')
//	{
//		return 1 + my_second_strlen(str + 1);
//	}
//	else
//	{
//		return 0;
//	}
//}
//int main()
//{
//	char arr[10] = "abcdef";
//	int ret = my_second_strlen(arr);
//	printf("%d\n", ret);
//	return 0;
//}// 第三种方法：指针-指针
//#include<assert.h>
//size_t my_third_strlen(const char* str)
//{
//	assert(str != NULL);
//	const char* start = str;
//	while (*str != '\0')
//	{
//		str++;
//	}
//	return str - start;
//}
//int main()
//{
//	char arr[10] = "abcdef";
//	int ret = my_third_strlen(arr);
//	printf("%d\n", ret);
//	return 0;
//}//// 逆序字符串
//#include<string.h>
//void reverse(char* arr)
//{
//	int ret = strlen(arr);
//	char* left = arr;
//	char* right = arr + ret - 1;
//	while (left < right)
//	{
//		char tmp = *left;
//		*left = *right;
//		*right = tmp;
//		left++;
//		right--;
//	}
//}
//int main()
//{
//	char arr[31] = { 0 };
//	scanf("%[^\n]", arr);
//	reverse(arr);
//	printf("%s\n", arr);
//}//// 方法二
//int digit_sum(int m)
//{
//	int sum = 0;
//	while (m)
//	{
//		sum += m % 10;
//		m /= 10;
//	}
//	//返回每⼀位的和
//	return sum;
//}
//// 求数字的每一位之和
//// 方法一
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int sum = 0;
//	while (n / 10)
//	{
//		sum += n % 10;
//		n /= 10;
//	}
//	sum += n % 10;
//	printf("%d\n", sum);
//}//#include<string.h>
//// 判断字符串
//int main()
//{
//	char arr[31] = { 0 };
//	scanf("%[^\n]s", arr);
//	int len = strlen(arr);
//	char* left = arr;
//	char* right = arr + len - 1;
//	while (left < right)
//	{
//		if (*left != *right)
//		{
//			printf("NO");
//			return 0;
//		}
//		left++;
//		right--;
//	}
//	printf("YES");
//}//// 计算天数
//#include <stdio.h>
//int get_month_of_day(int y, int m)
//{
//	//将每个⽉份的天数记录在数组中
//	int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
//
//	//获取⽉份的天数
//	int day = days[m];
//
//	//特判⼆⽉天数是29天的情况
//	if ((y % 4 == 0 && y % 100 != 0) || (y % 400 == 0))
//	{
//		if (m == 2)
//			day += 1;
//	}
//	return day;
//}
//int main()
//{
//	int y = 0;
//	int m = 0;
//	//输⼊
//	scanf("%d %d", &y, &m);
//	//获取y年m⽉的天数
//	int ret = get_month_of_day(y, m);
//	printf("%d\n", ret);
//	return 0;
//}// 删除指定的数字   err样例
//int main()
//{
//	int arr[10] = { 0 };
//	int i = 0;
//	for (i = 0;  i<sizeof(arr) / sizeof(arr[0]); i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	int n = 0;
//	scanf("%d", &n);
//	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
//	{
//		if (n == arr[i])
//			arr[i] = arr[i + 1];
//	}
//	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
//	{
//		printf("%d ", arr[i]);
//	}
//}// 删除指定的数字
//int main()
//{
//	int count = 0;
//	int arr[10] = { 0 };
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	for (i = 0; i < sz; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	int n = 0;
//	scanf("%d", &n);
//	for (i = 0; i < sz; i++)
//	{
//		if (n == arr[i])
//		{
//			count++;
//			int j = 0;
//			for (j = i; j < sz -1; j++)
//			{
//				arr[j] = arr[j + 1];
//			}
//		}
//	}
//	for (i = 0; i < sz-count; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//}// 方法二
//int main()
//{
//	int arr[10] = { 0 };
//	int del = 0;
//	int i = 0;
//	//输⼊
//	for (i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	scanf("%d", &del);
//
//	//删除
//	int j = 0;
//	for (i = 0; i < 10; i++)
//	{
//		//若当前数与给定值不相同，不需要删除，
//		//将其填⼊第j个位置，将j后移
//		if (arr[i] != del)
//			arr[j++] = arr[i];
//	}
//
//	//打印
//	for (i = 0; i < j; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}// 字符串拷贝--
//int main()
//{
//	char arr1[20] = "abcdef";
//	char arr2[20] = {0};
//	char* str1 = arr1;
//	char* str2 = arr2;
//	while (*str1 != '\0')
//	{
//		*str2 = *str1;
//		str1++;
//		str2++;
//	}
//	*str2 = '\0';
//	printf("%s\n", arr2);
//}// 方法一
//void my_strcpy(char* dest, const char* src)
//{
//	while (*src != '\0') {
//		*dest = *src;
//		dest++;
//		src++;
//	}
//	// 拷贝原字符串的结束标志
//	*dest = '\0';
//}
//int main()
//{
//	char arr1[] = "hello bite";
//	char arr2[20] = { 0 };
//
//	//将字符串arr1中的内容拷⻉到字符串arr2中
//	my_strcpy(arr2, arr1);
//	//打印字符串arr2
//	printf("%s\n", arr2);
//	return 0;
//}// 方法二
//void my_strcpy(char* dest, const char* src)
//{
//	while (*dest++ = *src++)
//	{
//		;
//	}
//}
//int main()
//{
//	char arr1[] = "hello bite";
//	char arr2[20] = { 0 };
//
//	//将字符串arr1中的内容拷⻉到字符串arr2中
//	my_strcpy(arr2, arr1);
//	//打印字符串arr2
//	printf("%s\n", arr2);
//	return 0;
//}//// 合并有序数组
//int main()
//{
//	int n, m;
//	scanf("%d %d", &n, &m);
//	int arr1[30] = { 0 };
//	int arr2[30] = { 0 };
//	int arr3[60] = { 0 };
//	int i, j, k = 0; //k最开始没有初始化为0
//	for (i = 0; i < n; i++)
//	{
//		scanf("%d", &arr1[i]);
//	}
//	for (j = 0; j < m; j++)
//	{
//		scanf("%d", &arr2[j]);
//	}
//	i = 0, j = 0;
//	while (i < n && j < m)
//	{
//		if (arr1[i] < arr2[j])
//		{
//			arr3[k] = arr1[i];
//			k++;
//			i++;
//		}
//		else if (arr1[i] > arr2[j])
//		{
//			arr3[k] = arr2[j];
//			k++;
//			j++;
//		}
//		else
//		{
//			arr3[k] = arr1[i];
//			k++;
//			i++;
//		}
//	}
//	if (i == n)
//	{
//		for (; j < m; j++)
//		{
//			arr3[k] = arr2[j];
//			k++;
//		}
//	}
//	if (j == m)
//	{
//		for (; i < n; i++)
//		{
//			arr3[k] = arr1[i];
//			k++;
//		}
//	}
//	for (k = 0; k < m + n; k++)
//	{
//		printf("%d ", arr3[k]);
//	}
//}

---

后面75道题都是在线OJ环境下编写算法

---

26. 两整数相加 - 题号2235

Leedcode链接

---

---

27. 猜数字 - 题号LCP 01

Leedcode链接

---

---

代码如下（示例）：

int game(int* guess, int guessSize, int* answer, int answerSize)
{int i = 0;int cnt = 0;for (i = 0; i < guessSize; i++) {if (guess[i] == answer[i]) {cnt++;}}return cnt;
}

---

---

代码如下（示例）：

int sum(int num1, int num2) 
{return num1+num2;
}

---

28. 温度转换 - 题号2469

Leedcode链接

---

---

代码如下（示例）：

double* convertTemperature(double celsius, int* returnSize) 
{double* str = (double*)malloc(2*sizeof(double));str[0]=celsius+273.15;str[1]=celsius*1.80+32.00;*returnSize = 2;return str;
}

---

29. 最⼩偶倍数 - 题号 2413

Leedcode链接

---

---

代码如下（示例）：

int smallestEvenMultiple(int n) {//判断n是不是偶数if (n % 2 == 0)return n;//如果不是偶数，则⼀定是奇数elsereturn 2 * n;
}int smallestEvenMultiple(int n) {//判断n是不是偶数if (n & 1 == 0)return n;//如果没有进⾏上⼀步操作，直接返回n为奇数时的结果2*n即可return 2 * n;
}

---

30. 数组异或操作 - 题号1486

Leedcode链接

---

---

代码如下（示例）：

int xorOperation(int n, int start)
{int arr[n];int i = 0;for (i = 0; i < n; i++){arr[i] = start + 2 * i;}int ret = 0;for (i = 0; i < n; i++){ret ^= arr[i];}return ret;
}int xorOperation(int n, int start) {int i = 0;int ret = 0;int u;for (i = 0; i < n; i++) {//将nums[i]的值存放在u中，每次更新u的值u = start + 2 * i;ret ^= u;}return ret;
}

---

31. 数组元素和与数字和的绝对差

Leedcode链接

---

---

代码如下（示例）：

#include<math.h>
int differenceOfSum(int* nums, int numsSize)
{int x = 0;int y = 0;for (int i = 0; i < numsSize; i++){x += nums[i];while (nums[i]){y += nums[i] % 10;nums[i] /= 10;}}return abs(x - y);
}

---

32. 回⽂数 - 题号：9

Leedcode链接

---

---

代码如下（示例）：

bool isPalindrome(int x)
{if (x < 0){return false;}long long n = 0;int tmp = x;while (tmp){n = n * 10 + tmp % 10;tmp /= 10;}return x == n;
}

---

33. 有多少⼩于当前数字的数字

Leedcode链接

---

---

这里用方法一是最优解，方法二和三适合教学，代码如下！

---

代码如下（示例）：

// 方法一：
#include<stdlib.h>
int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize)
{int* tmp = (int*)malloc(numsSize * sizeof(int));for (int i = 0; i < numsSize; i++){int count = 0;for (int j = 0; j < numsSize; j++){if (nums[i] > nums[j]){count++;}}tmp[i] = count;}*returnSize = numsSize;return tmp;
}// 方法二
int low(int* order, int orderSize, int u) {int i;//定义左右两边界，l为最左边，r为最右边int l = 0, r = orderSize - 1;//当l<r时表⽰l~r之间还未被查找while (l < r) {//mid为l和r的中点，向下取整int mid = (l + r) / 2;//如果在有序数组中下标为中点的数⼩于要查找的数，则要查找的数⼀定在中点右边，将左边界修改为中if (order[mid] < u) l = mid + 1;//否则在中点处或者中点左边部分，将右边界修改为中点，else r = mid;}//当查找完成时l=r，返回其中⼀个即可return l;
}
int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize) {//定义答案数组int* ans = malloc(numsSize * sizeof(int));//定义有序数组int* order = malloc(numsSize * sizeof(int));int i = 0, j = 0;//将原数组中的数放⼊有序数组，之后进⾏排序for (i = 0; i < numsSize; i++) order[i] = nums[i];//此段代码为冒泡排序，时间复杂度较⾼，有兴趣可以修改此段代码为其他时间复杂度较低的排序代for (i = 0; i < numsSize; i++) {//此层循环为将当前数组最⼤值（除了之前已经找到的最⼤值之外）放⼊数组最后⾯（nunmsSfor (j = 0; j < numsSize - i - 1; j++) {//如果两个相邻的数之间左边的⽐较⼤，则交换相邻的两个数if (order[j] > order[j + 1]) {int u = order[j];order[j] = order[j + 1];order[j + 1] = u;}}}//更新答案数组for (int i = 0; i < numsSize; i++) {//将当前数在有序数组中的下标存⼊答案数组，order：有序数组，numsSize：数组⻓度，nums[ans[i] = low(order, numsSize, nums[i]);}//更新数组⻓度并返回数组*returnSize = numsSize;return ans;
}// 方法三：
int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize) {//定义答案数组，排序数组，哈希表数组int* ans = malloc(numsSize * sizeof(int));int* order = malloc(numsSize * sizeof(int));int* bucket = malloc(110 * sizeof(int));int i = 0, j = 0;//初始化哈希表数组中的值为-1//防⽌出现重复情况，哈希表⼀个下标放⼊多个值，仅当桶⾥值为-1时更新桶⾥的值for (i = 0; i < 101; i++) bucket[i] = -1;//将原数组中的值放⼊排序数组for (i = 0; i < numsSize; i++) order[i] = nums[i];//此段代码为冒泡排序，时间复杂度较⾼，有兴趣可以修改此段代码为其他排序代码，内容同上for (i = 0; i < numsSize; i++) {for (j = 0; j < numsSize - i - 1; j++) {if (order[j] > order[j + 1]) {int u = order[j];order[j] = order[j + 1];order[j + 1] = u;}}}//定义变量cnt记录当前数是否重复出现，若第⼀次出现则记录当前位置，使得之后的重复的数都被赋值int cnt = 0;for (i = 0; i < numsSize; i++) {//若第⼀次出现，则更新cntif (bucket[order[i]] == -1) cnt = i;//将当前数第⼀次出现的位置放⼊桶⾥bucket[order[i]] = cnt;}//遍历原数组，将数字在桶⾥的值放⼊答案数组for (i = 0; i < numsSize; i++) {ans[i] = bucket[nums[i]];}//更新数组⻓度并返回答案数组*returnSize = numsSize;return ans;
}

---

34. 字⺟在字符串中的百分⽐

Leedcode链接

---

---

代码如下（示例）：

int percentageLetter(char* s, char letter)
{int sum = 0;int ret = strlen(s);while (*s){if (*s == letter){sum++;}s++;}return sum * 100 / ret;
}

---

35. ⾯试题 01.01. 判定字符是否唯⼀

Leedcode链接

---

---

代码如下（示例）：

bool isUnique(char* astr) {int i = 0;//定义数组⽤来标记每个字⺟是否出现，0为未出现过，1为已经出现过bool hash[26] = { 0 };//遍历字符串，当字符不为空时进⼊循环while (astr[i]) {//若当前字⺟之前被标记过返回falseif (hash[astr[i] - 'a'] == 1)return false;//否则标记当前字⺟elsehash[astr[i] - 'a'] = 1;//下标+1，继续遍历下⼀个字符i++;}//遍历结束，未出现重复，则返回truereturn true;
}bool isUnique(char* astr) {int i = 0;//定义变量⽤来标记int s = 0;while (astr[i]) {//在这⾥定义u直接表⽰为左移后的结果//astr[i]-'a'即为astr[i]在字⺟表中的顺序-1，即上⾯所说的w-1int u = 1 << (int)(astr[i] - 'a');//若未被标记则标记此位，即s加上u;if ((u & s) == 0) s += u;//若之前已经被标记，则返回false;else return false;i++;}//遍历结束不存在重复则返回truereturn true;
}

---

36. IP 地址⽆效化 - 题号：1108

Leedcode链接

---

---

代码如下（示例）：

char* defangIPaddr(char* address)
{int len = strlen(address);char* ptr = NULL;char* ans = ptr = malloc(len + 6 + 1);while (*address){if (*address == '.'){*ptr = '[';ptr++;*ptr = '.';ptr++;*ptr = ']';ptr++;}else{*ptr++ = *address;}address++;}*ptr = '\0';return ans;
}

---

37. 句⼦中的最多单词数

Leedcode链接

---

---

代码如下（示例）：

int mostWordsFound(char** sentences, int sentencesSize)
{int i = 0;int max = 0;for (i = 0; i < sentencesSize; i++){int word = 1;int j = 0;while (sentences[i][j]){if (sentences[i][j] == ' '){word++;}j++;}if (max < word){max = word;}}return max;
}

---

38. 反转两次的数字 - 题号：2119

Leedcode链接

---

)

---

---

代码如下（示例）：

bool isSameAfterReversals(int num)
{int tmp = num;long long n = 0;while (tmp){n = n * 10 + tmp % 10;tmp /= 10;}while (n){tmp = tmp * 10 + n % 10;n /= 10;}if (tmp == num){return true;}else{return false;}
}bool isSameAfterReversals(int num)
{int tmp = num;int n = 0;while (tmp){n = n * 10 + tmp % 10;tmp /= 10;}while (n){tmp = tmp * 10 + n % 10;n /= 10;}return num == tmp;
}// 方法二：只要num个位数不为0，返回正确
bool isSameAfterReversals(int num)
{return num == 0 || num % 10 != 0;
}

---

39. 找出数组的最⼤公约数-题号：1979

Leedcode链接

---

---

---

代码如下（示例）：

int findGCD(int* nums, int numsSize)
{int i = 0;for (i = 0; i < numsSize - 1; i++){for (int j = 0; j < numsSize - 1 - i; j++){if (nums[j] < nums[j + 1]){int tmp = nums[j];nums[j] = nums[j + 1];nums[j + 1] = tmp;}}}int a = nums[0];int b = nums[numsSize - 1];int c = (a > b ? b : a);while (1){if (a % c == 0 && b % c == 0){break;}c--;}return c;
}

---

40. 统计位数为偶数的数字-题号：1295

Leedcode链接

---

---

---

代码如下（示例）：

int findNumbers(int* nums, int numsSize)
{int sum = 0;int i = 0;for (i = 0; i < numsSize; i++){int ret = nums[i];int tmp = 0;while (ret){tmp++;ret = ret / 10;}if (tmp % 2 == 0){sum++;}}return sum;
}#include<string.h>
int findNumbers(int* nums, int numsSize) 
{int i = 0;int ans = 0;//定义字符串数组⽤来存放转化后的字符串 char arr[7] = {};for (i = 0; i < numsSize; i++) {//将数字转化为字符串 sprintf(arr, "%d", nums[i]);//字符串⻓度为偶数，即当前数字位数为偶数时记录⼀次 if (strlen(arr) % 2 == 0) {ans++;}}//返回位数为偶数的数字个数 return ans;
}

---

41. 分割数组中数字的数位-题号：2553

Leedcode链接

---

---

---

代码如下（示例）：

int* separateDigits(int* nums, int numsSize, int* returnSize) 
{int i = 0;int tmp = 0;//定义数组作为返回值并且分配内存 int* ans = malloc(6 * 1000 * sizeof(int));int k = 0;for (i = 0; i < numsSize; i++) {int n = nums[i];int j = 0;//反转n放⼊tmp while (n){tmp = tmp * 10 + n % 10;n /= 10;}//正向存储到ans while (tmp){ans[k++] = tmp % 10;tmp /= 10;}}*returnSize = k;return ans;
} 

---

但这样的方法有弊端，因为 80 逆转 之后就是 8 了，没发计算 0 和 8
所以可以采用以下的方法进行运算，使用三个函数进行封装

---

---

代码如下（示例）：

{int length = 0;while (num != 0){length++;num /= 10;}return length;
}void reverse(int* answer, int start, int end)
{for (int i = start, j = end; i < j; i++, j--) {int temp = answer[i];answer[i] = answer[j];answer[j] = temp;}
}int* separateDigits(int* nums, int numsSize, int* returnSize) 
{int totalLength = 0;for (int i = 0; i < numsSize; i++) {totalLength += getLength(nums[i]);}int* answer = (int*)malloc(sizeof(int) * totalLength);*returnSize = totalLength;int index = 0;for (int i = 0; i < numsSize; i++) {int start = index;int temp = nums[i];while (temp != 0) {answer[index] = temp % 10;index++;temp /= 10;}reverse(answer, start, index - 1);}return answer;
}

---

42. 速算机器⼈-题号：LCP17

Leedcode链接

---

---

---

代码如下（示例）：

int calculate(char* s) 
{//定义x和y并初始化 int x = 1;int y = 0;//遍历字符串数组，字符串数组指针直接指向字符串⾸位，则遍历时直接获取指针指向的字符，判断while (*s) {//判断当前字符，并执⾏相应操作 if (*s == 'A')x = 2 * x + y;else if (*s == 'B')y = 2 * y + x;//字符串指针后移，完成遍历操作 s++;}//返回操作执⾏完成后的两值之和 return x + y;
}

---

43. 转换成⼩写字⺟-题号：709

Leedcode链接

---

---

---

代码如下（示例）：

char* toLowerCase(char* s)
{int i = 0;while (s[i]){if (s[i] >= 'A' && s[i] <= 'Z'){s[i] += 32;}i++;}return s;
} 

---

44. 找出中枢整数-题号：2485

Leedcode链接

---

---

---

代码如下（示例）：

int pivotInteger(int n) 
{int i;//遍历1~n for (i = 1; i <= n; i++) {//若i满⾜1~i的和与i~n的和相等，则返回i if ((1 + i) * i / 2 == (i + n) * (n - i + 1) / 2) return i;}//当1~n都不能满⾜题意时，返回-1 return -1;
}

---

45. 公因⼦的数⽬-题号：2427

Leedcode链接

---

---

---

代码如下（示例）：

int commonFactors(int a, int b)
{int c = a > b ? b : a;int i = 0;int sum = 0;for (i = 1; i <= c; i++){if (a % i == 0 && b % i == 0){sum++;}}return sum;
}

---

46. 执⾏操作后的变量值-题号：2011

Leedcode链接

---

---

---

代码如下（示例）：

int finalValueAfterOperations(char** operations, int operationsSize) 
{int i;//定义变量并初始化 int x = 0;//遍历操作数组 for (i = 0; i < operationsSize; i++) {//使⽤strcmp函数对字符串进⾏⽐较，若字符串是"X++"或"++X"其中之⼀，则进⾏x++操作 if (!strcmp(operations[i], "X++") || !strcmp(operations[i], "++X")) {x++;}//否则进⾏x--操作 else {x--;}//另⼀种写法： /*if(operations[i][1]=='+') x++;else x--;*/}//返回最终值 return x;
}

---

47. 设计停车系统-题号：1603

Leedcode链接

---

---

---

代码如下（示例）：

typedef struct 
{int parking[3];
}ParkingSystem;// 初始化停车场系统
ParkingSystem* parkingSystemCreate(int big, int medium, int small) 
{// 为停车场系统指针分配内存ParkingSystem* obj = (ParkingSystem*)malloc(sizeof(ParkingSystem));// 分别将三个函数参数赋值给停车场系统的停车位数量obj->parking[0] = big;obj->parking[1] = medium;obj->parking[2] = small;// 返回停车场系统指针return obj;
}
// 添加车辆
bool parkingSystemAddCar(ParkingSystem* obj, int carType) 
{// 如果相应的停车位数量为0，则添加失败if (obj->parking[carType - 1] == 0) {return false;}// 否则添加成功，相应停车位数量减⼀else {obj->parking[carType - 1]--;return true;}
}
// 释放停车场系统内存
void parkingSystemFree(ParkingSystem* obj) 
{ free(obj); 
}

---

48. 翻转图像-题号：832

Leedcode链接

---

---

---

代码如下（示例）：

int** flipAndInvertImage(int** image, int imageSize, int* imageColSize,int* returnSize, int** returnColumnSizes) 
{int i = 0;int j = 0;// ⽔平翻转for (i = 0; i < imageSize; i++) {int l = 0;int r = imageSize - 1;// 逆序当前⾏，当l=r时不需要交换while (l < r) {// 交换int tmp = image[i][l];image[i][l] = image[i][r];image[i][r] = tmp;// 左指针右移，右指针左移，交换下⼀组l++;r--;}}// 遍历数组所有位置进⾏反转for (i = 0; i < imageSize; i++) {for (j = 0; j < imageSize; j++) {// ⽤1减去当前值即可完成反转image[i][j] = 1 - image[i][j];}}// 另⼀种写法，在逆序时直接反转，⽆实际复杂度优化，只是提⾼代码复⽤率/*for(i=0; i<imageSize; i++) {int l = 0;int r = imageSize-1;//逆序当前⾏，当l=r时不需要交换while(l<r) {//交换int tmp = image[i][l];image[i][l] = image[i][r];image[i][r] = tmp;//反转image[i][l]=1-image[i][l];image[i][r]=1-image[i][r];l++;r--;}//当l=r时不需要交换，但是需要反转if(l==r) image[i][l]=1-image[i][l];}*/// 参数的解释很重要，数组的⾏列长度都未发⽣变化，直接赋值为原数组长度*returnSize = imageSize;*returnColumnSizes = imageColSize;// 返回操作完成后的数组return image;
}

---

49. 链表中倒数第k个节点-题号：剑指offer22

Leedcode链接

---

---

---

代码如下（示例）：

struct ListNode* trainingPlan(struct ListNode* head, int cnt) 
{if (head == NULL) {return NULL;}struct ListNode* n2 = head;struct ListNode* n1 = head;int i = 0;for (i = 0; i < cnt; i++) {if (n2->next != NULL) {n2 = n2->next;} else {return n1;break;}}while (n2 != NULL) {n1 = n1->next;n2 = n2->next;}return n1;
}

---

50. ⼆进制链表转整数-题号：1290

Leedcode链接

---

---

---

代码如下（示例）：

int getDecimalValue(struct ListNode* head) 
{int ret = 0;// 定义链表指针⽤作遍历整个链表struct ListNode* cur = head;// 链表指针不为空时进⼊循环while (cur) {// 左移⼀位后将当前值添加⾄最低位ret = (ret << 1) + cur->val;// 因为左移操作后最低位为0，任何数与0进⾏或操作都是不变的所以上式也可以写为// ret = (ret << 1) | cur->val;// 指针只想下⼀位数字或者链表结尾cur = cur->next;}// 返回最终得到的数字return ret;
}

---

51. 矩阵对角元素的和-题号：1572

Leedcode链接

---

---

---

代码如下（示例）：

int diagonalSum(int** mat, int matSize, int* matColSize) 
{int i = 0;// 定义变量存储答案int sum = 0;// 循环遍历数组for (i = 0; i < matSize; i++) {int j = 0;for (j = 0; j < matSize; j++) {// 判断当前数是否在对⻆线上if (i == j || i + j == matSize - 1) {// 若在对⻆线上则将其添加⾄答案中sum += mat[i][j];}}}// 返回答案return sum;
}

---

52. 汉明距离-题号：461

Leedcode链接

---

---

---

代码如下（示例）：

int hammingDistance(int x, int y) 
{int r = x^y;int ret = 0;while(r){ret++;r = r&(r-1);}return ret;
}

---

53. 只出现⼀次的数字Ⅲ-题号：260

Leedcode链接

---

---

---

代码如下（示例）：

int* singleNumber(int* nums, int numsSize, int* returnSize) 
{int* ans = (int*)calloc(2, sizeof(int));int ret = 0;int i = 0;// 计算数组中所有数异或起来的结果retfor (i = 0; i < numsSize; i++) {ret ^= nums[i];}// 从低位往⾼位遍历计算ret的⼆进制中哪⼀位是1int pos = 0;for (i = 0; i < 32; i++) {if (((ret >> i) & 1) == 1) {pos = i;break;}}// 3. 分组异或for (i = 0; i < numsSize; i++) {// 若当前数pos位为1，作为其中⼀组对ans[0]进⾏异或操作if (((nums[i] >> pos) & 1) == 1) {ans[0] ^= nums[i];}// 否则，作为另⼀组对ans[1]进⾏异或操作。else {ans[1] ^= nums[i];}}// ans[1]另⼀种计算⽅法// ans[1]=ret^ans[0];// 更新数组长度*returnSize = 2;// 返回答案数组return ans;
}

---

54. 颠倒⼆进制位-题号：190

Leedcode链接

---

---

---

代码如下（示例）：

uint32_t reverseBits(uint32_t n) 
{int i = 0;// 定义⼀个⽆符号整型ansuint32_t ans = 0;// 从低位往⾼位遍历，当ifor (i = 1; i <= 32; i++) {// 将原数的第i+1位赋值给ans的第32-(i+1)+1位ans |= ((n >> (i - 1)) & 1) << (31 - i + 1);}// 返回答案return ans;
}

---

55. 检查两个字符串数组是否相等-题号：1662

Leedcode链接

---

---

---

代码如下（示例）：

bool arrayStringsAreEqual(char** word1, int word1Size, char** word2, int word2Size)
{int i = 0;char name1[1001] = { 0 };char name2[1001] = { 0 };for (i = 0; i < word1Size; i++){strcat(name1, word1[i]);}for (i = 0; i < word2Size; i++){strcat(name2, word2[i]);}return (strcmp(name1, name2) == 0);
}bool arrayStringsAreEqual(char** word1, int word1Size, char** word2, int word2Size)
{//定义指向字符串数组的指针指向数组起始位置，并定义两个变量指向两个字符串的字符位置 int x = 0, y = 0, i = 0, j = 0;//同时遍历两个字符串数组 while (x < word1Size && y < word2Size) {//⽐较当前指向的两个字符是否相等 if (word1[x][i] != word2[y][j]) {//不相等直接返回false return false;}//指向字符的变量后移 i++;//如果指针当前指向空，则遍历下⼀个字符串，并且重新初始化字符指针 if (word1[x][i] == '\0') {x++;i = 0;}//同上 j++;if (word2[y][j] == '\0') {y++;j = 0;}}//若两个字符串遍历同时结束并未发现不相同字符时返回true，否则返回false return x == word1Size && y == word2Size;
} 

---

56. 按⾝⾼排序-题号：2418

Leedcode链接

---

---

---

代码如下（示例）：

char** sortPeople(char** names, int namesSize, int* heights, int heightsSize, int* returnSize)
{// 冒泡排序排两个数组int i = 0;for (i = 0; i < heightsSize - 1; i++){int j = 0;for (j = 0; j < heightsSize - 1 - i; j++){if (heights[j] < heights[j + 1]){int tmp = heights[j];heights[j] = heights[j + 1];heights[j + 1] = tmp;char* name = NULL;name = names[j];names[j] = names[j + 1];names[j + 1] = name;}}}*returnSize = heightsSize;return names;
}

---

57. 删除每⾏中的最⼤值-题号：2500

Leedcode链接

---

---

---

代码如下（示例）：

//定义qsort函数中的排序参数 
int cmp_int(const void* e1, const void* e2) 
{return *(int*)e1 - *(int*)e2;
}
int deleteGreatestValue(int** grid, int gridSize, int* gridColSize) 
{int i = 0;int ans = 0;//先对数组每⼀⾏排序，从⼩到⼤和从⼤到⼩都可以，只需保证每次删除的数在同⼀列即可 for (i = 0; i < gridSize; i++) {qsort(grid[i], *gridColSize, sizeof(int), cmp_int);}int j = 0;//定义变量，初始化为最⼤列下标 int y = *gridColSize - 1;//求出数组最后⼀列的最⼤值，加到ans上，然后y--，遍历每⼀列 while (y >= 0) {int max = grid[0][y];//求当前列的最⼤值 for (j = 1; j < gridSize; j++) {if (max < grid[j][y]) {max = grid[j][y];}}//将最⼤值添加⾄ans ans += max;y--;}//返回答案 return ans;
}

---

58. 最富有客⼾的资产总量-题号：1672

Leedcode链接

---

---

---

代码如下（示例）：

int maximumWealth(int** accounts, int accountsSize, int* accountsColSize)
{int max = 0;int i = 0;for (i = 0; i < accountsSize; i++){int j = 0;int tmp = 0;for (j = 0; j < *accountsColSize; j++){int max = accounts[0][0];tmp += accounts[i][j];}if (max < tmp){max = tmp;}}return max;
}

---

59. 统计能整除数字的位数-题号：2520

Leedcode链接

---

---

---

代码如下（示例）：

int countDigits(int num) 
{int cnt = 0;int tmp = num;while(tmp){if(num % (tmp % 10) == 0){cnt++;}tmp = tmp/10;}return cnt;
}

---

60. 重新排列数组-题号：1470

Leedcode链接

---

---

---

代码如下（示例）：

int* shuffle(int* nums, int numsSize, int n, int* returnSize)
{int i = 0;int* ret = (int*)malloc(2 * n * sizeof(int));for (i = 0; i < n; i++){ret[2 * i] = nums[i];ret[2 * i + 1] = nums[i + n];}*returnSize = 2 * n;return ret;
}

---

61. 矩阵中的局部最⼤值-题号：2373

Leedcode链接

---

---

---

代码如下（示例）：

int Max(int x, int y) { return x > y ? x : y; }
int** largestLocal(int** grid, int gridSize, int* gridColSize, int* returnSize,int** returnColumnSizes) {// 使⽤malloc模拟开辟⼀个⼆维数组int** ans = malloc((gridSize - 2) * sizeof(int*));int i = 0;// 为每个⼀维数组开辟空间for (i = 0; i < gridSize - 2; i++) {ans[i] = malloc((gridSize - 2) * sizeof(int));}// 遍历数组并忽略⽆法取得3×3矩阵的情况for (i = 0; i < gridSize - 2; i++) {int j = 0;for (j = 0; j < gridSize - 2; j++) {int x = 0;int y = 0;// 求得最⼤值，并将其赋值给ans数组相对应下标的元素for (x = i; x <= i + 2; x++) {for (y = j; y <= j + 2; y++) {ans[i][j] = Max(ans[i][j], grid[x][y]);}}}}// 更新数组长度*returnSize = gridSize - 2;// 更新数组每⼀维长度*returnColumnSizes = malloc((gridSize - 2) * sizeof(int));for (i = 0; i < gridSize - 2; i++) {(*returnColumnSizes)[i] = gridSize - 2;}// 返回⽣成的矩阵return ans;
}
}

---

62. 判断句⼦是否为全字⺟句-题号：1832

Leedcode链接

---

---

---

代码如下（示例）：

bool checkIfPangram(char* sentence)
{// ⽤于记录字⺟表中每个字⺟是否在sentence中出现过，初始化为0int exist[26] = { 0 };int i = 0;// 遍历sentence中的每个字符while (*sentence){// 将对应字⺟表中的字⺟在exist数组中的值设为1exist[*sentence - 'a'] = 1;sentence++;}// 遍历exist数组for (i = 0; i < 26; i++){// 如果存在某个字⺟在sentence中未出现，则返回falseif (exist[i] == 0)return false;}// sentence为全字⺟句，返回truereturn true;
}

---

63. 宝⽯与⽯头-题号：771

Leedcode链接

---

---

---

代码如下（示例）：

int numJewelsInStones(char* jewels, char* stones)
{int sum = 0;while (*jewels){char* tmp = stones;while (*tmp){if (*jewels == *tmp){sum++;}tmp++;}jewels++;}return sum;
}int numJewelsInStones(char* jewels, char* stones) 
{int n = 0;//定义⼀个哈希数组，将英⽂字⺟映射到ASCII码表中，其最⼤值和最⼩值之差为57。 bool hash[60] = { 0 };//遍历jewels while (*jewels) {//标记jewels中出现的字符 hash[*jewels - 'A'] = 1;jewels++;}//遍历stones while (*stones) {//判断当前字符是否被标记过 if (hash[*stones - 'A'])n++;stones++;}//返回答案 return n;
}

---

64. 交替数字和-题号：2544

Leedcode链接

---

---

---

代码如下（示例）：

// 假设成立时候，flag = -1，返回sum
// 假设不成立时，flag = 1 ，返回-sum
int alternateDigitSum(int n)
{int flag = 1;int sum = 0;while (n){sum += flag * (n % 10);flag = -flag;n = n / 10;}return -flag * sum;
}

---

65. 找到最⾼海拔-题号：1732

Leedcode链接

---

---

---

代码如下（示例）：

int largestAltitude(int* gain, int gainSize) 
{int i = 0;//定义⼀个变量m记录最⾼海拔，并初始化为第⼀个点的海拔 int m = gain[0];for (i = 1; i < gainSize; i++) {//更新gain数组当前元素为当前的前缀和 gain[i] += gain[i - 1];//更新m为当前最⼤海拔 if (gain[i] > m){m = gain[i];}}//特判若所有点的海拔都低于初始值，则更新m为0 if (m < 0){m = 0;}//返回最⾼海拔 return m;
}

---

66. 整数的各位积和之差-题号：1281

Leedcode链接

---

---

---

代码如下（示例）：

int subtractProductAndSum(int n)
{int sum1 = 0;int sum2 = 1;while (n){sum1 += (n % 10);sum2 *= (n % 10);n = n / 10;}return sum2 - sum1;
}

---

67. 统计⼀致字符串的数⽬ - 题号：1684

Leedcode链接

---

---

---

代码如下（示例）：

int countConsistentStrings(char* allowed, char** words, int wordsSize) {int i = 0;int count = 0;//遍历words数组for (i = 0; i < wordsSize; i++) {int j = 0;//假定全部出现int flag = 1;//遍历每⼀个字符while (words[i][j]) {if (NULL == strchr(allowed, words[i][j])) {//有字符没出现flag = 0;break;}j++;}//更新计数器的值count += flag;}//返回计数器的值return count;
}

---

68. 左旋转字符串 - 题号：剑指 Offer 58 - Ⅱ

Leedcode链接

---

---

---

代码如下（示例）：

char* dynamicPassword(char* password, int target)
{int i = 0;int len = strlen(password);for (i = 0; i < target; i++){char tmp = password[0];int j = 0;for (j = 0; j < len - 1; j++){password[j] = password[j + 1];}password[len - 1] = tmp;}return password;
}void reverse(char* left, char* right) 
{//反转两个指针之间的内容while (left < right) {//交换两个指针指向的的内容char tmp = *left;*left = *right;*right = tmp;//两个指针向对⽅靠拢，继续进⾏交换left++;right--;}
}
char* reverseLeftWords(char* s, int k) 
{//定义变量⽤来记录字符串⻓度int len = strlen(s);//第⼀次反转reverse(s, s + k - 1);//第⼆次反转reverse(s + k, s + len - 1);//整体反转reverse(s, s + len - 1);//返回反转后的字符串return s;
}

---

69. 解码异或后的数组

Leedcode链接

---

---

---

代码如下（示例）：

int* decode(int* encoded, int encodedSize, int first, int* returnSize) 
{//a^b = c//c^a --> a^b^a = b//定义arr数组并分配内存int* arr = (int*)malloc((encodedSize + 1) * sizeof(int));//为arr数组第⼀个元素赋值arr[0] = first;int i = 0;//为arr数组元素依次赋值for (i = 1; i < encodedSize + 1; i++) {arr[i] = encoded[i - 1] ^ arr[i - 1];}//更新数组⻓度并返回数组*returnSize = encodedSize + 1;return arr;
}

---

70. 好数对的数⽬ - 题号：1512

Leedcode链接

---

---

---

代码如下（示例）：

int numIdenticalPairs(int* nums, int numsSize)
{int sum = 0;int i = 0;for (i = 0; i < numsSize; i++){for (int j = i + 1; j < numsSize; j++){if (nums[i] == nums[j]){sum++;}}}return sum;
}int numIdenticalPairs(int* nums, int numsSize) 
{int i = 0;//计数器int cnt = 0;//定义哈希表int* arr = (int*)malloc((101) * sizeof(int));// 将每个元素赋值为 0for (int i = 1; i < 101; i++) {arr[i] = 0;}//遍历数组for (i = 0; i < numsSize; i++) {//计数器加上当前元素在数组前⾯位置中出现的次数，并令出现的次数加⼀cnt += arr[nums[i]]++;}////释放哈希表内存free(arr);//返回计数器return cnt;
}

---

71. 拥有最多糖果的孩⼦ - 题号：1431

Leedcode链接

---

---

---

代码如下（示例）：

bool* kidsWithCandies(int* candies, int candiesSize, int extraCandies, int* returnSize)
{int i = 0;bool* nums = (bool*)malloc(candiesSize * sizeof(bool));for (i = 0; i < candiesSize; i++){int ret = candies[i] + extraCandies;int j = 0;int flag = 0;for (j = 0; j < candiesSize; j++){if (ret < candies[j]){flag = 1;}}if (flag == 1){nums[i] = false;}else{nums[i] = true;}}*returnSize = candiesSize;return nums;
}

---

72. 第⼀个出现两次的字⺟

Leedcode链接

---

---

---

代码如下（示例）：

char repeatedCharacter(char* s)
{// 定义哈希数组bool arr[26] = { 0 };// 遍历字符串while (*s){// 检查当前字⺟是否被标记过，若被标记则直接返回当前字⺟if (arr[*s - 'a'] == 1){return *s;}// 否则标记当前字⺟arr[*s - 'a'] = 1;s++;}// 返回任意⼀个字符，防⽌编译错误return ' ';
}
} 

---

73. 统计星号 - 题号：2315

Leedcode链接

---

---

---

代码如下（示例）：

int countAsterisks(char* s)
{int count = 0;int flag = 0;while (*s){if (*s == '|'){flag = !flag;}if (flag == 1){// 在两个 | 之间s++;continue;}if (*s == '*'){count++;}s++;}return count;
}

---

74. 数组串联 - 题号：1929

Leedcode链接

---

---

---

代码如下（示例）：

int* getConcatenation(int* nums, int numsSize, int* returnSize) 
{int* newnums = (int*)malloc(2 * numsSize * sizeof(int));*returnSize = 2 * numsSize;int i = 0;for(i=0;i<numsSize ;i++){newnums[i] = nums[i];}for(i=0;i<numsSize;i++){newnums[i+numsSize] = nums[i];}return newnums;
}

---

75. 左右元素和的差值 - 题号：2574

Leedcode链接

---

---

---

代码如下（示例）：

int* leftRigthDifference(int* nums, int numsSize, int* returnSize) 
{// 定义前缀和与后缀和数组int leftSum[numsSize];int rightSum[numsSize];// 初始化前缀和数组的⾸位和后缀和数组的末位leftSum[0] = rightSum[numsSize - 1] = 0;int i = 0;// 定义ans数组int* answer = (int*)malloc(numsSize * sizeof(int));// 为前缀和数组与后缀和数组赋值for (i = 1; i < numsSize; i++) {leftSum[i] = leftSum[i - 1] + nums[i - 1];// 后缀和数组⼀定要先为后⾯的元素赋值rightSum[numsSize - i - 1] =rightSum[numsSize - i] + nums[numsSize - i];}// 求出ans数组for (i = 0; i < numsSize; i++) {answer[i] = abs(leftSum[i] - rightSum[i]);}// 更新数组⻓度后返回数组*returnSize = numsSize;return answer;
}

---

76. 爬楼梯 - 题号：70

Leedcode链接

---

---

---

代码如下（示例）：

// 方法一：超出时间限制
int sum(int n) 
{//基本情况，需要终⽌递归，1~1的所有数的和为1本⾝，直接返回1if (n == 1) return 1;//否则返回1~n-1所有数的和加上n本⾝，即1~n所有数的和return n + sum(n - 1);
}
int main() {//假设n为5，求得1~5之间所有数的和printf("%d", sum(5));
}// 方法二：递归方法优化，记忆路线
//递归时间复杂度⾼
int climb(int x) {//若x为1或2，则返回x（⾛到第⼀阶台阶的⽅法数为1，⾛到第⼆阶台阶的⽅法数为2）if (x <= 2) return x;//返回从第⼀阶台阶⾛到第x-1阶和第x-2阶台阶的⽅法数的和return climb(x - 1) + climb(x - 2);
}
int climbStairs(int n) {//返回从第⼀阶台阶⾛到第n阶台阶的⽅法数return climb(n);
}// 方法三：动态规划
//定义全局变量数组，⽤来记忆化搜索
int mem[50];
//定义递归函数
int climb(int x) {//若参数⼩于等于2，则返回参数本⾝if (x <= 2) return x;//若函数值已经被计算过，则返回这个值if (mem[x] != -1) return mem[x];//否则计算这个函数值并返回return mem[x] = climb(x - 1) + climb(x - 2);
}
int climbStairs(int n) {int i = 0;//初始化记忆数组for (i = 1; i <= n; i++) mem[i] = -1;//返回从第⼀阶台阶⾛到第n阶台阶的⽅法数return climb(n);
}int climbStairs(int n) {//定义数组⽤来记录每⼀个位置的元素值int climb[50];//初始化前两个位置的元素值climb[1] = 1;climb[2] = 2;int i = 0;//遍历求得每个位置的元素值for (i = 3; i <= n; i++) climb[i] = climb[i - 1] + climb[i - 2];//返回第n个位置的元素值，即从第⼀阶台阶⾛到第n阶台阶的⽅法数return climb[n];
}// 方法四：动态规划空间优化
//递归时间复杂度⾼
int climbStairs(int n) {//特判n⼩于等于2的情况if (n <= 2)return n;else {//定义三个变量就三个位置的元素值int a = 1;int b = 2;int c = 0;//进⾏n-2次操作while (n > 2) {//将a和b的和赋值给c，然后将b的值赋值给a，将c的值赋值给bc = a + b;a = b;b = c;n--;}//返回c的值return c;}
}

---

77. ⼆进制中1的个数 - 题号：剑指 Offer 15

Leedcode链接

---

---

代码如下（示例）：

**int hammingWeight(uint32_t n) 
{int i = 0;int cnt = 0;for (i = 0; i < 32; i++) {if (((n >> i) & 1) == 1) {cnt++;}}return cnt;
}
// int hammingWeight(uint32_t n) {
// int cnt = 0;
// while(n) {
// //最低位为1表⽰n为奇数
// if(n%2 == 1) //if((n&1)==1)
// cnt++;
//
// //右移操作相当于除以2
// n/=2; //n>>=1
// }
// return cnt;
// }int hammingWeight(uint32_t n) 
{//定义变量作为计数器int cnt = 0;//计算n的⼆进制形式中1的个数while (n) {n = n & (n - 1);cnt++;}//返回答案return cnt;
}**

---

78. ⼆分查找 - 题号：704

Leedcode链接

---

---

---

代码如下（示例）：

int search(int* nums, int numsSize, int target)
{int left = 0;int right = numsSize - 1;while (left <= right){int mid = (left + right) / 2;if (target > nums[mid]){left = mid + 1;}else if (target < nums[mid]){right = mid - 1;}else{return mid;}}return -1;
}

---

79. 删除有序数组中的重复项

Leedcode链接

---

---

---

代码如下（示例）：

int removeDuplicates(int* nums, int numsSize)
{int fast = 1;int slow = 1;while (fast <= numsSize - 1){if (nums[fast] != nums[fast - 1]){nums[slow] = nums[fast];slow++;}fast++;}return slow;
}

---

80. 排序矩阵查找 - 题号：⾯试题 10.09

Leedcode链接

---

---

---

代码如下（示例）：

bool searchMatrix(int** matrix, int matrixSize, int matrixColSize, int target)
{int i = 0;for (i = 0; i < matrixSize; i++){int j = 0;for (j = 0; j < matrixColSize; j++){if (target == matrix[i][j]){return true;}}}return false;
}

---

81. 只出现⼀次的数字 - 题号:136

Leedcode链接

---

---

---

代码如下（示例）：

int singleNumber(int* nums, int numsSize) {int i = 0;int ret = 0;//将每个数异或起来for (i = 0; i < numsSize; i++) {ret ^= nums[i];}return ret;//nums[i]^=nums[i-1];//return nums[numsSize-1];
}

---

82. 反转字符串 - 题号:344

Leedcode链接

---

---

---

代码如下（示例）：

void reverseString(char* s, int sSize)
{// 双指针的方法int left = 0;int right = sSize - 1;while (left <= right){char tmp = s[left];s[left] = s[right];s[right] = tmp;left++;right--;}return s;
}void reverseString(char* s, int sSize)
{char* left = s;char* right = s + sSize - 1;while (left <= right){char tmp = *left;*left = *right;*right = tmp;left++;right--;}
}

---

83. 字符串中的第⼀个唯⼀字符 - 题号:387

Leedcode链接

---

---

---

代码如下（示例）：

int firstUniqChar(char* s) 
{int arr[256] = { 0 };char* str = s;while (*str) {arr[*str++]++;}str = s;while (*str) {if (arr[*str] == 1){return str - s;}str++;}return -1;
}

---

84. 找出星型图的中⼼节点 - 题号:1791

Leedcode链接

---

---

---

代码如下（示例）：

int findCenter(int** edges, int edgesSize, int* edgesColSize) 
{//依次判断等式是否成⽴if (edges[0][0] == edges[1][0]) return edges[0][0];if (edges[0][0] == edges[1][1]) return edges[0][0];if (edges[0][1] == edges[1][0]) return edges[0][1];if (edges[0][1] == edges[1][1]) return edges[0][1];//防⽌编译错误return 0;
}

---

85. 两个数对之间的最⼤乘积差

Leedcode链接

---

---

---

代码如下（示例）：

int maxProductDifference(int* nums, int numsSize)
{// 先进行冒泡排序然后直接加减即可int i = 0;for (i = 0; i < numsSize - 1; i++){int j = 0;for (j = 0; j < numsSize - 1 - i; j++){if (nums[j] > nums[j + 1]){int tmp = nums[j];nums[j] = nums[j + 1];nums[j + 1] = tmp;}}}return (nums[numsSize - 1] * nums[numsSize - 2]) - (nums[0] * nums[1]);
}

---

86. 杨辉三⻆ - 题号：118

Leedcode链接

---

---

---

代码如下（示例）：

int** generate(int numRows, int* returnSize, int** returnColumnSizes) 
{int i = 0;//开辟存放杨辉三⻆的⼆维数组int** arr = (int**)malloc(numRows * sizeof(int*));//为每⼀维分配内存for (i = 0; i < numRows; i++) {arr[i] = (int*)malloc(numRows * sizeof(int));}//更新⾏数*returnSize = numRows;//存放每⼀⾏数据的个数*returnColumnSizes = (int*)malloc(numRows * sizeof(int));//按⾏从上到下遍历for (i = 0; i < numRows; i++) {int j = 0;//更新每⼀⾏的元素个数(*returnColumnSizes)[i] = i + 1;//初始化每⼀⾏的⾸位和末位元素为1arr[i][0] = arr[i][i] = 1;//更新中间元素，遍历前两维时不会进⼊循环，不需要特判for (j = 1; j < i; j++) {arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];}}//返回杨辉三⻆return arr;
}

---

87. 替换空格 - 题号：剑指Offer 05

Leedcode链接

---

---

---

代码如下（示例）：

char* pathEncryption(char* path)
{int len = strlen(path);int left = 0;while (left != len){if (path[left] == '.'){path[left] = ' ';}else{left++;}}return path;
}

---

88. 各位相加 - 题号：258

Leedcode链接

---

---

---

代码如下（示例）：

int addDigits(int num)
{while (num > 9){//证明还是两位数int sum = 0;while (num){sum += num % 10;num /= 10;}num = sum;}return num;
} 

---

89. 按奇偶排序数组 - 题号：905

Leedcode链接

---

---

---

代码如下（示例）：

int* sortArrayByParity(int* nums, int numsSize, int* returnSize) 
{//定义双指针int l = 0;int r = numsSize - 1;//当两指针还未相遇时查找奇数在前的情况while (l < r) {//查找最左边的奇数while ((l < r) && nums[l] % 2 == 0) {l++;}//查找最右边的偶数while ((l < r) && nums[r] % 2 == 1) {r--;}//若两指针未相遇进⾏交换if (l < r) {int tmp = nums[l];nums[l] = nums[r];nums[r] = tmp;//交换后两指针相向移动继续查找l++;r--;}}//更新数组⻓度后返回更新后的数组*returnSize = numsSize;return nums;
}

---

90. 分割平衡字符串 - 题号：1221

Leedcode链接

---

---

---

代码如下（示例）：

int balancedStringSplit(char* s) 
{//定义变量作为平衡字符串计数器int cnt = 0;//定义两个变量作为字符'L'和'R'的计数器int rc = 0;int lc = 0;//遍历字符串while (*s) {//更新字符串计数if (*s == 'R')rc++;else if (*s == 'L')lc++;//若两个字符计数器的值相等，则以上⼀个字符结尾+1作为起点，当前字符作为结尾满⾜平衡if (rc == lc)cnt++;s++;}return cnt;
}

---

91. 差的绝对值为k的数对数⽬ - 题号：2006

Leedcode链接

---

---

---

代码如下（示例）：

int countKDifference(int* nums, int numsSize, int k)
{int i = 0;int sum = 0;for (i = 0; i < numsSize; i++){int j = 0;for (j = i; j < numsSize; j++){if (k == abs(nums[i] - nums[j])){sum++;}}}return sum;
}

---

92. 打印从1到最⼤的n位数

Leedcode链接

---

---

---

代码如下（示例）：

int* countNumbers(int cnt, int* returnSize)
{int sz = pow(10, cnt) - 1;int* nums = (int*)malloc(sz * sizeof(int));for (int i = 0; i < sz; i++){nums[i] = i + 1;}*returnSize = sz;return nums;
}

---

93. ⽣成每种字符都是奇数个的字符串 - 题号：1374

Leedcode链接

---

---

---

代码如下（示例）：

char* generateTheString(int n) 
{//开辟⼀个⻓度为n+1的数组anschar* ans = malloc((n + 1) * sizeof(char));//初始化数组memset(ans, 'a', n);ans[n] = '\0';//如果n位偶数，将第⼀个改为'b'，a和b都是奇数个if (n % 2 == 0)ans[0] = 'b';//返回字符串ansreturn ans;
}

---

94. 将每个元素替换为右侧最⼤元素 - 题号：1299

Leedcode链接

---

---

---

代码如下（示例）：

int* replaceElements(int* arr, int arrSize, int* returnSize) 
{int max = -1;for (int i = arrSize - 1; i >= 0; i--) {int temp = arr[i];arr[i] = max;if (max < temp) max = temp;}*returnSize = arrSize;return arr;
}

---

95. 交替合并字符串

Leedcode链接

---

---

---

代码如下（示例）：

char* mergeAlternately(char* word1, char* word2) {int flag = 1;//定义⻓度⼤于等于两个字符串⻓度之和的字符串char* ans = calloc(201, sizeof(char));int i = 0;//遍历两字符串while (*word1 && *word2) {//判断上⼀次合并的是哪个字符串，进⾏交替合并if (flag == 1) {ans[i++] = *word1++;flag = 0;}else {ans[i++] = *word2++;flag = 1;}}//如果word1先结束，将word2剩余的内容合并if (*word1 == '\0') {while (*word2) {ans[i++] = *word2++;}}//如果word2先结束，将word1剩余的内容合并else {while (*word1) {ans[i++] = *word1++;}}//返回拼接后的字符串return ans;
}

---

96. 合并两个有序数组 - 题号：88

Leedcode链接

---

---

---

代码如下（示例）：

//定义⽐较函数
int cmp(const void* e1, const void* e2) 
{return *(int*)e1 - *(int*)e2;
}
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)
{int i = 0;//将nums2数组中的内容全部追加到nums1中for (i = 0; i < n; i++) {nums1[m + i] = nums2[i];}//将数组升序排序qsort(nums1, nums1Size, sizeof(int), cmp);
}void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) {//定义双指针分别指向nums1数组和nums2数组中的元素int p1 = 0, p2 = 0;//定义⼀个⻓度为n+m的新数组int* sorted = malloc((n + m) * sizeof(int));//当两指针都没有指向空时，进⼊循环将较⼩的元素存⼊sorted数组末位，并将相应指针后移while (p1 < m && p2 < n) {if (nums1[p1] < nums2[p2]) {sorted[p1 + p2 - 1] = nums1[p1++];}else {sorted[p1 + p2 - 1] = nums2[p2++];}}//判断是否p1指针还有剩余if (p1 < m) {while (p1 < m) sorted[p1++ + n] = nums1[p1];}//否则p2指针还有剩余else {while (p2 < n) sorted[m + p2++] = nums2[p2];}int i;//将合并后并排序的数组元素依次赋值给nums1数组for (i = 0; i != m + n; ++i) {nums1[i] = sorted[i];}
}

---

97. ⾼度检查器 - 题号：1051

Leedcode链接

---

---

---

代码如下（示例）：

int heightChecker(int* heights, int heightsSize)
{// 先用冒泡排序int i = 0;int* tmp = (int*)malloc(heightsSize * sizeof(int));memcpy(tmp, heights, heightsSize * sizeof(int));int sum = 0;for (i = 0; i < heightsSize - 1; i++){int j = 0;for (j = 0; j < heightsSize - 1 - i; j++){if (heights[j] > heights[j + 1]){int tmp = heights[j];heights[j] = heights[j + 1];heights[j + 1] = tmp;}}}for (i = 0; i < heightsSize; i++){if (heights[i] != tmp[i]){sum++;}}return sum;
}

---

98. 找出数组排序后的⽬标下标 - 题号：2089

Leedcode链接

---

---

---

代码如下（示例）：

int* targetIndices(int* nums, int numsSize, int target, int* returnSize)
{int i = 0;for (i = 0; i < numsSize - 1; i++){int j = 0;for (j = 0; j < numsSize - 1 - i; j++){if (nums[j] > nums[j + 1]){int tmp = nums[j];nums[j] = nums[j + 1];nums[j + 1] = tmp;}}}int cnt = 0;for (int i = 0; i < numsSize; i++){if (nums[i] == target)cnt++;}int* ret = (int*)malloc(cnt * sizeof(int));int sum = 0;int k = 0;for (i = 0; i < numsSize; i++){if (nums[i] == target){ret[k++] = i;}}*returnSize = cnt;return ret;
}

---

99. 反转链表 - 题号：剑指 Offer 24

Leedcode链接

---

---

---

代码如下（示例）：

typedef struct ListNode
{int val;struct ListNode* next;
}ListNode;
struct ListNode* reverseList(struct ListNode* head) {//定义两个指针⽤作反转struct ListNode* cur = head;struct ListNode* prev = NULL;//当cur不为空时，代表链表还存在未反转的节点while (cur) {//定义指针指向指针cur的下⼀个节点避免链表断裂struct ListNode* next_node = cur->next;//实现反转操作cur->next = prev;//更新两个指针以便下⼀次迭代prev = cur;cur = next_node;}//将头指针指向指针prev指向的节点，完成反转head = prev;//返回头指针return head;
}

---

100. 合并两个排序的链表 - 题号：剑指 Offer 25

Leedcode链接

---

---

---

代码如下（示例）：

typedef struct ListNode
{int val;struct ListNode* next;
}ListNode;
struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {//定义⼀个哑节点作为结果链表的头struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));dummy->val = 0;dummy->next = NULL;//定义结果链表的尾，刚开始头尾相同struct ListNode* curr = dummy;//循环⽐较两个链表的头节点while (l1 && l2) {//将较⼩的节点接⼊结果链表中，并将该节点从原链表中删除if (l1->val < l2->val) {curr->next = l1;l1 = l1->next;}else {curr->next = l2;l2 = l2->next;}//尾部后移curr = curr->next;}//其中⼀个链表为空，将另⼀个链表的剩余节点全部接⼊结果链表if (l1) {curr->next = l1;}else {curr->next = l2;}//返回哑节点dummy的next指针return dummy->next;
}

---

整体的心得

刷完这一百道题，我相信，我们对C语言有了足够多的了解和认识，
这100道题用于大学生转专业和C语言期末考试
本篇文章是作者花费了3个月制作，从高考结束一直到大一开学，
也希望我的努力可以让C语言初学者有一个很好的理解！

---

整体源代码

代码如下（示例）：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>// 1. 打印1-100的奇数
//int main()
//{
//	int i = 0;
//	for (i = 1; i <= 100; i++)
//	{
//		if (i % 2 == 1)
//			printf("%d ", i);
//	}
//	return 0;
//}
//
//int main()
//{
//	int i = 0;
//	for (i = 1; i <= 100; i += 2)
//	{
//		printf("%d ", i);
//	}
//	return 0;
//}// 打印9*9乘法表
//int main()
//{
//	int i, j;
//	for (i = 1; i <= 9; i++)
//	{
//		for (j = 1; j <= i; j++)
//		{
//			printf("%d*%d=%2d ", i, j, i * j);
//		}
//		printf("\n");
//	}
//}// 打印100-200的素数
//int main()
//{
//	int i = 0;
//	int j = 0;
//	for (i = 100; i <= 200; i++)
//	{
//		int flag = 1;
//		for (j = 2; j < i ; j++)
//		{
//			if (i % j == 0)
//			{
//				flag = 0;//不是素数
//				break;
//			}
//		}
//		if (flag == 1)
//			printf("%d ", i);
//	}
//}// 优化版本
//#include<math.h>
//int main()
//{
//	int i = 0;
//	int j = 0;
//	for (i = 101; i < 200; i+=2)
//	{
//		int flag = 1;
//		for (j = 2; j <= sqrt(i); j++)
//		{
//			if (i % j == 0)
//			{
//				flag = 0;
//				break;
//			}
//		}
//		if (flag == 1)
//			printf("%d ", i);
//	}
//}// 判断三角形
//int main()
//{
//	int a, b, c;
//	scanf("%d %d %d", &a, &b, &c);
//	if ((a + b > c && a - b < c) || (b + c > a && b - c < a) || (a + c > b && a - c < b))
//	{
//		if ((a == b) && (a != c) || (a == c) && (a != b) || (b == c) && (b != a))
//			printf("等腰三角形\n");
//		else if (a == b && b == c)
//			printf("等边三角形\n");
//		else
//			printf("普通三角形\n");
//	}
//	else
//	{
//		printf("非三角形\n");
//	}
//}// 判断三角形
//int main()
//{
//	int a, b, c;
//	scanf("%d %d %d", &a, &b, &c);
//	if (a + b > c && b + c > a && a + c > b)
//	{
//		if (a == b && b == c)
//			printf("等边三角形");
//		else if (a == b || a == c || b == c)
//			printf("等腰三角形");
//		else
//			printf("普通三角形");
//	}
//	else
//	{
//		printf("非三角形");
//	}
//}// 求最大公约数
//int main()
//{
//	int a, b;
//	int i = 0;
//	scanf("%d %d", &a, &b);
//	int c = (a > b ? b : a);
//	for (i = c; i >=1; i--)
//	{
//		if (a % i == 0 && b % i == 0)
//		{
//			printf("%d\n", i);
//			break;
//		}
//	}
//}//int main()
//{
//	int a, b;
//	int i = 0;
//	scanf("%d %d", &a, &b);
//	int c = (a > b ? b : a);
//	while (1)
//	{
//		if (a % c == 0 && b % c == 0)
//		{
//			break;
//		}
//		c--;
//	}
//	printf("%d\n", c);
//	return 0;
//}//int main()
//{
//	int a, b;
//	scanf("%d %d", &a, &b);
//	int k = 0;
//	while (k = a % b)
//	{
//		a = b;
//		b = k;
//	}
//	printf("%d\n", b);
//}
//
//
////辗转相除法递归实现
//int gcd(int a, int b)
//{
//	if (b == 0)
//		return a;
//	return gcd(b, a % b);
//}// 求两个数的最小公倍数 方法一
//int main()
//{
//	int a = 0;
//	int b = 0;
//	scanf("%d %d", &a, &b);
//	int c = (a > b ? a : b);
//	for (int i = c; i < a * b; i++)
//	{
//		if (i % a == 0 && i % b == 0)
//		{
//			printf("%d\n", i);
//			break;
//		}
//	}
//}//求两个数的最小公倍数 方法二
//int main()
//{
//	int a = 0;
//	int b = 0;
//	scanf("%d %d", &a, &b);
//	int c = a * b;
//	int k = 0;
//	// 辗转相除法求最大公约数 b
//	while (k = a % b)
//	{
//		a = b;
//		b = k;
//	}
//	printf("%d\n", c / b);
//}// error
//int main()
//{
//	int i = 1;
//	int j = 1;
//	for (i = 1; i <= 100; i++)
//	{
//		if (i % 2 == 0)
//			i = i * (-1);
//		j = j + 1 / i;
//	}
//	printf("%d\n", j);
//}//int main()
//{
//	int i = 0;
//	double sum = 0;
//	for (i = 1; i <= 100; i++)
//	{
//		if (i % 2 == 1)
//			sum += 1.0 / i;
//		else
//			sum -= 1.0 / i;
//	}
//	printf("%lf\n", sum);
//}// 第一种方法
//void bubblesort(int arr[], int sz)
//{
//    int i = 0;
//    for (i = 0; i < sz - 1; i++)
//    {
//        int j = 0;
//        for (j = 0; j < sz - 1 - i; j++)
//        {
//            if (arr[j] > arr[j + 1])
//            {
//                int tmp = arr[j];
//                arr[j] = arr[j + 1];
//                arr[j + 1] = tmp;
//            }
//        }
//    }
//}
//int main()
//{
//	int arr[10] = { 0 };
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	int sz = sizeof(arr)/sizeof(arr[0]);
//    bubblesort(arr, sz);
//    printf("%d\n", arr[9] - arr[0]);
//
//}// 第二种方法
//int main()
//{
//	int arr[10] = { 0 };
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	int Max = arr[0];
//	int Min = arr[0];
//	for (i = 1; i < 10; i++)
//	{
//		if (arr[i] > Max)
//			Max = arr[i];
//		if (arr[i] < Min)
//			Min = arr[i];
//	}
//	printf("%d\n", Max - Min);
//	return 0;
//}// 第三种方法
//int main()
//{
//	int arr;
//	scanf("%d", &arr);
//	int Max = arr;
//	int Min = arr;
//	int i = 0;
//	for (i = 1; i < 10; i++)
//	{
//		scanf("%d", &arr);
//		if (arr > Max)
//			Max = arr;
//		if (arr < Min)
//			Min = arr;
//	}
//	printf("%d\n", Max - Min);
//	return 0;
//}// 冒泡排序
//void BubbleSort(int arr[], int sz)
//{
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < sz - 1; i++)
//	{
//		for (j = 0; j < sz - 1 - i; j++)
//		{
//			if (arr[j] > arr[j + 1])
//			{
//				int tmp = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = tmp;
//			}
//		}
//	}
//}
//void arrPrintf(int arr[], int sz)
//{
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//}
//int main()
//{
//	int arr[10] = { 0 };
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	for (i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	BubbleSort(arr, sz);
//	arrPrintf(arr, sz);
//}//#include <stdio.h>
//int main()
//{
//	int arr[10] = { 0 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	for (i = 0; i < sz - 1; i++)
//	{
//		int j = 0;
//		int flag = 1;//假设待排序的数据已经有序
//		for (j = 0; j < sz - 1 - i; j++)
//		{
//			if (arr[j] > arr[j + 1])
//			{
//				flag = 0;
//				int tmp = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = tmp;
//			}
//		}
//		if (flag == 1)
//			break;
//	}
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}//#include <stdio.h>
//int main()
//{
//	int arr[10] = { 0 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	for (i = 0; i < sz - 1; i++)
//	{
//		int j = 0;
//		for (j = 0; j < sz - 1 - i; j++)
//		{
//			if (arr[j] > arr[j + 1])
//			{
//				int tmp = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = tmp;
//			}
//		}
//	}
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}// 判断盗窃者
//int main()
//{
//	int thieves = 0;
//	for (thieves = 'a'; thieves <= 'd'; thieves++)
//	{
//		if ((thieves != 'a') + (thieves == 'c') + (thieves == 'd') + (thieves != 'd') == 3)
//			printf("盗窃者是: %c", thieves);
//	}
//}// 判断自幂数
//#include <math.h>
//int main()
//{
//	int i = 0;
//	for (i = 1; i <= 100000; i++)
//	{
//		//判断i是否是?幂数
//		//1. 计算i的位数n
//		int n = 1;
//		int tmp = i;
//		while (tmp / 10)
//		{
//			n++;
//			tmp /= 10;
//		}
//		//2. 计算i的每?位的n次?之和
//		tmp = i;
//		int sum = 0;
//		while (tmp)
//		{
//			sum += (int)pow(tmp % 10, n);
//			tmp /= 10;
//		}
//		//3. 输出
//		if (sum == i)
//			printf("%d ", i);
//	}
//	return 0;
//}//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	//打印上半部分的n行
//	int i = 0;
//	for (i = 0; i < n; i++)
//	{
//		int j = 0;
//		for (j = 0; j < n - 1 - i; j++)
//		{
//			printf(" ");
//		}
//		for (j = 0; j < 2 * i + 1; j++)
//		{
//			printf("*");
//		}
//		printf("\n");
//	}
//	//打印下半部分的n-1?
//	for (i = 0; i < n; i++)
//	{
//		int j = 0;
//		for (j = 0; j <= i; j++)
//		{
//			printf(" ");
//		}
//		for (j = 0; j < 2 * (n - 1 - i) - 1; j++)
//		{
//			printf("*");
//		}
//		printf("\n");
//	}
//	return 0;
//}// 喝多少汽水
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int total = 0;
//	int empty = 0;
//	total += n;
//	empty += n;
//	while (empty >= 2)
//	{
//		total += empty / 2;
//		empty = empty / 2 + empty % 2;
//	}
//	printf("%d\n", total);
//}// 第二种方法
//int main()
//{
//	int n = 0;
//	int total = 0;
//	scanf("%d", &n);
//	if (n == 0)
//		total = 0;
//	else
//		total = 2 * n - 1;
//	printf("%d\n",total);
//	return 0;
//}////方法一：不使用库函数
//int main()
//{
//	char buf[31] = { 0 };
//	scanf("%[^\n]", buf);
//	int i = 0;
//	while (buf[i])
//	{
//		if (buf[i] >= 'a' && buf[i] <= 'z')
//			buf[i] -= 32;
//
//		else if (buf[i] >= 'A' && buf[i] <= 'Z')
//			buf[i] += 32;
//		i++;
//	}
//	printf("%s\n", buf);
//	return 0;
//}
////?法2：使?库函数
//#include <ctype.h>
//int main()
//{
//	char buf[31] = { 0 };
//	scanf("%[^\n]s", buf);
//	int i = 0;
//	while (buf[i])
//	{
//		if (islower(buf[i]))
//			buf[i] = toupper(buf[i]);
//		else if (isupper(buf[i]))
//			buf[i] = tolower(buf[i]);
//		i++;
//	}
//	printf("%s\n", buf);
//	return 0;
//}// 交换两个整数
//void Swap(int* pa, int* pb)
//{
//	int tmp = *pa;
//	*pa = *pb;
//	*pb = tmp;
//}
//int main()
//{
//	int a, b;
//	scanf("%d %d", &a, &b);
//	Swap(&a, &b);
//	printf("%d %d\n", a, b);
//}// 求两个整数的平均值
//int average(int a, int b)
//{
//	return (a+b)/2;
//}
//int average(int a, int b)
//{
//	return a+(b-a)/2;
//}
//int main()
//{
//	int a, b;
//	scanf("%d %d", &a, &b);
//	int ret = average(a, b);
//	printf("%d\n", ret);
//}// 求字符串长度
//模拟实现strlen函数的第一种方法
//#include<assert.h>
//size_t my_first_strlen(const char* string)
//{
//	assert(string);
//	int count = 0;
//	while (*string != '\0')
//	{
//		string++;
//		count++;
//	}
//	return count;
//}
//int main()
//{
//	char arr[10] = "abcdef";
//	int ret = my_first_strlen(arr);
//	printf("%d\n", ret);
//	return 0;
//}// 第二种方法：递归
//#include<assert.h>
//size_t my_second_strlen(const char* str)
//{
//	assert(str != NULL);
//	if (*str != '\0')
//	{
//		return 1 + my_second_strlen(str + 1);
//	}
//	else
//	{
//		return 0;
//	}
//}
//int main()
//{
//	char arr[10] = "abcdef";
//	int ret = my_second_strlen(arr);
//	printf("%d\n", ret);
//	return 0;
//}// 第三种方法：指针-指针
//#include<assert.h>
//size_t my_third_strlen(const char* str)
//{
//	assert(str != NULL);
//	const char* start = str;
//	while (*str != '\0')
//	{
//		str++;
//	}
//	return str - start;
//}
//int main()
//{
//	char arr[10] = "abcdef";
//	int ret = my_third_strlen(arr);
//	printf("%d\n", ret);
//	return 0;
//}//// 逆序字符串
//#include<string.h>
//void reverse(char* arr)
//{
//	int ret = strlen(arr);
//	char* left = arr;
//	char* right = arr + ret - 1;
//	while (left < right)
//	{
//		char tmp = *left;
//		*left = *right;
//		*right = tmp;
//		left++;
//		right--;
//	}
//}
//int main()
//{
//	char arr[31] = { 0 };
//	scanf("%[^\n]", arr);
//	reverse(arr);
//	printf("%s\n", arr);
//}//// 方法二
//int digit_sum(int m)
//{
//	int sum = 0;
//	while (m)
//	{
//		sum += m % 10;
//		m /= 10;
//	}
//	//返回每?位的和
//	return sum;
//}
//// 求数字的每一位之和
//// 方法一
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int sum = 0;
//	while (n / 10)
//	{
//		sum += n % 10;
//		n /= 10;
//	}
//	sum += n % 10;
//	printf("%d\n", sum);
//}//#include<string.h>
//// 判断字符串
//int main()
//{
//	char arr[31] = { 0 };
//	scanf("%[^\n]s", arr);
//	int len = strlen(arr);
//	char* left = arr;
//	char* right = arr + len - 1;
//	while (left < right)
//	{
//		if (*left != *right)
//		{
//			printf("NO");
//			return 0;
//		}
//		left++;
//		right--;
//	}
//	printf("YES");
//}//// 计算天数
//#include <stdio.h>
//int get_month_of_day(int y, int m)
//{
//	//将每个?份的天数记录在数组中
//	int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
//
//	//获取?份的天数
//	int day = days[m];
//
//	//特判??天数是29天的情况
//	if ((y % 4 == 0 && y % 100 != 0) || (y % 400 == 0))
//	{
//		if (m == 2)
//			day += 1;
//	}
//	return day;
//}
//int main()
//{
//	int y = 0;
//	int m = 0;
//	//输?
//	scanf("%d %d", &y, &m);
//	//获取y年m?的天数
//	int ret = get_month_of_day(y, m);
//	printf("%d\n", ret);
//	return 0;
//}// 删除指定的数字   err样例
//int main()
//{
//	int arr[10] = { 0 };
//	int i = 0;
//	for (i = 0;  i<sizeof(arr) / sizeof(arr[0]); i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	int n = 0;
//	scanf("%d", &n);
//	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
//	{
//		if (n == arr[i])
//			arr[i] = arr[i + 1];
//	}
//	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
//	{
//		printf("%d ", arr[i]);
//	}
//}// 删除指定的数字
//int main()
//{
//	int count = 0;
//	int arr[10] = { 0 };
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	for (i = 0; i < sz; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	int n = 0;
//	scanf("%d", &n);
//	for (i = 0; i < sz; i++)
//	{
//		if (n == arr[i])
//		{
//			count++;
//			int j = 0;
//			for (j = i; j < sz -1; j++)
//			{
//				arr[j] = arr[j + 1];
//			}
//		}
//	}
//	for (i = 0; i < sz-count; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//}// 方法二
//int main()
//{
//	int arr[10] = { 0 };
//	int del = 0;
//	int i = 0;
//	//输?
//	for (i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	scanf("%d", &del);
//
//	//删除
//	int j = 0;
//	for (i = 0; i < 10; i++)
//	{
//		//若当前数与给定值不相同，不需要删除，
//		//将其填?第j个位置，将j后移
//		if (arr[i] != del)
//			arr[j++] = arr[i];
//	}
//
//	//打印
//	for (i = 0; i < j; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}// 字符串拷贝--
//int main()
//{
//	char arr1[20] = "abcdef";
//	char arr2[20] = {0};
//	char* str1 = arr1;
//	char* str2 = arr2;
//	while (*str1 != '\0')
//	{
//		*str2 = *str1;
//		str1++;
//		str2++;
//	}
//	*str2 = '\0';
//	printf("%s\n", arr2);
//}// 方法一
//void my_strcpy(char* dest, const char* src)
//{
//	while (*src != '\0') {
//		*dest = *src;
//		dest++;
//		src++;
//	}
//	// 拷贝原字符串的结束标志
//	*dest = '\0';
//}
//int main()
//{
//	char arr1[] = "hello bite";
//	char arr2[20] = { 0 };
//
//	//将字符串arr1中的内容拷?到字符串arr2中
//	my_strcpy(arr2, arr1);
//	//打印字符串arr2
//	printf("%s\n", arr2);
//	return 0;
//}// 方法二
//void my_strcpy(char* dest, const char* src)
//{
//	while (*dest++ = *src++)
//	{
//		;
//	}
//}
//int main()
//{
//	char arr1[] = "hello bite";
//	char arr2[20] = { 0 };
//
//	//将字符串arr1中的内容拷?到字符串arr2中
//	my_strcpy(arr2, arr1);
//	//打印字符串arr2
//	printf("%s\n", arr2);
//	return 0;
//}//// 合并有序数组
//int main()
//{
//	int n, m;
//	scanf("%d %d", &n, &m);
//	int arr1[30] = { 0 };
//	int arr2[30] = { 0 };
//	int arr3[60] = { 0 };
//	int i, j, k = 0; //k最开始没有初始化为0
//	for (i = 0; i < n; i++)
//	{
//		scanf("%d", &arr1[i]);
//	}
//	for (j = 0; j < m; j++)
//	{
//		scanf("%d", &arr2[j]);
//	}
//	i = 0, j = 0;
//	while (i < n && j < m)
//	{
//		if (arr1[i] < arr2[j])
//		{
//			arr3[k] = arr1[i];
//			k++;
//			i++;
//		}
//		else if (arr1[i] > arr2[j])
//		{
//			arr3[k] = arr2[j];
//			k++;
//			j++;
//		}
//		else
//		{
//			arr3[k] = arr1[i];
//			k++;
//			i++;
//		}
//	}
//	if (i == n)
//	{
//		for (; j < m; j++)
//		{
//			arr3[k] = arr2[j];
//			k++;
//		}
//	}
//	if (j == m)
//	{
//		for (; i < n; i++)
//		{
//			arr3[k] = arr1[i];
//			k++;
//		}
//	}
//	for (k = 0; k < m + n; k++)
//	{
//		printf("%d ", arr3[k]);
//	}
//}//int sum(int num1, int num2)
//{
//    return num1 + num2;
//}//int game(int* guess, int guessSize, int* answer, int answerSize)
//{
//	int i = 0;
//	int cnt = 0;
//	for (i = 0; i < guessSize; i++) 
//	{
//		if (guess[i] == answer[i]) {
//			cnt++;
//		}
//	}
//	return cnt;
//}//#include<stdlib.h>
//double* convertTemperature(double celsius, int* returnSize)
//{
//    double* str = (double*)malloc(2 * sizeof(double));
//    str[0] = celsius + 273.15;
//    str[1] = celsius * 1.80 + 32.00;
//    *returnSize = 2;
//    return str;
//}//int smallestEvenMultiple(int n) {
//	//判断n是不是偶数
//	if (n % 2 == 0)
//		return n;
//	//如果不是偶数，则?定是奇数
//	else
//		return 2 * n;
//}
//
//int smallestEvenMultiple(int n) {
//	//判断n是不是偶数
//	if (n & 1 == 0)
//		return n;
//	//如果没有进?上?步操作，直接返回n为奇数时的结果2*n即可
//	return 2 * n;
//}//int xorOperation(int n, int start)
//{
//    int arr[n];
//    int i = 0;
//    for (i = 0; i < n; i++)
//    {
//        arr[i] = start + 2 * i;
//    }
//    int ret = 0;
//    for (i = 0; i < n; i++)
//    {
//        ret ^= arr[i];
//    }
//    return ret;
//}
//
//int xorOperation(int n, int start) {
//    int i = 0;
//    int ret = 0;
//    int u;
//    for (i = 0; i < n; i++) {
//        //将nums[i]的值存放在u中，每次更新u的值
//        u = start + 2 * i;
//        ret ^= u;
//    }
//    return ret;
//}//#include<math.h>
//int differenceOfSum(int* nums, int numsSize)
//{
//    int x = 0;
//    int y = 0;
//    for (int i = 0; i < numsSize; i++)
//    {
//        x += nums[i];
//        while (nums[i])
//        {
//            y += nums[i] % 10;
//            nums[i] /= 10;
//        }
//    }
//    return abs(x - y);
//}//bool isPalindrome(int x)
//{
//    if (x < 0)
//    {
//        return false;
//    }
//
//    long long n = 0;
//    int tmp = x;
//    while (tmp)
//    {
//        n = n * 10 + tmp % 10;
//        tmp /= 10;
//    }
//    return x == n;
//}//// 方法一：
//#include<stdlib.h>
//int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize)
//{
//    int* tmp = (int*)malloc(numsSize * sizeof(int));
//    for (int i = 0; i < numsSize; i++)
//    {
//        int count = 0;
//        for (int j = 0; j < numsSize; j++)
//        {
//            if (nums[i] > nums[j])
//            {
//                count++;
//            }
//        }
//        tmp[i] = count;
//    }
//    *returnSize = numsSize;
//    return tmp;
//}
//
//
//// 方法二
//int low(int* order, int orderSize, int u) {
//    int i;
//    //定义左右两边界，l为最左边，r为最右边
//    int l = 0, r = orderSize - 1;
//
//    //当l<r时表?l~r之间还未被查找
//    while (l < r) {
//        //mid为l和r的中点，向下取整
//        int mid = (l + r) / 2;
//        //如果在有序数组中下标为中点的数?于要查找的数，则要查找的数?定在中点右边，将左边界修改为中
//        if (order[mid] < u) l = mid + 1;
//        //否则在中点处或者中点左边部分，将右边界修改为中点，
//        else r = mid;
//    }
//    //当查找完成时l=r，返回其中?个即可
//    return l;
//}
//int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize) {
//    //定义答案数组
//    int* ans = malloc(numsSize * sizeof(int));
//    //定义有序数组
//    int* order = malloc(numsSize * sizeof(int));
//    int i = 0, j = 0;
//
//    //将原数组中的数放?有序数组，之后进?排序
//    for (i = 0; i < numsSize; i++) order[i] = nums[i];
//
//    //此段代码为冒泡排序，时间复杂度较?，有兴趣可以修改此段代码为其他时间复杂度较低的排序代
//    for (i = 0; i < numsSize; i++) {
//        //此层循环为将当前数组最?值（除了之前已经找到的最?值之外）放?数组最后?（nunmsS
//        for (j = 0; j < numsSize - i - 1; j++) {
//            //如果两个相邻的数之间左边的?较?，则交换相邻的两个数
//            if (order[j] > order[j + 1]) {
//                int u = order[j];
//                order[j] = order[j + 1];
//                order[j + 1] = u;
//            }
//        }
//    }
//
//    //更新答案数组
//    for (int i = 0; i < numsSize; i++) {
//        //将当前数在有序数组中的下标存?答案数组，order：有序数组，numsSize：数组?度，nums[
//        ans[i] = low(order, numsSize, nums[i]);
//    }
//
//    //更新数组?度并返回数组
//    *returnSize = numsSize;
//    return ans;
//}
//
//
//
//// 方法三：
//int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize) {
//    //定义答案数组，排序数组，哈希表数组
//    int* ans = malloc(numsSize * sizeof(int));
//    int* order = malloc(numsSize * sizeof(int));
//    int* bucket = malloc(110 * sizeof(int));
//    int i = 0, j = 0;
//    //初始化哈希表数组中的值为-1
//    //防?出现重复情况，哈希表?个下标放?多个值，仅当桶?值为-1时更新桶?的值
//    for (i = 0; i < 101; i++) bucket[i] = -1;
//
//    //将原数组中的值放?排序数组
//    for (i = 0; i < numsSize; i++) order[i] = nums[i];
//    //此段代码为冒泡排序，时间复杂度较?，有兴趣可以修改此段代码为其他排序代码，内容同上
//    for (i = 0; i < numsSize; i++) {
//        for (j = 0; j < numsSize - i - 1; j++) {
//            if (order[j] > order[j + 1]) {
//                int u = order[j];
//                order[j] = order[j + 1];
//                order[j + 1] = u;
//            }
//        }
//    }
//    //定义变量cnt记录当前数是否重复出现，若第?次出现则记录当前位置，使得之后的重复的数都被赋值
//    int cnt = 0;
//    for (i = 0; i < numsSize; i++) {
//        //若第?次出现，则更新cnt
//        if (bucket[order[i]] == -1) cnt = i;
//        //将当前数第?次出现的位置放?桶?
//        bucket[order[i]] = cnt;
//    }
//
//    //遍历原数组，将数字在桶?的值放?答案数组
//    for (i = 0; i < numsSize; i++) {
//        ans[i] = bucket[nums[i]];
//    }
//
//    //更新数组?度并返回答案数组
//    *returnSize = numsSize;
//    return ans;
//}//int percentageLetter(char* s, char letter)
//{
//    int sum = 0;
//    int ret = strlen(s);
//    while (*s)
//    {
//        if (*s == letter)
//        {
//            sum++;
//        }
//        s++;
//    }
//    return sum * 100 / ret;
//}//bool isUnique(char* astr) {
//	int i = 0;
//	//定义数组?来标记每个字?是否出现，0为未出现过，1为已经出现过
//	bool hash[26] = { 0 };
//	//遍历字符串，当字符不为空时进?循环
//	while (astr[i]) {
//		//若当前字?之前被标记过返回false
//		if (hash[astr[i] - 'a'] == 1)
//			return false;
//		//否则标记当前字?
//		else
//			hash[astr[i] - 'a'] = 1;
//		//下标+1，继续遍历下?个字符
//		i++;
//	}
//	//遍历结束，未出现重复，则返回true
//	return true;
//}
//
//bool isUnique(char* astr) {
//	int i = 0;
//	//定义变量?来标记
//	int s = 0;
//	while (astr[i]) {
//		//在这?定义u直接表?为左移后的结果
//		//astr[i]-'a'即为astr[i]在字?表中的顺序-1，即上?所说的w-1
//		int u = 1 << (int)(astr[i] - 'a');
//		//若未被标记则标记此位，即s加上u;
//		if ((u & s) == 0) s += u;
//		//若之前已经被标记，则返回false;
//		else return false;
//		i++;
//	}
//	//遍历结束不存在重复则返回true
//	return true;
//}//char* defangIPaddr(char* address)
//{
//    int len = strlen(address);
//    char* ptr = NULL;
//    char* ans = ptr = malloc(len + 6 + 1);
//    while (*address)
//    {
//        if (*address == '.')
//        {
//            *ptr = '[';
//            ptr++;
//            *ptr = '.';
//            ptr++;
//            *ptr = ']';
//            ptr++;
//        }
//        else
//        {
//            *ptr++ = *address;
//        }
//        address++;
//    }
//    *ptr = '\0';
//    return ans;
//}//int mostWordsFound(char** sentences, int sentencesSize)
//{
//    int i = 0;
//    int max = 0;
//    for (i = 0; i < sentencesSize; i++)
//    {
//        int word = 1;
//        int j = 0;
//        while (sentences[i][j])
//        {
//            if (sentences[i][j] == ' ')
//            {
//                word++;
//            }
//            j++;
//        }
//        if (max < word)
//        {
//            max = word;
//        }
//    }
//    return max;
//}//bool isSameAfterReversals(int num)
//{
//    int tmp = num;
//    long long n = 0;
//    while (tmp)
//    {
//        n = n * 10 + tmp % 10;
//        tmp /= 10;
//    }
//    while (n)
//    {
//        tmp = tmp * 10 + n % 10;
//        n /= 10;
//    }
//    if (tmp == num)
//    {
//        return true;
//    }
//    else
//    {
//        return false;
//    }
//}
//
//bool isSameAfterReversals(int num)
//{
//    int tmp = num;
//    int n = 0;
//    while (tmp)
//    {
//        n = n * 10 + tmp % 10;
//        tmp /= 10;
//    }
//    while (n)
//    {
//        tmp = tmp * 10 + n % 10;
//        n /= 10;
//    }
//    return num == tmp;
//}
//
//// 方法二：只要num个位数不为0，返回正确
//bool isSameAfterReversals(int num)
//{
//    return num == 0 || num % 10 != 0;
//}//int findGCD(int* nums, int numsSize)
//{
//    int i = 0;
//    for (i = 0; i < numsSize - 1; i++)
//    {
//        for (int j = 0; j < numsSize - 1 - i; j++)
//        {
//            if (nums[j] < nums[j + 1])
//            {
//                int tmp = nums[j];
//                nums[j] = nums[j + 1];
//                nums[j + 1] = tmp;
//            }
//        }
//    }
//    int a = nums[0];
//    int b = nums[numsSize - 1];
//    int c = (a > b ? b : a);
//    while (1)
//    {
//        if (a % c == 0 && b % c == 0)
//        {
//            break;
//        }
//        c--;
//    }
//    return c;
//}//int findNumbers(int* nums, int numsSize)
//{
//    int sum = 0;
//    int i = 0;
//    for (i = 0; i < numsSize; i++)
//    {
//        int ret = nums[i];
//        int tmp = 0;
//        while (ret % 10 == 0)
//        {
//            tmp++;
//            ret = ret / 10;
//        }
//        if (tmp % 2 == 0)
//        {
//            sum++;
//        }
//    }
//    return sum;
//}
//int main()
//{
//    int arr[] = { 12,345,2,6,7896 };
//    int len = sizeof(arr) / sizeof(arr[0]);
//    int sum = findNumbers(arr, len);
//    return 0;
//}//int findNumbers(int* nums, int numsSize)
//{
//    int sum = 0;
//    int i = 0;
//    for (i = 0; i < numsSize; i++)
//    {
//        int ret = nums[i];
//        int tmp = 0;
//        while (ret)
//        {
//            tmp++;
//            ret = ret / 10;
//        }
//        if (tmp % 2 == 0)
//        {
//            sum++;
//        }
//    }
//    return sum;
//}
//
//#include<string.h>
//int findNumbers(int* nums, int numsSize) 
//{
//    int i = 0;
//    int ans = 0;
//    //定义字符串数组?来存放转化后的字符串 
//    char arr[7] = {};
//    for (i = 0; i < numsSize; i++) {
//        //将数字转化为字符串 
//        sprintf(arr, "%d", nums[i]);
//        //字符串?度为偶数，即当前数字位数为偶数时记录?次 
//        if (strlen(arr) % 2 == 0) {
//            ans++;
//        }
//    }
//    //返回位数为偶数的数字个数 
//    return ans;
//}
#include<stdlib.h>//int* separateDigits(int* nums, int numsSize, int* returnSize) 
//{
//	int i = 0;
//	int tmp = 0;
//	//定义数组作为返回值并且分配内存 
//	int* ans = malloc(6 * 1000 * sizeof(int));
//	int k = 0;
//	for (i = 0; i < numsSize; i++) 
//	{
//		int n = nums[i];
//		int j = 0;
//		//反转n放?tmp 
//		while (n)
//		{
//			tmp = tmp * 10 + n % 10;
//			n /= 10;
//		}
//		//正向存储到ans 
//		while (tmp)
//		{
//			ans[k++] = tmp % 10;
//			tmp /= 10;
//		}
//	}
//	*returnSize = k;
//	return ans;
//}//int getLength(int num) 
//{
//    int length = 0;
//    while (num != 0)
//    {
//        length++;
//        num /= 10;
//    }
//    return length;
//}
//
//void reverse(int* answer, int start, int end)
//{
//    for (int i = start, j = end; i < j; i++, j--) 
//    {
//        int temp = answer[i];
//        answer[i] = answer[j];
//        answer[j] = temp;
//    }
//}
//
//int* separateDigits(int* nums, int numsSize, int* returnSize) 
//{
//    int totalLength = 0;
//    for (int i = 0; i < numsSize; i++) 
//    {
//        totalLength += getLength(nums[i]);
//    }
//    int* answer = (int*)malloc(sizeof(int) * totalLength);
//    *returnSize = totalLength;
//    int index = 0;
//    for (int i = 0; i < numsSize; i++) 
//    {
//        int start = index;
//        int temp = nums[i];
//        while (temp != 0) 
//        {
//            answer[index] = temp % 10;
//            index++;
//            temp /= 10;
//        }
//        reverse(answer, start, index - 1);
//    }
//    return answer;
//}//int calculate(char* s) 
//{
//	//定义x和y并初始化 
//	int x = 1;
//	int y = 0;
//	//遍历字符串数组，字符串数组指针直接指向字符串?位，则遍历时直接获取指针指向的字符，判断
//	while (*s) 
//	{
//		//判断当前字符，并执?相应操作 
//		if (*s == 'A')
//			x = 2 * x + y;
//		else if (*s == 'B')
//			y = 2 * y + x;
//		//字符串指针后移，完成遍历操作 
//		s++;
//	}
//	//返回操作执?完成后的两值之和 
//	return x + y;
//}//char* toLowerCase(char* s)
//{
//    int i = 0;
//    while (s[i])
//    {
//        if (s[i] >= 'A' && s[i] <= 'Z')
//        {
//            s[i] += 32;
//        }
//        i++;
//    }
//    return s;
//}//int pivotInteger(int n)
//{
//    int x = 0;
//    int sum1 = 0;
//    int sum2 = 0;
//    for (int i = 1; i < x; i++)
//    {
//        sum1 += i;
//    }
//    for (int i = x; i < n; i++)
//    {
//        sum2 += i;
//    }
//    if (sum1 == sum2)
//    {
//        return x;
//    }
//    else
//    {
//        return -1;
//    }
//}
//int main()
//{
//    int n = 8;
//    printf("%d\n", pivotInteger(n));
//}//int pivotInteger(int n) 
//{
//	int i;
//	//遍历1~n 
//	for (i = 1; i <= n; i++) 
//	{
//		//若i满?1~i的和与i~n的和相等，则返回i 
//		if ((1 + i) * i / 2 == (i + n) * (n - i + 1) / 2) 
//			return i;
//	}
//	//当1~n都不能满?题意时，返回-1 
//	return -1;
//}//int commonFactors(int a, int b)
//{
//    int c = a > b ? b : a;
//    int i = 0;
//    int sum = 0;
//    for (i = 1; i <= c; i++)
//    {
//        if (a % i == 0 && b % i == 0)
//        {
//            sum++;
//        }
//    }
//    return sum;
//}
#include<string.h>//int finalValueAfterOperations(char** operations, int operationsSize) 
//{
//	int i;
//	//定义变量并初始化 
//	int x = 0;
//	//遍历操作数组 
//	for (i = 0; i < operationsSize; i++) 
//	{
//		//使?strcmp函数对字符串进??较，若字符串是"X++"或"++X"其中之?，则进?x++操作 
//		if (!strcmp(operations[i], "X++") || !strcmp(operations[i], "++X")) 
//		{
//			x++;
//		}
//		//否则进?x--操作 
//		else 
//		{
//			x--;
//		}
//
//		//另?种写法： 
//		/*
//		if(operations[i][1]=='+') x++;
//		else x--;
//		*/
//	}
//	//返回最终值 
//	return x;
//}
#include<stdlib.h>//typedef struct 
//{
//    int parking[3];
//}ParkingSystem;
//
//// 初始化停车场系统
//ParkingSystem* parkingSystemCreate(int big, int medium, int small) 
//{
//    // 为停车场系统指针分配内存
//    ParkingSystem* obj = (ParkingSystem*)malloc(sizeof(ParkingSystem));
//    // 分别将三个函数参数赋值给停车场系统的停车位数量
//    obj->parking[0] = big;
//    obj->parking[1] = medium;
//    obj->parking[2] = small;
//    // 返回停车场系统指针
//    return obj;
//}
//// 添加车辆
//bool parkingSystemAddCar(ParkingSystem* obj, int carType) 
//{
//    // 如果相应的停车位数量为0，则添加失败
//    if (obj->parking[carType - 1] == 0) 
//    {
//        return false;
//    }
//    // 否则添加成功，相应停车位数量减?
//    else 
//    {
//        obj->parking[carType - 1]--;
//        return true;
//    }
//}
//// 释放停车场系统内存
//void parkingSystemFree(ParkingSystem* obj) 
//{ 
//    free(obj); 
//}//int** flipAndInvertImage(int** image, int imageSize, int* imageColSize,
//    int* returnSize, int** returnColumnSizes) 
//{
//    int i = 0;
//    int j = 0;
//    // ?平翻转
//    for (i = 0; i < imageSize; i++) {
//        int l = 0;
//        int r = imageSize - 1;
//        // 逆序当前?，当l=r时不需要交换
//        while (l < r) {
//            // 交换
//            int tmp = image[i][l];
//            image[i][l] = image[i][r];
//            image[i][r] = tmp;
//            // 左指针右移，右指针左移，交换下?组
//            l++;
//            r--;
//        }
//    }
//    // 遍历数组所有位置进?反转
//    for (i = 0; i < imageSize; i++) {
//        for (j = 0; j < imageSize; j++) {
//            // ?1减去当前值即可完成反转
//            image[i][j] = 1 - image[i][j];
//        }
//    }
//    // 另?种写法，在逆序时直接反转，?实际复杂度优化，只是提?代码复?率
//    /*
//    for(i=0; i<imageSize; i++) {
//    int l = 0;
//    int r = imageSize-1;
//    //逆序当前?，当l=r时不需要交换
//    while(l<r) {
//    //交换
//    int tmp = image[i][l];
//    image[i][l] = image[i][r];
//    image[i][r] = tmp;
//    //反转
//    image[i][l]=1-image[i][l];
//    image[i][r]=1-image[i][r];
//    l++;r--;
//    }
//    //当l=r时不需要交换，但是需要反转
//    if(l==r) image[i][l]=1-image[i][l];
//    }
//    */
//    // 参数的解释很重要，数组的?列?度都未发?变化，直接赋值为原数组?度
//    * returnSize = imageSize;
//    *returnColumnSizes = imageColSize;
//    // 返回操作完成后的数组
//    return image;
//}//struct ListNode* trainingPlan(struct ListNode* head, int cnt)
//{
//    if (head == NULL)
//    {
//        return NULL;
//    }
//    struct ListNode* n2 = head;
//    struct ListNode* n1 = head;
//    int i = 0;
//    for (i = 0; i < cnt; i++)
//    {
//        if (n2->next != NULL)
//        {
//            n2 = n2->next;
//        }
//        else
//        {
//            return n1;
//            break;
//        }
//    }
//    while (n2 != NULL)
//    {
//        n1 = n1->next;
//        n2 = n2->next;
//    }
//    return n1;
//}//int getDecimalValue(struct ListNode* head) 
//{
//    int ret = 0;
//    // 定义链表指针?作遍历整个链表
//    struct ListNode* cur = head;
//    // 链表指针不为空时进?循环
//    while (cur) 
//    {
//        // 左移?位后将当前值添加?最低位
//        ret = (ret << 1) + cur->val;
//        // 因为左移操作后最低位为0，任何数与0进?或操作都是不变的所以上式也可以写为
//        // ret = (ret << 1) | cur->val;
//        // 指针只想下?位数字或者链表结尾
//        cur = cur->next;
//    }
//    // 返回最终得到的数字
//    return ret;
//}//int diagonalSum(int** mat, int matSize, int* matColSize) 
//{
//    int i = 0;
//    // 定义变量存储答案
//    int sum = 0;
//    // 循环遍历数组
//    for (i = 0; i < matSize; i++) 
//    {
//        int j = 0;
//        for (j = 0; j < matSize; j++) 
//        {
//            // 判断当前数是否在对?线上
//            if (i == j || i + j == matSize - 1) 
//            {
//                // 若在对?线上则将其添加?答案中
//                sum += mat[i][j];
//            }
//        }
//    }
//    // 返回答案
//    return sum;
//}//int hammingDistance(int x, int y)
//{
//    int r = x ^ y;
//    int ret = 0;
//    while (r)
//    {
//        ret++;
//        r = r & (r - 1);
//    }
//    return ret;
//}//int* singleNumber(int* nums, int numsSize, int* returnSize) 
//{
//    int* ans = (int*)calloc(2, sizeof(int));
//    int ret = 0;
//    int i = 0;
//    // 计算数组中所有数异或起来的结果ret
//    for (i = 0; i < numsSize; i++) 
//    {
//        ret ^= nums[i];
//    }
//
//    // 从低位往?位遍历计算ret的?进制中哪?位是1
//    int pos = 0;
//    for (i = 0; i < 32; i++) 
//    {
//        if (((ret >> i) & 1) == 1) 
//        {
//            pos = i;
//            break;
//        }
//    }
//    // 3. 分组异或
//    for (i = 0; i < numsSize; i++) 
//    {
//        // 若当前数pos位为1，作为其中?组对ans[0]进?异或操作
//        if (((nums[i] >> pos) & 1) == 1) 
//        {
//            ans[0] ^= nums[i];
//        }
//        // 否则，作为另?组对ans[1]进?异或操作。
//        else 
//        {
//            ans[1] ^= nums[i];
//        }
//    }
//    // ans[1]另?种计算?法
//    // ans[1]=ret^ans[0];
//
//    // 更新数组长度
//    *returnSize = 2;
//
//    // 返回答案数组
//    return ans;
//}//uint32_t reverseBits(uint32_t n)
//{
//    int i = 0;
//    // 定义?个?符号整型ans
//    uint32_t ans = 0;
//    // 从低位往?位遍历，当i
//    for (i = 1; i <= 32; i++)
//    {
//        // 将原数的第i+1位赋值给ans的第32-(i+1)+1位
//        ans |= ((n >> (i - 1)) & 1) << (31 - i + 1);
//    }
//    // 返回答案
//    return ans;
//}//-----------------------------------------------------------------------------------------//bool arrayStringsAreEqual(char** word1, int word1Size, char** word2, int word2Size)
//{
//    int i = 0;
//    char name1[1001] = { 0 };
//    char name2[1001] = { 0 };
//    for (i = 0; i < word1Size; i++)
//    {
//        strcat(name1, word1[i]);
//    }
//    for (i = 0; i < word2Size; i++)
//    {
//        strcat(name2, word2[i]);
//    }
//    return (strcmp(name1, name2) == 0);
//}
//
//
//
//bool arrayStringsAreEqual(char** word1, int word1Size, char** word2, int word2Size)
//{
//    //定义指向字符串数组的指针指向数组起始位置，并定义两个变量指向两个字符串的字符位置 
//    int x = 0, y = 0, i = 0, j = 0;
//    //同时遍历两个字符串数组 
//    while (x < word1Size && y < word2Size)
//    {
//        //?较当前指向的两个字符是否相等 
//        if (word1[x][i] != word2[y][j])
//        {
//            //不相等直接返回false 
//            return false;
//        }
//        //指向字符的变量后移 
//        i++;
//        //如果指针当前指向空，则遍历下?个字符串，并且重新初始化字符指针 
//        if (word1[x][i] == '\0')
//        {
//            x++;
//            i = 0;
//        }
//        //同上 
//        j++;
//        if (word2[y][j] == '\0')
//        {
//            y++;
//            j = 0;
//        }
//    }
//    //若两个字符串遍历同时结束并未发现不相同字符时返回true，否则返回false 
//    return x == word1Size && y == word2Size;
//}
//
//
//
//bool arrayStringsAreEqual(char** word1, int word1Size, char** word2, int word2Size)
//{
//    int i = 0;
//    char name1[1001] = { 0 };
//    char name2[1001] = { 0 };
//    for (i = 0; i < word1Size; i++)
//    {
//        strcat(name1, word1[i]);
//    }
//    for (i = 0; i < word2Size; i++)
//    {
//        strcat(name2, word2[i]);
//    }
//    return (strcmp(name1, name2) == 0);
//}
//
//
//
//bool arrayStringsAreEqual(char** word1, int word1Size, char** word2, int word2Size)
//{
//    //定义指向字符串数组的指针指向数组起始位置，并定义两个变量指向两个字符串的字符位置 
//    int x = 0, y = 0, i = 0, j = 0;
//    //同时遍历两个字符串数组 
//    while (x < word1Size && y < word2Size)
//    {
//        //?较当前指向的两个字符是否相等 
//        if (word1[x][i] != word2[y][j])
//        {
//            //不相等直接返回false 
//            return false;
//        }
//        //指向字符的变量后移 
//        i++;
//        //如果指针当前指向空，则遍历下?个字符串，并且重新初始化字符指针 
//        if (word1[x][i] == '\0')
//        {
//            x++;
//            i = 0;
//        }
//        //同上 
//        j++;
//        if (word2[y][j] == '\0')
//        {
//            y++;
//            j = 0;
//        }
//    }
//    //若两个字符串遍历同时结束并未发现不相同字符时返回true，否则返回false 
//    return x == word1Size && y == word2Size;
//}
//
//
//
////定义qsort函数中的排序参数 
//int cmp_int(const void* e1, const void* e2)
//{
//    return *(int*)e1 - *(int*)e2;
//}
//int deleteGreatestValue(int** grid, int gridSize, int* gridColSize)
//{
//    int i = 0;
//    int ans = 0;
//    //先对数组每??排序，从?到?和从?到?都可以，只需保证每次删除的数在同?列即可 
//    for (i = 0; i < gridSize; i++)
//    {
//        qsort(grid[i], *gridColSize, sizeof(int), cmp_int);
//    }
//    int j = 0;
//    //定义变量，初始化为最?列下标 
//    int y = *gridColSize - 1;
//
//    //求出数组最后?列的最?值，加到ans上，然后y--，遍历每?列 
//    while (y >= 0)
//    {
//        int max = grid[0][y];
//        //求当前列的最?值 
//        for (j = 1; j < gridSize; j++)
//        {
//            if (max < grid[j][y])
//            {
//                max = grid[j][y];
//            }
//        }
//        //将最?值添加?ans 
//        ans += max;
//        y--;
//    }
//    //返回答案 
//    return ans;
//}
//
//
//
//int maximumWealth(int** accounts, int accountsSize, int* accountsColSize)
//{
//    int max = 0;
//    int i = 0;
//    for (i = 0; i < accountsSize; i++)
//    {
//        int j = 0;
//        int tmp = 0;
//        for (j = 0; j < *accountsColSize; j++)
//        {
//            int max = accounts[0][0];
//            tmp += accounts[i][j];
//        }
//        if (max < tmp)
//        {
//            max = tmp;
//        }
//    }
//    return max;
//}
//
//
//int countDigits(int num)
//{
//    int cnt = 0;
//    int tmp = num;
//    while (tmp)
//    {
//        if (num % (tmp % 10) == 0)
//        {
//            cnt++;
//        }
//        tmp = tmp / 10;
//    }
//    return cnt;
//}
//
//
//
//int* shuffle(int* nums, int numsSize, int n, int* returnSize)
//{
//    int i = 0;
//    int* ret = (int*)malloc(2 * n * sizeof(int));
//    for (i = 0; i < n; i++)
//    {
//        ret[2 * i] = nums[i];
//        ret[2 * i + 1] = nums[i + n];
//    }
//    *returnSize = 2 * n;
//    return ret;
//}
//
//
//
//int Max(int x, int y) { return x > y ? x : y; }
//int** largestLocal(int** grid, int gridSize, int* gridColSize, int* returnSize,
//    int** returnColumnSizes)
//{
//    // 使?malloc模拟开辟?个?维数组
//    int** ans = malloc((gridSize - 2) * sizeof(int*));
//    int i = 0;
//    // 为每个?维数组开辟空间
//    for (i = 0; i < gridSize - 2; i++) {
//        ans[i] = malloc((gridSize - 2) * sizeof(int));
//    }
//    // 遍历数组并忽略?法取得3×3矩阵的情况
//    for (i = 0; i < gridSize - 2; i++) {
//        int j = 0;
//        for (j = 0; j < gridSize - 2; j++) {
//            int x = 0;
//            int y = 0;
//            // 求得最?值，并将其赋值给ans数组相对应下标的元素
//            for (x = i; x <= i + 2; x++) {
//                for (y = j; y <= j + 2; y++) {
//                    ans[i][j] = Max(ans[i][j], grid[x][y]);
//                }
//            }
//        }
//    }
//
//    // 更新数组长度
//    *returnSize = gridSize - 2;
//    // 更新数组每?维长度
//    *returnColumnSizes = malloc((gridSize - 2) * sizeof(int));
//    for (i = 0; i < gridSize - 2; i++) {
//        (*returnColumnSizes)[i] = gridSize - 2;
//    }
//    // 返回?成的矩阵
//    return ans;
//}
//}
//
//
//
//bool checkIfPangram(char* sentence)
//{
//    // ?于记录字?表中每个字?是否在sentence中出现过，初始化为0
//    int exist[26] = { 0 };
//    int i = 0;
//    // 遍历sentence中的每个字符
//    while (*sentence)
//    {
//        // 将对应字?表中的字?在exist数组中的值设为1
//        exist[*sentence - 'a'] = 1;
//        sentence++;
//    }
//    // 遍历exist数组
//    for (i = 0; i < 26; i++)
//    {
//        // 如果存在某个字?在sentence中未出现，则返回false
//        if (exist[i] == 0)
//            return false;
//    }
//    // sentence为全字?句，返回true
//    return true;
//}
//
//
//
//int numJewelsInStones(char* jewels, char* stones)
//{
//    int sum = 0;
//    while (*jewels)
//    {
//        char* tmp = stones;
//        while (*tmp)
//        {
//            if (*jewels == *tmp)
//            {
//                sum++;
//            }
//            tmp++;
//        }
//        jewels++;
//    }
//    return sum;
//}
//
//
//int numJewelsInStones(char* jewels, char* stones)
//{
//    int n = 0;
//    //定义?个哈希数组，将英?字?映射到ASCII码表中，其最?值和最?值之差为57。 
//    bool hash[60] = { 0 };
//    //遍历jewels 
//    while (*jewels)
//    {
//        //标记jewels中出现的字符 
//        hash[*jewels - 'A'] = 1;
//        jewels++;
//    }
//    //遍历stones 
//    while (*stones)
//    {
//        //判断当前字符是否被标记过 
//        if (hash[*stones - 'A'])
//            n++;
//        stones++;
//    }
//    //返回答案 
//    return n;
//}
//
//
//// 假设成立时候，flag = -1，返回sum
//// 假设不成立时，flag = 1 ，返回-sum
//int alternateDigitSum(int n)
//{
//    int flag = 1;
//    int sum = 0;
//    while (n)
//    {
//        sum += flag * (n % 10);
//        flag = -flag;
//        n = n / 10;
//    }
//    return -flag * sum;
//}
//
//
//int largestAltitude(int* gain, int gainSize)
//{
//    int i = 0;
//    //定义?个变量m记录最?海拔，并初始化为第?个点的海拔 
//    int m = gain[0];
//    for (i = 1; i < gainSize; i++)
//    {
//        //更新gain数组当前元素为当前的前缀和 
//        gain[i] += gain[i - 1];
//        //更新m为当前最?海拔 
//        if (gain[i] > m)
//        {
//            m = gain[i];
//        }
//    }
//    //特判若所有点的海拔都低于初始值，则更新m为0 
//    if (m < 0)
//    {
//        m = 0;
//    }
//    //返回最?海拔 
//    return m;
//}
//
//
//int subtractProductAndSum(int n)
//{
//    int sum1 = 0;
//    int sum2 = 1;
//    while (n)
//    {
//        sum1 += (n % 10);
//        sum2 *= (n % 10);
//        n = n / 10;
//    }
//    return sum2 - sum1;
//}//int countConsistentStrings(char* allowed, char** words, int wordsSize) {
//	int i = 0;
//	int count = 0;
//	//遍历words数组
//	for (i = 0; i < wordsSize; i++) {
//		int j = 0;
//		//假定全部出现
//		int flag = 1;
//		//遍历每?个字符
//		while (words[i][j]) {
//			if (NULL == strchr(allowed, words[i][j])) {
//				//有字符没出现
//				flag = 0;
//				break;
//			}
//			j++;
//		}
//		//更新计数器的值
//		count += flag;
//	}
//	//返回计数器的值
//	return count;
//}//char* reverseLeftWords(char* s, int k) 
//{
//	int i = 0;
//	int len = strlen(s);
//	for (i = 0; i < k; i++) 
//	{
//		//定义变量记录收个字符
//		char tmp = s[0];
//		int j = 0;
//		//所有字符左移⼀位
//		for (j = 0; j < len - 1; j++) 
//		{
//			s[j] = s[j + 1];
//		}
//		//将tmp添加⾄末尾
//		s[len - 1] = tmp;
//	}
//	//返回更新后的字符串
//	return s;
//}//char* dynamicPassword(char* password, int target)
//{
//    int i = 0;
//    int len = strlen(password);
//    for (i = 0; i < target; i++)
//    {
//        char tmp = password[0];
//        int j = 0;
//        for (j = 0; j < len - 1; j++)
//        {
//            password[j] = password[j + 1];
//        }
//        password[len - 1] = tmp;
//    }
//    return password;
//}
//
//
//
//void reverse(char* left, char* right) 
//{
//    //反转两个指针之间的内容
//    while (left < right) 
//    {
//        //交换两个指针指向的的内容
//        char tmp = *left;
//        *left = *right;
//        *right = tmp;
//        //两个指针向对⽅靠拢，继续进⾏交换
//        left++;
//        right--;
//    }
//}
//char* reverseLeftWords(char* s, int k) 
//{
//    //定义变量⽤来记录字符串⻓度
//    int len = strlen(s);
//    //第⼀次反转
//    reverse(s, s + k - 1);
//    //第⼆次反转
//    reverse(s + k, s + len - 1);
//    //整体反转
//    reverse(s, s + len - 1);
//    //返回反转后的字符串
//    return s;
//}//int* decode(int* encoded, int encodedSize, int first, int* returnSize) 
//{
//	//a^b = c
//	//c^a --> a^b^a = b
//	//定义arr数组并分配内存
//	int* arr = (int*)malloc((encodedSize + 1) * sizeof(int));
//	//为arr数组第⼀个元素赋值
//	arr[0] = first;
//	int i = 0;
//	//为arr数组元素依次赋值
//	for (i = 1; i < encodedSize + 1; i++) 
//	{
//		arr[i] = encoded[i - 1] ^ arr[i - 1];
//	}
//	//更新数组⻓度并返回数组
//	*returnSize = encodedSize + 1;
//	return arr;
//}//int numIdenticalPairs(int* nums, int numsSize)
//{
//    int sum = 0;
//    int i = 0;
//    for (i = 0; i < numsSize; i++)
//    {
//        for (int j = i + 1; j < numsSize; j++)
//        {
//            if (nums[i] == nums[j])
//            {
//                sum++;
//            }
//        }
//    }
//    return sum;
//}
//
//
//int numIdenticalPairs(int* nums, int numsSize) 
//{
//    int i = 0;
//    //计数器
//    int cnt = 0;
//    //定义哈希表
//    int* arr = (int*)malloc((101) * sizeof(int));
//    // 将每个元素赋值为 0
//    for (int i = 1; i < 101; i++) 
//    {
//        arr[i] = 0;
//    }
//
//    //遍历数组
//    for (i = 0; i < numsSize; i++) 
//    {
//        //计数器加上当前元素在数组前⾯位置中出现的次数，并令出现的次数加⼀
//        cnt += arr[nums[i]]++;
//    }
//    ////释放哈希表内存
//    free(arr);
//    //返回计数器
//    return cnt;
//}//bool* kidsWithCandies(int* candies, int candiesSize, int extraCandies, int* returnSize)
//{
//    int i = 0;
//    bool* nums = (bool*)malloc(candiesSize * sizeof(bool));
//    for (i = 0; i < candiesSize; i++)
//    {
//        int ret = candies[i] + extraCandies;
//        int j = 0;
//        int flag = 0;
//        for (j = 0; j < candiesSize; j++)
//        {
//            if (ret < candies[j])
//            {
//                flag = 1;
//            }
//        }
//        if (flag == 1)
//        {
//            nums[i] = false;
//        }
//        else
//        {
//            nums[i] = true;
//        }
//    }
//    *returnSize = candiesSize;
//    return nums;
//}//char repeatedCharacter(char* s)
//{
//    // 定义哈希数组
//    bool arr[26] = { 0 };
//    // 遍历字符串
//    while (*s)
//    {
//        // 检查当前字⺟是否被标记过，若被标记则直接返回当前字⺟
//        if (arr[*s - 'a'] == 1)
//        {
//            return *s;
//        }
//        // 否则标记当前字⺟
//        arr[*s - 'a'] = 1;
//        s++;
//    }
//    // 返回任意⼀个字符，防⽌编译错误
//    return ' ';
//}
//}//int countAsterisks(char* s)
//{
//    int count = 0;
//    int flag = 0;
//    while (*s)
//    {
//        if (*s == '|')
//        {
//            flag = !flag;
//        }
//        if (flag == 1)
//        {
//            // 在两个 | 之间
//            s++;
//            continue;
//        }
//        if (*s == '*')
//        {
//            count++;
//        }
//        s++;
//    }
//    return count;
//}//int* getConcatenation(int* nums, int numsSize, int* returnSize)
//{
//    int* newnums = (int*)malloc(2 * numsSize * sizeof(int));
//    *returnSize = 2 * numsSize;
//    int i = 0;
//    for (i = 0; i < numsSize; i++)
//    {
//        newnums[i] = nums[i];
//    }
//    for (i = 0; i < numsSize; i++)
//    {
//        newnums[i + numsSize] = nums[i];
//    }
//    return newnums;
//}//int* leftRigthDifference(int* nums, int numsSize, int* returnSize) 
//{
//    // 定义前缀和与后缀和数组
//    int leftSum[numsSize];
//    int rightSum[numsSize];
//    // 初始化前缀和数组的⾸位和后缀和数组的末位
//    leftSum[0] = rightSum[numsSize - 1] = 0;
//    int i = 0;
//    // 定义ans数组
//    int* answer = (int*)malloc(numsSize * sizeof(int));
//
//    // 为前缀和数组与后缀和数组赋值
//    for (i = 1; i < numsSize; i++) 
//    {
//        leftSum[i] = leftSum[i - 1] + nums[i - 1];
//        // 后缀和数组⼀定要先为后⾯的元素赋值
//        rightSum[numsSize - i - 1] =
//            rightSum[numsSize - i] + nums[numsSize - i];
//    }
//    // 求出ans数组
//    for (i = 0; i < numsSize; i++) 
//    {
//        answer[i] = abs(leftSum[i] - rightSum[i]);
//    }
//    // 更新数组⻓度后返回数组
//    *returnSize = numsSize;
//    return answer;
//}//// 方法一：超出时间限制
//int sum(int n) 
//{
//	//基本情况，需要终⽌递归，1~1的所有数的和为1本⾝，直接返回1
//	if (n == 1) return 1;
//	//否则返回1~n-1所有数的和加上n本⾝，即1~n所有数的和
//	return n + sum(n - 1);
//}
//int main() {
//	//假设n为5，求得1~5之间所有数的和
//	printf("%d", sum(5));
//}
//
//
//// 方法二：递归方法优化，记忆路线
////递归时间复杂度⾼
//int climb(int x) {
//	//若x为1或2，则返回x（⾛到第⼀阶台阶的⽅法数为1，⾛到第⼆阶台阶的⽅法数为2）
//	if (x <= 2) return x;
//	//返回从第⼀阶台阶⾛到第x-1阶和第x-2阶台阶的⽅法数的和
//	return climb(x - 1) + climb(x - 2);
//}
//int climbStairs(int n) {
//	//返回从第⼀阶台阶⾛到第n阶台阶的⽅法数
//	return climb(n);
//}
//
//
//// 方法三：动态规划
////定义全局变量数组，⽤来记忆化搜索
//int mem[50];
////定义递归函数
//int climb(int x) {
//	//若参数⼩于等于2，则返回参数本⾝
//	if (x <= 2) return x;
//	//若函数值已经被计算过，则返回这个值
//	if (mem[x] != -1) return mem[x];
//	//否则计算这个函数值并返回
//	return mem[x] = climb(x - 1) + climb(x - 2);
//}
//int climbStairs(int n) {
//	int i = 0;
//	//初始化记忆数组
//	for (i = 1; i <= n; i++) mem[i] = -1;
//	//返回从第⼀阶台阶⾛到第n阶台阶的⽅法数
//	return climb(n);
//}
//
//
//
//int climbStairs(int n) {
//	//定义数组⽤来记录每⼀个位置的元素值
//	int climb[50];
//	//初始化前两个位置的元素值
//	climb[1] = 1;
//	climb[2] = 2;
//	int i = 0;
//	//遍历求得每个位置的元素值
//	for (i = 3; i <= n; i++) climb[i] = climb[i - 1] + climb[i - 2];
//	//返回第n个位置的元素值，即从第⼀阶台阶⾛到第n阶台阶的⽅法数
//	return climb[n];
//}
//
//// 方法四：动态规划空间优化
////递归时间复杂度⾼
//int climbStairs(int n) {
//	//特判n⼩于等于2的情况
//	if (n <= 2)
//		return n;
//	else {
//		//定义三个变量就三个位置的元素值
//		int a = 1;
//		int b = 2;
//		int c = 0;
//		//进⾏n-2次操作
//		while (n > 2) {
//			//将a和b的和赋值给c，然后将b的值赋值给a，将c的值赋值给b
//			c = a + b;
//			a = b;
//			b = c;
//			n--;
//		}
//		//返回c的值
//		return c;
//	}
//}//int hammingWeight(uint32_t n) 
//{
//	int i = 0;
//	int cnt = 0;
//	for (i = 0; i < 32; i++) 
//	{
//		if (((n >> i) & 1) == 1) 
//		{
//			cnt++;
//		}
//	}
//	return cnt;
//}
//// int hammingWeight(uint32_t n) {
//// int cnt = 0;
//// while(n) {
//// //最低位为1表⽰n为奇数
//// if(n%2 == 1) //if((n&1)==1)
//// cnt++;
////
//// //右移操作相当于除以2
//// n/=2; //n>>=1
//// }
//// return cnt;
//// }
//
//
//int hammingWeight(uint32_t n) 
//{
//	//定义变量作为计数器
//	int cnt = 0;
//	//计算n的⼆进制形式中1的个数
//	while (n) 
//	{
//		n = n & (n - 1);
//		cnt++;
//	}
//	//返回答案
//	return cnt;
//}//int* leftRightDifference(int* nums, int numsSize, int* returnSize) 
//{
//    int* ans = (int*)malloc(numsSize * sizeof(int));
//    int* leftSum = (int*)calloc(numsSize, sizeof(int));
//    int* rightSum = (int*)calloc(numsSize, sizeof(int));
//
//    // 计算 leftSum
//    for (int i = 1; i < numsSize; i++) {
//        leftSum[i] = leftSum[i - 1] + nums[i - 1];
//    }
//
//    // 计算 rightSum
//    for (int i = numsSize - 2; i >= 0; i--) {
//        rightSum[i] = rightSum[i + 1] + nums[i + 1];
//    }
//
//    // 计算答案
//    for (int i = 0; i < numsSize; i++) {
//        ans[i] = abs(leftSum[i] - rightSum[i]);
//    }
//
//    free(leftSum);
//    free(rightSum);
//
//    *returnSize = numsSize;
//    return ans;
//}//int search(int* nums, int numsSize, int target)
//{
//    int left = 0;
//    int right = numsSize - 1;
//    while (left <= right)
//    {
//        int mid = (left + right) / 2;
//        if (target > nums[mid])
//        {
//            left = mid + 1;
//        }
//        else if (target < nums[mid])
//        {
//            right = mid - 1;
//        }
//        else
//        {
//            return mid;
//        }
//    }
//    return -1;
//}//int removeDuplicates(int* nums, int numsSize)
//{
//    int fast = 1;
//    int slow = 1;
//    while (fast <= numsSize - 1)
//    {
//        if (nums[fast] != nums[fast - 1])
//        {
//            nums[slow] = nums[fast];
//            slow++;
//        }
//        fast++;
//    }
//    return slow;
//}//bool searchMatrix(int** matrix, int matrixSize, int matrixColSize, int target)
//{
//    int i = 0;
//    for (i = 0; i < matrixSize; i++)
//    {
//        int j = 0;
//        for (j = 0; j < matrixColSize; j++)
//        {
//            if (target == matrix[i][j])
//            {
//                return true;
//            }
//        }
//    }
//    return false;
//}//int singleNumber(int* nums, int numsSize) {
//	int i = 0;
//	int ret = 0;
//	//将每个数异或起来
//	for (i = 0; i < numsSize; i++) {
//		ret ^= nums[i];
//	}
//	return ret;
//	//nums[i]^=nums[i-1];
//   //return nums[numsSize-1];
//}//void reverseString(char* s, int sSize)
//{
//    // 双指针的方法
//    int left = 0;
//    int right = sSize - 1;
//    while (left <= right)
//    {
//        char tmp = s[left];
//        s[left] = s[right];
//        s[right] = tmp;
//        left++;
//        right--;
//    }
//    return s;
//}
//
//void reverseString(char* s, int sSize)
//{
//    char* left = s;
//    char* right = s + sSize - 1;
//    while (left <= right)
//    {
//        char tmp = *left;
//        *left = *right;
//        *right = tmp;
//        left++;
//        right--;
//    }
//}//int firstUniqChar(char* s) 
//{
//	int arr[256] = { 0 };
//	char* str = s;
//	while (*str) 
//	{
//		arr[*str++]++;
//	}
//	str = s;
//	while (*str) 
//	{
//		if (arr[*str] == 1)
//		{
//			return str - s;
//		}
//		str++;
//	}
//	return -1;
//}//int findCenter(int** edges, int edgesSize, int* edgesColSize) 
//{
//	//依次判断等式是否成⽴
//	if (edges[0][0] == edges[1][0]) return edges[0][0];
//	if (edges[0][0] == edges[1][1]) return edges[0][0];
//	if (edges[0][1] == edges[1][0]) return edges[0][1];
//	if (edges[0][1] == edges[1][1]) return edges[0][1];
//	//防⽌编译错误
//	return 0;
//}//int maxProductDifference(int* nums, int numsSize)
//{
//    // 先进行冒泡排序然后直接加减即可
//    int i = 0;
//    for (i = 0; i < numsSize - 1; i++)
//    {
//        int j = 0;
//        for (j = 0; j < numsSize - 1 - i; j++)
//        {
//            if (nums[j] > nums[j + 1])
//            {
//                int tmp = nums[j];
//                nums[j] = nums[j + 1];
//                nums[j + 1] = tmp;
//            }
//        }
//    }
//    return (nums[numsSize - 1] * nums[numsSize - 2]) - (nums[0] * nums[1]);
//}//int** generate(int numRows, int* returnSize, int** returnColumnSizes) 
//{
//	int i = 0;
//	//开辟存放杨辉三⻆的⼆维数组
//	int** arr = (int**)malloc(numRows * sizeof(int*));
//	//为每⼀维分配内存
//	for (i = 0; i < numRows; i++) {
//		arr[i] = (int*)malloc(numRows * sizeof(int));
//	}
//	//更新⾏数
//	*returnSize = numRows;
//	//存放每⼀⾏数据的个数
//	*returnColumnSizes = (int*)malloc(numRows * sizeof(int));
//
//	//按⾏从上到下遍历
//	for (i = 0; i < numRows; i++) {
//		int j = 0;
//		//更新每⼀⾏的元素个数
//		(*returnColumnSizes)[i] = i + 1;
//			//初始化每⼀⾏的⾸位和末位元素为1
//			arr[i][0] = arr[i][i] = 1;
//
//		//更新中间元素，遍历前两维时不会进⼊循环，不需要特判
//		for (j = 1; j < i; j++) {
//			arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
//		}
//	}
//	//返回杨辉三⻆
//	return arr;
//}//char* pathEncryption(char* path)
//{
//    int len = strlen(path);
//    int left = 0;
//    while (left != len)
//    {
//        if (path[left] == '.')
//        {
//            path[left] = ' ';
//        }
//        else
//        {
//            left++;
//        }
//    }
//    return path;
//}//int addDigits(int num)
//{
//    while (num > 9)
//    {
//        //证明还是两位数
//        int sum = 0;
//        while (num)
//        {
//            sum += num % 10;
//            num /= 10;
//        }
//        num = sum;
//    }
//    return num;
//}//int* sortArrayByParity(int* nums, int numsSize, int* returnSize) 
//{
//	//定义双指针
//	int l = 0;
//	int r = numsSize - 1;
//	//当两指针还未相遇时查找奇数在前的情况
//	while (l < r) 
//	{
//		//查找最左边的奇数
//		while ((l < r) && nums[l] % 2 == 0) 
//		{
//			l++;
//		}
//		//查找最右边的偶数
//		while ((l < r) && nums[r] % 2 == 1) 
//		{
//			r--;
//		}
//		//若两指针未相遇进⾏交换
//		if (l < r) {
//			int tmp = nums[l];
//			nums[l] = nums[r];
//			nums[r] = tmp;
//			//交换后两指针相向移动继续查找
//			l++;
//			r--;
//		}
//	}
//	//更新数组⻓度后返回更新后的数组
//	*returnSize = numsSize;
//	return nums;
//}//int balancedStringSplit(char* s) 
//{
//	//定义变量作为平衡字符串计数器
//	int cnt = 0;
//	//定义两个变量作为字符'L'和'R'的计数器
//	int rc = 0;
//	int lc = 0;
//	//遍历字符串
//	while (*s) 
//	{
//		//更新字符串计数
//		if (*s == 'R')
//			rc++;
//		else if (*s == 'L')
//			lc++;
//		//若两个字符计数器的值相等，则以上⼀个字符结尾+1作为起点，当前字符作为结尾满⾜平衡
//		if (rc == lc)
//			cnt++;
//		s++;
//	}
//	return cnt;
//}//int countKDifference(int* nums, int numsSize, int k)
//{
//    int i = 0;
//    int sum = 0;
//    for (i = 0; i < numsSize; i++)
//    {
//        int j = 0;
//        for (j = i; j < numsSize; j++)
//        {
//            if (k == abs(nums[i] - nums[j]))
//            {
//                sum++;
//            }
//        }
//    }
//    return sum;
//}//int* countNumbers(int cnt, int* returnSize)
//{
//    int sz = pow(10, cnt) - 1;
//    int* nums = (int*)malloc(sz * sizeof(int));
//    for (int i = 0; i < sz; i++)
//    {
//        nums[i] = i + 1;
//    }
//    *returnSize = sz;
//    return nums;
//}//char* generateTheString(int n) 
//{
//	//开辟⼀个⻓度为n+1的数组ans
//	char* ans = malloc((n + 1) * sizeof(char));
//	//初始化数组
//	memset(ans, 'a', n);
//	ans[n] = '\0';
//
//	//如果n位偶数，将第⼀个改为'b'，a和b都是奇数个
//	if (n % 2 == 0)
//		ans[0] = 'b';
//	//返回字符串ans
//	return ans;
//}//int* replaceElements(int* arr, int arrSize, int* returnSize) 
//{
//	int max = -1;
//	for (int i = arrSize - 1; i >= 0; i--) 
//	{
//		int temp = arr[i];
//		arr[i] = max;
//		if (max < temp) max = temp;
//	}
//	*returnSize = arrSize;
//	return arr;
//}//char* mergeAlternately(char* word1, char* word2) {
//	int flag = 1;
//	//定义⻓度⼤于等于两个字符串⻓度之和的字符串
//	char* ans = calloc(201, sizeof(char));
//	int i = 0;
//	//遍历两字符串
//	while (*word1 && *word2) {
//		//判断上⼀次合并的是哪个字符串，进⾏交替合并
//		if (flag == 1) {
//			ans[i++] = *word1++;
//			flag = 0;
//		}
//		else {
//			ans[i++] = *word2++;
//			flag = 1;
//		}
//	}
//	//如果word1先结束，将word2剩余的内容合并
//	if (*word1 == '\0') {
//		while (*word2) {
//			ans[i++] = *word2++;
//		}
//	}
//	//如果word2先结束，将word1剩余的内容合并
//	else {
//		while (*word1) {
//			ans[i++] = *word1++;
//		}
//	}
//	//返回拼接后的字符串
//	return ans;
//}////定义⽐较函数
//int cmp(const void* e1, const void* e2) 
//{
//	return *(int*)e1 - *(int*)e2;
//}
//void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)
//{
//    int i = 0;
//   //将nums2数组中的内容全部追加到nums1中
//   for (i = 0; i < n; i++) 
//   {
//	  nums1[m + i] = nums2[i];
//   }
//   //将数组升序排序
//   qsort(nums1, nums1Size, sizeof(int), cmp);
//}
//
//
//void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) {
//	//定义双指针分别指向nums1数组和nums2数组中的元素
//	int p1 = 0, p2 = 0;
//	//定义⼀个⻓度为n+m的新数组
//	int* sorted = malloc((n + m) * sizeof(int));
//
//	//当两指针都没有指向空时，进⼊循环将较⼩的元素存⼊sorted数组末位，并将相应指针后移
//	while (p1 < m && p2 < n) {
//		if (nums1[p1] < nums2[p2]) {
//			sorted[p1 + p2 - 1] = nums1[p1++];
//		}
//		else {
//			sorted[p1 + p2 - 1] = nums2[p2++];
//		}
//	}
//
//	//判断是否p1指针还有剩余
//	if (p1 < m) {
//		while (p1 < m) sorted[p1++ + n] = nums1[p1];
//	}
//	//否则p2指针还有剩余
//	else {
//		while (p2 < n) sorted[m + p2++] = nums2[p2];
//	}
//	int i;
//	//将合并后并排序的数组元素依次赋值给nums1数组
//	for (i = 0; i != m + n; ++i) {
//		nums1[i] = sorted[i];
//	}
//}//int heightChecker(int* heights, int heightsSize)
//{
//    // 先用冒泡排序
//    int i = 0;
//    int* tmp = (int*)malloc(heightsSize * sizeof(int));
//    memcpy(tmp, heights, heightsSize * sizeof(int));
//    int sum = 0;
//    for (i = 0; i < heightsSize - 1; i++)
//    {
//        int j = 0;
//        for (j = 0; j < heightsSize - 1 - i; j++)
//        {
//            if (heights[j] > heights[j + 1])
//            {
//                int tmp = heights[j];
//                heights[j] = heights[j + 1];
//                heights[j + 1] = tmp;
//            }
//        }
//    }
//    for (i = 0; i < heightsSize; i++)
//    {
//        if (heights[i] != tmp[i])
//        {
//            sum++;
//        }
//    }
//    return sum;
//}//int* targetIndices(int* nums, int numsSize, int target, int* returnSize)
//{
//    int i = 0;
//    for (i = 0; i < numsSize - 1; i++){
//        int j = 0;
//        for (j = 0; j < numsSize - 1 - i; j++)
//        {
//            if (nums[j] > nums[j + 1])
//            {
//                int tmp = nums[j];
//                nums[j] = nums[j + 1];
//                nums[j + 1] = tmp;
//            }
//        }
//    }
//    int cnt = 0;
//    for (int i = 0; i < numsSize; i++){
//        if (nums[i] == target)
//            cnt++;
//    }
//    int* ret = (int*)malloc(cnt * sizeof(int));
//    int sum = 0;
//    int k = 0;
//    for (i = 0; i < numsSize; i++){
//        if (nums[i] == target){
//            ret[k++] = i;
//        }
//    }
//    *returnSize = cnt;
//    return ret;
//}//typedef struct ListNode
//{
//	int val;
//	struct ListNode* next;
//}ListNode;
//struct ListNode* reverseList(struct ListNode* head) {
//	//定义两个指针⽤作反转
//	struct ListNode* cur = head;
//	struct ListNode* prev = NULL;
//
//	//当cur不为空时，代表链表还存在未反转的节点
//	while (cur) {
//		//定义指针指向指针cur的下⼀个节点避免链表断裂
//		struct ListNode* next_node = cur->next;
//		//实现反转操作
//		cur->next = prev;
//		//更新两个指针以便下⼀次迭代
//		prev = cur;
//		cur = next_node;
//	}
//
//	//将头指针指向指针prev指向的节点，完成反转
//	head = prev;
//	//返回头指针
//	return head;
//}//typedef struct ListNode
//{
//	int val;
//	struct ListNode* next;
//}ListNode;
//struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
//	//定义⼀个哑节点作为结果链表的头
//	struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
//	dummy->val = 0;
//	dummy->next = NULL;
//	//定义结果链表的尾，刚开始头尾相同
//	struct ListNode* curr = dummy;
//	//循环⽐较两个链表的头节点
//	while (l1 && l2) {
//		//将较⼩的节点接⼊结果链表中，并将该节点从原链表中删除
//		if (l1->val < l2->val) {
//			curr->next = l1;
//			l1 = l1->next;
//		}
//		else {
//			curr->next = l2;
//			l2 = l2->next;
//		}
//		//尾部后移
//		curr = curr->next;
//	}
//
//	//其中⼀个链表为空，将另⼀个链表的剩余节点全部接⼊结果链表
//	if (l1) {
//		curr->next = l1;
//	}
//	else {
//		curr->next = l2;
//	}
//	//返回哑节点dummy的next指针
//	return dummy->next;
//}