关注

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("等腰三角形");
		else
			printf("普通三角形");
	}
	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;
	// 辗转相除法求最大公约数 b
	while (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;
		else
			sum -= 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的位数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;
}

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;
	else
		total = 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);
	//打印字符串arr2
	printf("%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最开始没有初始化为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]);
	}
}

前面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;
	//如果不是偶数，则⼀定是奇数
	else
		return 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++) {
        //此层循环为将当前数组最⼤值（除了之前已经找到的最⼤值之外）放⼊数组最后⾯（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;
}

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]) {
		//若当前字⺟之前被标记过返回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;
}

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;
    // 计算数组中所有数异或起来的结果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;
}

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

Leedcode链接

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

代码如下（示例）：

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;
}

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中出现过，初始化为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;
}

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));
    // 将每个元素赋值为 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;
}

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本⾝，直接返回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;
	}
}

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;
			//初始化每⼀⾏的⾸位和末位元素为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;
}

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的数组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;
}

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;
//}

转载自CSDN-专业IT技术社区

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/2201_75587702/article/details/149729867

评论

赞0

评论列表

微信小程序
QQ小程序

关于作者

点赞数：0
关注数：0
粉丝：0
文章：0
关注标签：0
加入于：--