🎉前言

🎉欢迎关注🔎点赞👍收藏⭐️留言📝
🎉推荐up主专题文章【C语言重难点总结】
📌QQ：3052645092 有问题可以一起讨论哦
🍭作者水平很有限，如果发现错误，请及时告知作者哦！感谢感谢！

本篇涵盖C语言100道常见的编程题，适用于“专接本，专升本，考研，期中期末考试”，每道题都是亲自手动打出来的，也在编译器上测试过，每道题都有相关的详细注释，如有发现错误，欢迎评论区指正。对于零基础伙伴或者没咋做过编程题的小伙伴真心希望将这篇文章的每道题至少【做三遍】，没有人做一遍就能全部都学会，我自己在做编程题时也是做了好几遍，做完之后过一段时间可能也会忘，这就说明还是不熟，就像打王者荣耀时，你不可能上去就会玩的很好，如果你有英雄联盟基础肯定是稍微熟悉一下王者就可以很快上手，其实做这些题也是，锻炼的是一种意识，意识就熟能生巧，很喜欢韩顺平老师课上提到的一句话:“我亦无他，唯手熟尔”，其实也没什么，就是手熟罢了！记住哦！多做几遍，这些题应付接本，升本，绰绰有余。加油，铁铁！[看看发文效果，如果时间允许可能会出一些题的视频讲解版]

⭐️1.十进制数转任意进制数

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main(){
	int i = 0, j = 0, num[20], base, n = 0;
	char ch[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
		'A', 'B', 'C', 'D', 'E', 'F' };
	printf("请输入一个数:");
	scanf("%d", &n);
	printf("请输入要转换的进制数:");
	scanf("%d", &base);
	do{
		//255 转16 
		// (1) 255%16=15 15放入num[0]  255/15=15  
		//(2) 15%16=15   15放入num[1]  15/16=0 n==0 退出 15正是char数组元素 F 的下标
		
		num[i] = n%base;
		//n%base得出来的余数最大不会大于base 
		n = n / base;
		i++;

	} while (n != 0);

	//最先的余数是在最后面打印

	//--i 因为在里面多加了一次
	for (j = --i; j >= 0; j--){
		printf("%c", ch[num[j]]);
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

⭐️2.数字三角形

⭐️本题需要看图代数去试：

​

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main(){
	int i, j, k,t=0;
	for (i = 1; i <= 9; i++){
		t = 0;
		//第一次是8个空格
		while (8 - i >= t){//打印空格
			t++;
			printf("  ");
		}
		for (j = 1; j <= i; j++)//打印左半边三角形
			printf("% d", j);
		for (k = i - 1; k > 0; k--)//打印右半边三角形
			printf("% d", k);
		printf("\n");
	}

	return 0;
}


​
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

⭐️3. 编程求某年第 n 天的日期。

⭐️用数组表示月天数。

int main(){
	int year, days, month = 0;
	int a[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	printf("请输入年,天数:");

	scanf("%d%d", &year, &days);

	int t = (year % 4 == 0 && year % 100 != 0 || year % 400 == 0);
	//判断闰年
	
	while (days > 0 && days < 365 + t){//<=0跳出
		days -= a[month];//总天数减去每个月份的天数
		month++;
	}
	if (days < 0){//若是days<0了 月份-1 在天数上加回来 days 加这个月的天数
		          //2022  50天  50天-1月=19天  19-28天 =-9  month=2  month-1=1  
		          //1是a[1] days=-9  -9+28 =19  也就是2月19日
		month--;
		days += a[month];
		//最后一次的时候天数不够减 days为负数了要加回来，变为每月的多少号
	}
	//month也是代表数组下标 0开始
	printf("%d-%d-%d \n", year, month + 1, days);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

⭐️求周岁

⭐️4.功能： 输入一个学生的生日（年： y0、 月： m0、 日： d0）， 并输入当前日期（年： y1、 月： m1、 日： d1）。 求出该学生的年龄（实足年龄）

    int main()
    {
    	int age, y0, y1, m0, m1, d0, d1;
    	printf("输入生日日期（年,月,日） ");
    	/***********SPACE***********/
    	scanf("%d%d%d", &y0, &m0, &d0);
    	printf("输入当前日期（年,月,日)");
    	scanf("%d%d%d", &y1, &m1, &d1);
    	age = y1 - y0;
    	/***********SPACE***********/
    	if (m0>m1)age--;//生日月份大于当前月份 2000 12 31     2022 6 2   
    	/***********SPACE***********/
    	if ((m0 == m1) && (d0>d1))age--; //两个月份相等的情况下 生日日期大于当前日期 age--
    	printf("age=%3d", age);
    	return 0;
    } ```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

⭐️5.编程求出使该算式成立时的这两个数，

⭐️5.功能： 算式： (空)2 * 7(空) = 3848 中缺少一个十位数和一个个位数编程求出使该算式成立时的这两个数， 并输出正确的算式。

    //功能： 算式： (空)2 * 7(空) = 3848 中缺少一个十位数和一个个位数。
    //编程求出使该算式成立时的这两个数， 并输出正确的算式。
     
    int main(){
    	int m, n;
    	for (m = 1; m <= 9; m++){
    		for (n = 0; n <= 9; n++){
    			if ((10 * m + 2)*(7 * 10 + n) == 3848){
    				printf("%d*%d", 10 * m + 2, 70 + n);
    			}
    		}
    	}
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

⭐️6.功能：(较难不用看) 编程求任意给两个日期（年 月 日）相差的天数。

//功能： 编程求任意给两个日期（年 月 日）相差的天数。
void date(int startyear, int startmonth, int startday, int endyear,
int endmonth, int endday){
	int arr[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	
	int flagmonth_sta, flagmonth_end, i, j,total=0;
	
	for (i = startyear; i <= endyear; i++){
		if (i == startyear)
			//开始年的月,按从开始的月计算
			flagmonth_sta = startmonth;
		else flagmonth_sta = 1;//否则在1月开始
 
		if (i == endyear)
			//若是末尾年月份在末尾月结束
			flagmonth_end = endmonth;
		else flagmonth_end = 12;//否则就在12结束
 
		//累加这一年月份的日子
		for (j = flagmonth_sta; j <= flagmonth_end; j++){
 
			//判断是不是闰年
			if (flagmonth_end > 2 && (i % 4 == 0 && i % 100 != 0 || i % 400 == 0)){
				arr[2] = 29;
			}
			else arr[2] = 28;
 
			int start_day, end_day;
			if (startmonth == j&&i==startyear)
				//是起始年的起始月
				start_day = startday;
			else start_day = 0;//否则天数是0
 
			if (endmonth == j&&i == endyear)
				//终止年的终止月 设为传过来得天数
				end_day = endday;
			else end_day = arr[j];//否则是数组的天数
 
			//；累加当前月份的日子
			for (int n = start_day; n <= end_day; n++)
			{
				total++;
			}
 
		}
 
	}
	printf("%d", total-1);
	
}
 
int main(){
	int startyear, startmonth, startday;
	int endyear, endmonth, endday;
	printf("请输入开始的年月日:");
	scanf("%d%d%d", &startyear, &startmonth, &startday);
	printf("请输入终止的年月日:");
	scanf("%d%d%d", &endyear, &endmonth, &endday);
	date(startyear, startmonth, startday, endyear, endmonth, endday);
 
 
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

⭐️7.把一个数的二进制奇数位和偶数位交换

    //写一个函数把一个数的二进制奇数位和偶数位交换
    void Print(int num){
    	int arr[32],count=0;
    	
    	while (num){
    		arr[count++]=num % 2;
    		num /= 2;
    	}
    	for (int i = count-1; i >= 0; i--)
    		printf("%d ", arr[i]);
    	printf("\n");
    }
    int  Swap(int num){
    	return ((num & 0xaaaaaaaa) >> 1) + ((num & 0x55555555) << 1);
    }
    int main(){
    	int num = 0;
    	printf("请输入一个数:");
    	scanf("%d", &num);
    	printf("初始二进制位:\n");
    	Print(num);
    	int result=Swap(num);
    	printf("Swap后十进制 = %d \n Swap后二进制位:\n",result);
    	Print(result);
     
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

⭐️8.题目要求找出数组中的两个单身狗

⭐️即数组中只有x个元素是单独不一样的，别的都是有相同的兄弟

    //题目要求找出数组中的两个单身狗，即数组中只有x个元素是单独不一样的，
    //别的都是有相同的兄弟
    int main(){
    	int arr[10] = { 1, 2, 5, 4, 9, 0, 1, 2, 3, 4 };
    	int flag;
    	//10个数循环比较10次 
    	for (int i = 0; i < 10; i++){
    		flag = 0;
    		//每个擂主要和全部的人比较，包括自己
    		for (int j = 0; j < 10; j++){
    			if (arr[i] == arr[j]){
    				flag++;//会和自己本身比较一下,所以找到单身狗flag=1 不是的大于1
    			}
    		}
    		if (flag <= 1)printf("单身狗= %d\n", arr[i]);
    	}
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

⭐️9. 数字字符串转换为整数

    //数字字符串转换为整数
    int isNumber(char a[]){
    	//-123
    	int i = 0, flag = 0;
    	if (a[0] == '-'){
    		//判断是不是数字字符
    		for ( i = 1; a[i] != '\0'; i++){
    			if (!(a[i] >= '0'&&a[i] <= '9'))
    				break;
    		}
    		if (a[i] == '\0')
    			flag = -1;
    		//若是判断是负数的数字字符返回-1
    	}
    	else {//不是负数数字字符的情况
    		for (i = 0; a[i] != '\0'; i++){
    			if (!(a[i] >= '0'&&a[i] <= '9'))
    				break;
    		}
    		if (a[i] == '\0')
    			flag = 1;//若是正数数字字符满足条件返回1
     
    	}
    	return flag;//0的情况是不是合法字符
     
    }
    void str_num(char a[]){
    	int i = 0,num=0,flag=1;//整数的符号
    	int start=-1;//判断字符串转换的起始位置
    	//判断是不是数字字符串
    	int flag11=isNumber(a);
    	if (flag11 == 0){
    		printf("不是合法数字字符\n");
    		return;
    	}
    	else if (flag11 == -1){//负数数字字符串转换为整数
    		flag = -1;
    		start = 1;
    	}
    	else if (flag11 == 1){
    		flag = 1;
    		start = 0;
    	}
    	//转化
    	for (i = start; a[i] != '\0'; i++){
    		num = num * 10 + a[i] - '0';
    	}
    	num *= flag;
    	printf("转换为的整数字符是:%d\n", num);
     
    }
    int main(){
    	char a[10];
    	printf("请输入一个字符串:");
    	gets(a);
    	str_num(a);
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

⭐️10.升序的数组插入一个数，还保持升序

    //升序的数组插入一个数，还保持升序
    void insert(int a[], int n,int sz){
    	int i = 0;
    	for (i = sz - 2; i >= 0; i--){
    		if (n < a[i]){//n小于数组的元素，该元素向后挪
    			a[i + 1] = a[i];
    		}
    		else {//否则就插入
    				a[i + 1] = n;
    				break;
    		}
    	}
    	//插入的数比数组元素都小的情况
    	if (i == -1)
    		a[0] = n;
    	
    	
    	
    }
    int main(){
    	int a[11] = { 1, 2, 3, 4, 5, 6, 7, 8, 10, 12 };
    	int sz = sizeof(a) / sizeof(a[0]);
    	int n = 0;
    	printf("请输入一个数字:");
    	scanf("%d", &n);
    	insert(a, n,sz);
    	for (int i = 0; i < 11; i++){
    		printf("%d ", a[i]);
    	}
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

⭐️11.输入年 月 判断该月多少天

    //输入年 月 判断该月多少天
    #include<stdio.h>
    int main(){
    	int y = 0;
    	int m = 0;//天数固定设计一个数组
    	int arr[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    	while (scanf("%d %d", &y, &m) != EOF){//ctrl+Z退出
    		int day = arr[m];//不要对arr[m]直接修改会改动数组内容
    		if (y % 4 == 0 && y % 100 != 0 || y % 400 == 0){
    			if (m == 2)
    				day += 1;
    		}
    		printf("%d\n", day);
    	}
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

⭐️12 遍历法求名次

    int main(){
    	int a = 0;
    	int b = 0;
    	int c = 0;
    	int d = 0;
    	int e = 0;
    	for (a = 0; a <= 5; a++){
    		for (b = 0; b <= 5; b++){
    			for (c = 0; c <= 5; c++){
    				for (d = 0; d <= 5; d++){
    					for (e = 0; e <= 5; e++){
    						//他们每个人说的对一半，逻辑值相加才等于1
    						if ((b == 2) + (a == 3) == 1
    							&& (b == 2) + (e == 4) == 1
    							&& (c== 1) + (d == 2) == 1
    							&&(c == 5) + (d == 3) == 1
    							&& (e == 4) + (a == 1) == 1){
    							if (a*b*c*d*e==120)//并且5个人的排名不能相同
    							printf("a=%d,b=%d,c=%d,d=%d,e=%d\n", a, b, c, d, e);
    							
    						}
    					}
    				}
    			}
    		}
    	}
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

⭐️13. 谁是凶手

    int main(){
    	char murder;
    	for (murder = 'A'; murder <= 'D'; murder++){
    		//遍历这四个人，且要满足这4个条件
    		if ((murder != 'A') + (murder == 'C') + (murder == 'D') + (murder != 'D')
    			==3){//这四个条件里面3个真的一个假的，所以相加后的逻辑值 ==3才行
    			printf("murder是  %c\n", murder);
    		}
    	}
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11

⭐️14.输入一个整数数组，实现一个函数，来调整数组中的奇数和偶数的位置，奇数在前偶数在后

    //法1 
    void reverse(int a[], int sz, int temp1[], int temp2[]){
    	int j_num = 0, o_num=0, i;
    	for (i = 0; i < sz; i++){
    		if (a[i] % 2 == 0){//存到偶数暂存数组
    			temp1[o_num++] = a[i];
    		}
    		else if (a[i] % 2 != 0){
    			temp2[j_num++] = a[i];
    		}
    	}
    	for (i = 0; i < j_num; i++){//所有奇数放回去
    		a[i] = temp2[i];
    	}
    	for (int j=0; j < o_num; j++,i++){//所有偶数放回去
    		a[i] = temp1[j];//j来控制偶数数组下标
    	}
     
    }
    int main(){
    	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    	int temp1[10];//暂存奇数偶数的数组
    	int temp2[10];
    	int sz = sizeof(a) / sizeof(a[0]);
    	reverse(a, sz,temp1,temp2);
    	for (int i = 0; i < sz; i++){
    		printf("%d ", a[i]);
    	}
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

⭐️法2：

//法2
void reverse(int left[], int right[]){
	//left指向起始  right指向数组末尾
	while (left < right){
		while ((left<right)&&*left % 2 != 0){
			left++;//如果*left是奇数就循环接着向后指,直到指向偶数就退出
		}
		//（left<right）是避免全是奇数的情况，指导最后一个元素，在向后指就越界了
		while ((right>left)&&*right % 2 == 0){
			right--;//如果*right是偶数就循环接着向前指,直到指向奇数就退出
			
		}
 
		//左边的偶数和右边的奇数交换
		if (left < right){
			int temp = *left;
			*left = *right;
			*right = temp;
		}
	}
}
int main(){
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	
	int sz = sizeof(a) / sizeof(a[0]);
	reverse(a, a+sz-1);
	for (int i = 0; i < sz; i++){
		printf("%d ", a[i]);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

⭐️15.1元一瓶汽水，两个空瓶可以换一瓶，问20元可以喝多少瓶

    int main(){
    	int total = 0, empty = 0, money;
    	printf("请输入钱数:");
    	scanf("%d", &money);
    	total = money;//初始瓶子数
    	empty = money;//空瓶数
    	while (empty >= 2){//大于等于2才能换
    		total += empty / 2;//两瓶换一瓶换的累加到总和上去
    		empty = empty / 2 + empty % 2;//更新空瓶数量有奇数瓶的要加上
    	}
    	printf("能喝 %d 瓶\n", total);
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

⭐️16.打印一个菱形，输如n的打印2*n - 1行的菱形

    //打印一个菱形，输如n的打印2*n - 1行的菱形
     
    int main(){
    	int n = 0;
    	printf("请输入一个数字:");
    	scanf("%d", &n);
    	int i, j;
    	for (i = 0; i < n; i++){//打印上三角
    		//打印空格
    		for (j = 0; j < n - 1 - i; j++){
    			printf(" ");
    		}
    		//打印*
    		for (j = 0; j <= 2 * i; j++){
    			printf("*");
    		}
    		printf("\n");
    	}
    	//打印下三角
    	for (i = 0; i < n - 1; i++){
    		//打印空格
    		for (j = 0; j <= i; j++){
    			printf(" ");
    		}
    		//打印*
    		for (j = 0; j <= 2 * n - 4 - 2 * i; j++){
    			printf("*");
    		}
    		printf("\n");
    	}
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

⭐️17.输入一个整数找出紧跟在他后面的素数

    //输入一个整数找出紧跟在他后面的素数
    int find(int n){
    	int i;
    	while (n){
    		for ( i = 2; i < n; i++){
    			if (n%i == 0){
    				break;
    			}
    		}
    		if (n == i)return n;
    		n++;
    	}
    	printf("输入不合法");
    	return -1;
    }
    int  main(){
    	int n = 0;
    	printf("请输入一个大于1的数：");
    	scanf("%d", &n);
    	printf("紧跟的素数是:%d", find(n));
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

⭐️18.计数求和，Sn=2+22+222+2222+22222

    int main(){
    	int a = 0, total = 0, n = 0, temp = 0;
    	printf("请输入一个数:a\n");
    	scanf("%d", &a);
    	printf("请输入这个数的幂次:n\n");
    	scanf("%d", &n);
     
    	while (n){
    		//第一次 0*10+2=2   第二次 2*10+2=22  .......
    		temp = temp * 10 + a;
    		//累加
    		total += temp;
    		n--;//次数-1
    	}
    	printf("%d",  total);
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

⭐️19.输入两个数求最小公倍数和最大公因数，代码中有详解

⭐️法1：

    ///输入两个数求最小公倍数和最大公因数，代码中有详解
    //法1
     
    int main(){
    	int n, m;
    	printf("请输入两个数:");
    	scanf("%d%d", &n, &m);
    	if (m < n){//m存大数，n存小数
    		m = m^n;
    		n = n^m;
    		m = n^m;
    	}
    	int p = m*n;
    	
    	int i;
    	for ( i = n; i >= 1; i--){
    		//两个数的因子最多不会超过小数n，所以从n开始向下试
    		//并且要满足这个条件
    		if (m%i == 0 && n%i==0){
    			printf("最大公因数=%d\n", i);
    			break;
    		}
    	}
    	printf("最小公倍数就是两数的积除以最大公约数=%d", p / i);
     
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

⭐️法2：

    //法2
     
    int main(){
    	int n, m;
    	printf("请输入两个数:");
    	scanf("%d%d", &n, &m);
    	if (m < n){//m存大数，n存小数
    		m = m^n;
    		n = n^m;
    		m = n^m;
    	}
    	int p = m*n;
    	
    	int r = 0;
    	while (n){
    		r = m%n;
    		m = n;
    		n = r;
    	}
     
    	printf("最大公约数是：%d, 最小公倍数是:%d\n", m, p / m);
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

⭐️递归版

//递归方法求最大公约数
int fun(int m, int n){
	if (n == 0)return m;
	else {
		int r = m%n;
		m = n;
		n = r;
		return fun(m, n);
	}
}

int main(){
	int m, n;
	printf("请输入两个数：\n");
	scanf("%d%d", &m, &n);
	if (m < n){
		int t = m;
		m = n;
		n = t;
	}

	printf("最大公约数是：%d\n", fun(m, n));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

⭐️20.一个数 +100之后是完全平方数,+168还是一个完全平方数

     
    //一个数 +100之后是完全平方数,+168还是一个完全平方数 
    //2*2=4 3*3=9 就是完全平方数
    #include<math.h>
    int main(){
    	int n = 1, t = 0, k = 0,m=0,k1;
    	while (n){
    		
    		k1 = sqrt(n+100);//返回一个double 放int 直接取整了
    		k = sqrt(n+168);
    		if (k*k == n+168&&k1*k1==n+100){
    			printf("%d",n);
    			break;
    		}
    		n++;
    	}
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

⭐️21 .数字金字塔

    //数字金字塔
    int main(){
    	int n = 0;
    	printf("请输入一个数：");
    	scanf("%d", &n);
    	int i = 0, j = 0;
    	//打印三角
    	for (i = 0; i < n; i++){
    		//打印空格
    		for (j = 0; j < n - 1 - i; j++)
    			printf(" ");
    		//打印*
    		for (j = 0; j <= 2*i; j++){
    			printf("%d", n);
    		}
    		printf("\n");
    	}
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

⭐️22.字符串左旋

⭐️实现一个函数，可以左旋字符中的K个字符 例如：ABCD左旋一个字符变成BCDA ABCD左旋两个字符变成CDAB

//字符串左旋
//实现一个函数，可以左旋字符中的K个字符
//例如：
//ABCD左旋一个字符变成BCDA
//ABCD左旋两个字符变成CDAB
void reverse(char a[], char n){
	int end=strlen(a) - 1,i;//end指向最后一个
	char temp;
	while (n){
		temp = a[end];//把最后一个挪到temp暂存
		//从倒数第2个开始向前挪
		for (i = end - 1; i >= 0; i--){
			a[i + 1] = a[i];
		}
		//挪完把temp的字符放到a[0]
		a[0] = temp;
		n--;
	}
}
int main(){
	char a[20];
	printf("请输入一个字符串:");
	gets(a);
	int n = 0;
	printf("请输入一个左旋的数字:");
	scanf("%d", &n);
	reverse(a,n);
	printf("%s\n", a);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

⭐️23.【稍难不用看】要求：写一个函数判断一个字符串是否是另一个字符串旋转后得到的

⭐️ 例如：ABCDE与EDCBA这俩个显然是abcd与ABCD 这显然不是

    //要求：写一个函数判断一个字符串是否是另一个字符串旋转后得到的
    //例如：ABCDE与EDCBA这俩个显然是
    //abcd与ABCD 这显然不是
    #include<string.h>
    int judge_string(char* str1, char* str2){
    	int i, j = 0;
    	int len = strlen(str1);
    	//循环字符串长度次
    	for (i = 0; i < len; i++){
    //先比较两个字符串是不是相等
    		if (strcmp(str1, str2) == 0)
    			return 1;
     
    		//不相等,挪1位在判断是不是相等
    		char endchar = str1[strlen(str1)-1];
    		//从倒数第2个开始向前挪
    		for (j = strlen(str1) - 2; j >= 0; j-- ){
    			str1[j + 1] = str1[j];
    		}
    		str1[0] = endchar;
    		//接着循环比较挪完1位的是不是相同了
    	}
    	return 0;
    }
    int main(){
    	char arr1[10] = "ABCDEF";
    	char arr2[10] = "CDEFAB";
    	int ret = judge_string(arr1, arr2);//返回1 说明是，返回0 不是
    	if (ret == 1){
    		printf("yes");
    	}
    	else printf("no");
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

⭐️24.给数组删除重复的元素

    //给数组删除重复的元素
    #include<stdio.h>
    #define N 12
    int main(){
    	int a[N] = { 1, 1, 2, 3, 3, 4, 6, 4, 8, 6,9,8};
    	int i = 0, j = 0, n = N;
    	//n个数比较n-1次
    	printf("==========去重之前=========\n");
    	for (i = 0; i < n; i++){
    		printf("%d ", a[i]);
    	}
    	for (i = 0; i < n - 1; i++){
     
    		for (j = i + 1; j < n; j++){
    			if (a[i] == a[j]){
    				//i位置上的数和后面的比较要是相同，依次向前挪
    				for (int k = j; k < n - 1; k++){
    					a[k] = a[k + 1];
    				}
    				--n;//把一个数字给干掉了所以n--;
    				--j;//从j+1后面的位置一直依次向钱挪 j位置被换了新值，所以--j还要再次看
    				//当前j位置的数与前面的重复嘛
    			}
    			
    		}
    	}
    	printf("\n==========去重之后=========\n");
    	for (i = 0; i < n; i++){
    		printf("%d ", a[i]);
    	}
    	return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

注意n–了之后，循环的访问范围就减少一个，所以被挪一个减少一个访问范围

⭐️25.C语言编程题求1！ + 2！ + 3！ + 4！… + N！

//C语言编程题————求1！ + 2！ + 3！ + 4！..... + N！
int main(){
	int total = 0, t = 1, i = 0;
	int n;
	printf("请输入一个数:");
	scanf("%d", &n);
	for (i = 1; i <=n; i++){
		t *= i;//累乘 第一次 1！ 第二次 2! 

		printf("%d的阶乘 : %d\n", i,t);
		total += t;//累加阶乘
	}
	printf("总和 %d! :%d\n", n, total);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

⭐️26.C语言编程题求斐波那契数（循环法与递归法）

⭐️递归法

//法1 递归法
int fib(int n){
	if (n > 2){
		return fib(n - 1) + fib(n - 2);
	}
	else return 1;
}
int main(){
	int n = 0;
	printf("您要得到第几个菲薄纳妾数：");
	scanf("%d", &n);
	
	printf("%d\n", fib(n));

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

⭐️普通的方法

//斐波那契数列 1,1,2,3,5,8,13,21 前面的两个数的和是后面这个数
int fib1(int n){
	int a = 1, b = 1, c = 1;
	//a是前2个数 b是前1个数  
	while (n > 2){
		c = a + b;//(1) 1+1=2  (2) 1+2=3
		a = b;// (1) a=1       (2) a=2 前一个数等于后一个数

		b = c;// (1) b=2       (2) b=3 算出的C就是下次循环要相加的后一个数
		n--;
	}
	return c;// 第1位 第2位 都是 1
}
int main(){
	int n = 0;
	printf("您要得到第几个菲薄纳妾数：");
	scanf("%d", &n);
	
	printf("%d\n", fib1(n));

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

⭐️数组的方法:

//数组法
int main(){

	int a[500];
	int n = 0;
	printf("请输入一个数n：\n");
	scanf("%d", &n);
	int i;
	a[0] = 1, a[1] = 1;
	for (i = 2; i <=n; i++){
		a[i] = a[i - 1] + a[i - 2];
		//前1个数+前2个数=当前数
		//也就是为数组赋值
	}

	printf("打印前n个斐波那契数===============\n");
	for (i =0 ; i <=n; i++){
		
		printf("%6d ", a[i]);
		//每行打印5个
		if ((i + 1) % 5 == 0)printf("\n");

	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

⭐️27.C语言编程输入n，k求n的k次幂（递归与非递归）

⭐️递归法:

//C语言编程————输入n，k,求n的k次幂（用递归的方法）
int fun(int n, int k){
	if (k <1)return 1;//0次幂都是1
	else return n*fun(n, k - 1);//否则 n*多次调用fun
}
int main(){
	int n, k;
	printf("请输入(n,k):");
	scanf("%d%d", &n,&k);
	printf("%d", fun(n, k));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

递归过程图：

⭐️非递归法:

//C语言编程————输入n，k,求n的k次幂（非递归的方法）
int fun(int n, int k){
	int total = 1;
	while (k--){
		total *= n;
	}
	return total;
}
int main(){
	int n, k;
	printf("请输入(n,k):");
	scanf("%d%d", &n,&k);
	printf("%d", fun(n, k));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

⭐️28.(递归)输入一个数，把他的每一位相加在输出出来；

⭐️如1234 1 + 2 + 3 + 4 = 10

//用函数实现输入一个数，把他的每一位相加在输出出来；如1234 1 + 2 + 3 + 4 = 10
int deal(int num){
	if (num > 9)
		return num % 10 + deal(num / 10);
	//大于9 就先%10 得到余数 在加 deal(num/10）若小于10 单一一个数直接返回这个数
	else return num;
}
int main(){
	int num = 0;
	printf("请输入一个数：");
	scanf("%d", &num);
	printf("%d各位相加之后的和是：%d\n", num, deal(num));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

⭐️29.实现函数把字符数组的元素逆序 如“abc“, 逆序成“cba“.

⭐️非递归版

//实现函数把字符数组的元素逆序 如“abc“, 逆序成“cba“.

void reverse(char a[]){
	int start = 0, end = strlen(a) - 1;//-1为了不去挪'\0'
	while (start < end){
		//首尾交换 直到start和end都指向同一个或者start>end时候结束交换
		char temp = a[start];
		a[start] = a[end];
		a[end] = temp;
		start++;//向后指
		end--;//向前指
	}

}
int main(){
	char a[20];
	printf("请输入一个字符串:");
	gets(a);
	reverse(a);
	printf("逆序之后:%s\n", a);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

⭐️递归版:

void reverse(char a[]){
	char temp = a[0];//进来之后先把当前数组的首元素赋值到临时变量

	int len = strlen(a) - 1;//指向最后一个元素

	a[0] = a[len];//把最后一个元素给第一个元素空间

	a[len] = '\0';//把最后一个元素赋值'\0'

	if (len >= 2){//若是字符串长度大于2就要交换
		reverse(a + 1);//再次调用 向前指一个
	}
	//完成递归之后 把在栈中的每个temp返回放到当前a[len]中
	a[len] = temp;
}

int main(){
	char a[20];
	printf("请输入一个字符串:");
	gets(a);
	reverse(a);
	printf("逆序之后:%s\n", a);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

⭐️30. 递归拆分整数

//递归拆分整数
void deal(int n){
	if (n > 9)deal(n / 10);
	printf("%d ", n % 10);
}
int main(){
	int num = 0;
	printf("请输入一个数：\n");
	scanf("%d", &num);
	deal(num);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

⭐️31.设计以函数打印乘法口诀表，

⭐️输入9，是99乘法表，输入8是88乘法表

//设计以函数打印乘法口诀表，输入9，是99乘法表，输入8是88乘法表
void Print1(int n){
	int i = 0, j = 0;
	for (i = 1; i <= n; i++){
		for (j = 1; j <= i; j++){
			printf("%d*%d=%3d	", i, j, i*j);
		}
		printf("\n");
	}
}
int main(){
	int num = 0;
	printf("请输入一个数：");
	scanf("%d", &num);
	Print1(num);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

⭐️32.构造一函数判断是否为素数100-200之间（只能被自己和1整除的数）

//素数100 - 200之间（只能被自己和1整除的数）
int main(){
	int i = 0;
	for (i = 100; i <= 200; i++){
		int j;
		for (j = 2; j < i; j++){
			if (i%j == 0)break;
		}
		if (i == j)printf("%4d", i);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

⭐️33.打印二进制数的奇数位和偶数位；分别打印二进制序列

//打印二进制数的奇数位和偶数位；分别打印二进制序列
void Print_two(int n){
	int i;
	
	printf("打印奇数位:\n");
	//右移0位是第一个二进制 所以右移 30位其实是第31个二进制位
	for (i = 30; i>=0; i-=2){
		printf("%d ", (1 & (n >> i)));
	}
	printf("\n打印偶数位:\n");
	//右移1位是第二个二进制 所以右移 31位其实是第32个二进制位
	for (i = 31; i >= 0; i -= 2){
		printf("%d ", (1 & (n >> i)));
	}
}
int main(){
	int n = 0;
	printf("请输入一个数字:");
	scanf("%d", &n);
	Print_two(n);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

⭐️34.计算M和N二进制中不同的位数，例如 1和7 有两位不同；

//计算M和N二进制中不同的位数，例如 1和7 有两位不同；
int main(){
	int n, m;
	printf("请输入2个数:");
	scanf("%d%d", &n, &m);
	int t = m^n;//通过二进制亦或后，相同为0不同为1,故此t里面1的个数就代表n和m之间有几个二进制位
	//不同
	
	//求出t里面有多少个1
	int count = 0, i = 0;
	while (i < 32){//移位32次 移了31位
		//右移1位与1==1就说明当前二进制位是1
		if (t >> i & 1 == 1){
			count++;
		}
		i++;
	}
	printf("二进制位不同有%d位\n", count);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

⭐️35.输出1900到2000之间的所有闰年

//输出1900到2000之间的所有闰年
int main(){
	for (int i= 1900; i <= 2000; i++){//世纪闰年 必须是400的倍数
		if ((i % 4 == 0 && i % 100 != 0) || (i % 400 == 0 ))
		{
			printf("%d是闰年  ",i);
		}
	}
}//润年分为世纪闰年和普通润年  
//普通闰年是  能整除4就行   为啥还要加%100不等于0呢  排除不是世纪闰年的 比如1900 不是闰年
//整百数的世纪闰年是   能整除400就行

1
2
3
4
5
6
7
8
9
10
11
12

⭐️36. 猴子吃桃问题

⭐️有一群猴子，去摘了一堆桃子*商量之后决定每天吃剩余桃子的一半当每天大家吃完桃子之后，有个贪心的小猴都会偷偷再吃一个桃子按照这样的方式猴子们每天都快乐的吃着桃子直到第十天，当大家再想吃桃子时，发现只剩下一个桃子问：猴子们一共摘了多少桃子

当前天吃前一天的一半零一个 .prvday/2+1=curday ---->(curday+1)*2=prvday
前一天/2+1=当前天的数量

/*有一群猴子，去摘了一堆桃子*/

/*商量之后决定每天吃剩余桃子的一半*/

/*当每天大家吃完桃子之后，有个贪心的小猴都会偷偷再吃一个桃子*/

/*按照这样的方式猴子们每天都快乐的吃着桃子*/

/*直到第十天，当大家再想吃桃子时，发现只剩下一个桃子了*/

//问：猴子们一共摘了多少桃子

//当前天吃前一天的一半零一个 
  //prvday/2+1=curday  ---->(curday+1)*2=prvday
//前一天/2+1=当前天的数量  

int main(){
	int curday = 1, prvday = 0;
	int days = 9;
	while (days > 0){
		//第一次循环 算出第一次前一天的数量
		prvday = (curday + 1) * 2;

		curday = prvday;//前一天的数量在给到当前天 接着循环
		days--;
	}
	printf("猴子摘了%d个桃子\n", curday);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

⭐️37.选择排序法 升序排列

Print_(int *a,int sz){
	printf("打印数组情况===============\n");

	for (int i = 0; i < sz; i++){
		printf("%d ", a[i]);
	}
	printf("\n");
}

//选择排序法 升序排列
int main(){
	int a[10] = { 1, 4, 7, 2, 5, 8, 3, 6, 9, 0 };
	int i, j, index;
	int sz = sizeof(a) / sizeof(a[0]);
	//10个数循环比较9次就行
	for (i = 0; i < sz - 1; i++){
		index = i;//index看为擂主
		for (j = i + 1; j < sz; j++){
			//index和j下标的打擂台，让index指向最小的数
			if (a[index] >a[j])index = j;
			
		}
		if (index != i){//把最小的数放到i下标的位置
			int t = a[index];
			a[index] = a[i];
			a[i] = t;
		}
	}

	Print_(a,sz);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

⭐️38.冒泡排序法

⭐️比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定性算法。

冒泡排序基础的排序算法，也是我们必须要牢牢掌握的一种算法。

//冒泡排序法
int main(){
	int a[10] = { 1, 4, 7, 2, 5, 8, 3, 6, 9, 0 };
		int i, j;
		int sz = sizeof(a) / sizeof(a[0]);
		//10个数循环比较9次就行
		for (i = 0; i < sz - 1; i++){

			for (j = 0; j < sz - 1 - i; j++){
				//从0号下标开始和后面的比较，若是当前j号大于j+1号就交换
				//第1轮把最大的放到最后，所以j < sz - 1 - i  减i为了
				//之前挪到后面的较大数不在发生没必要的比较

				if (a[j]>a[j + 1]){
					int t = a[j];
					a[j] = a[j + 1];
					a[j + 1] = t;
				}
			}
		}

		Print_(a, sz);
		return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

⭐️39.求3*3矩阵对角元素的和

//求3*3矩阵对角元素的和
int main(){
	int total = 0, a[3][3] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
	int i,j;
	//主对角
	for (i = 0; i < 3; i++){
		total += a[i][i];
	}
	//副对角
	for (i = 0, j = 2; i < 3; i++, j--){
		if (i != j){
			total += a[i][j];
		}
	}

	printf("total=%d\n", total);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

⭐️40.把整数数组中的元素值逆序存放

//把整数数组中的元素值逆序存放

int main(){
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int left=0, right = sizeof(a) / sizeof(a[0])-1;

	while (left < right){
		int t = a[left];
		a[left] = a[right];
		a[right] = t;
		left++;
		right--;
	}

	Print_(a, 10);//打印函数
	return 0;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

⭐️41.杨辉三角形

//杨辉三角形
//int main(){
//	//利用二维数组
//	int a[10][10];
//	for (int i = 0; i < 10; i++){//循环10次
//		for (int j = 0; j <= i; j++){
//			if (0 == j || i == j){
//				a[i][j] = 1;//对角线元素和0列赋值
//			}
//			else{//其余元素赋值
//				a[i][j] = a[i - 1][j] + a[i - 1][j - 1];
//			}
//		}
//	}
//	for (int i = 0; i < 10; i++){
//		for (int j = 0; j <= i; j++){
//			printf("%4d", a[i][j]);
//		}
//		printf("\n");
//	}
//	return 0;
//}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

⭐️42.折半查找—必须建立在有序的数组中

//折半查找---必须建立在有序的数组中
int main(){
	int a[11] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,11 };
	//left指向第一个  right指向最后一个
	int left = 0, right = sizeof(a) / sizeof(a[0])-1;

	int n,mid=right;//第一次指向最后一个
	printf("请输入要查找得数：");
	scanf("%d", &n);


	while (left < right){

		if (a[mid] < n){//中间元素<n 说明当前左边的全小于n
			left = mid;//所以left等于mid
		}
		else if (a[mid]>n){//中间元素>n 说明当前右边的全大于n
			right = mid;//所以right等于mid
		}
		else {
			printf("找到了 下标是%d\n", mid);
			break;
		}
		mid = (left + right) / 2;//在除以2改变循环条件
	}

	if (left >= right)printf("没有找到该元素\n");
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

⭐️43. 计算3行 80个字符 的类型个数

// 计算3行  80个字符 的类型个数
int main(){
	char ch[3][80];
	int i = 0;
	//输入3行字符
	//for (i = 0; i < 3; i++){
	//	gets(ch[i]);//scanf遇到空格或者换行就结束了
	//}
	int max_sum = 0, min_sum = 0, number_sum = 0, speace_sum = 0, other_sum = 0;
	for (i = 0; i < 3; i++){
		gets(ch[i]);
		for (int j = 0; ch[i][j] != '\0'; j++){
			if (ch[i][j]>='a'&&ch[i][j]<= 'z')
				min_sum++;
			else if (ch[i][j]>='A'&&ch[i][j] <= 'Z')
				max_sum++;
			else if (ch[i][j]>='0'&&ch[i][j] <= '9')
				number_sum++;
			else if (ch[i][j]==' ')
				speace_sum++;
			else other_sum++;
		}
	}
	printf("小写字母：%d\n大写字母：%d\n数字数量：%d\n空格数量：%d\n其它字符数量：%d\n", min_sum, max_sum,\
		number_sum,speace_sum, other_sum);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

⭐️44. 原文与密码

⭐️输入A转换为Z B<–>Y c<–>X 以此类推

//原文与密码  输入A转换为Z B<-->Y   c<-->X  以此类推

int main(){
	char a[30];
	
	printf("请输入一串字母:\n");
	gets(a);
	int i = 0;
	while (a[i]){
		if (a[i] >= 'a'&&a[i] <= 'z'){
			a[i] = 'a' + 25-(a[i] - 'a');
			//基值'a' +25-（差值）  a[i] 若是'a'  a[i]-'a'=0  'a'+25+0=z

		}
		if (a[i] >= 'A'&&a[i] <= 'Z'){
			a[i] = 'A' + 25-(a[i] - 'A');
			//基值'a' +25-（差值）  a[i] 若是'a'  a[i]-'a'=0  'a'+25+0=z

		}
		i++;

	}
	printf("转换之后：%s\n", a);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

⭐️45.模拟strcat字符串连接函数

//模拟strcat字符串连接函数
void My_strcat(char *str1, char *str2){
	while (*str1)str1++;//先让str1指向'\0'
	while (*str1 = *str2){//把当前str2指向的字符赋值给str1指向的空间
		                  //结束条件是*str1指向的空间被赋值了'\0'
		str1++, str2++;//两个指针变量分别向后指
	}
}
int main(){
	char str1[20];
	char str2[20];
	printf("请输入两个字符串:");
	gets(str1);
	gets(str2);
	My_strcat(str1, str2);
	printf("连接之后:%s\n", str1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

⭐️46.模拟strlen(3种方法)

⭐️方法1：计数器法

//模拟strlen
//方法1 普通式
int My_strlen(char *a){//abc
	int count = 0;
	while (*a != '\0'){//不是'\0'  count就加1
		count++;
		a++;
	}
	return count;
}
int main(){
	char a[30];
	printf("请输入一个字符串:");
	gets(a);
	printf("字符串的长度是：%d\n", My_strlen(a));
	return 0; 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

⭐️方法2：指针减指针法

//方法2 指针减指针法
int My_strlen2(char *a){//abc
	int *start = a;//字符串的首地址先暂存到一个指针变量里面去
	while (*a != '\0')a++;//在让a指向'\0'
	return a - start;//指针减指针代表指针之间经历的元素个数
}
int main(){
	char a[30];
	printf("请输入一个字符串:");
	gets(a);
	printf("字符串的长度是：%d\n", My_strlen2(a));
	return 0; 
}
1
2
3
4
5
6
7
8
9
10
11
12
13

⭐️方法3：递归方法（图解）

int My_strlen3(char *a){//abc
	if (*a == '\0')return 0;
	return 1 + My_strlen3(a + 1);
}
int main(){
	char a[30];
	printf("请输入一个字符串:");
	gets(a);
	printf("字符串的长度是：%d\n", My_strlen3(a));
	return 0; 
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14

⭐️47.模拟strcmp

//模拟strcmp--两个字符串完全相等就返回0 不相等就返回*a-*b的差值
int My_strcmp(char *a, char *b){
	while (*a == *b){//对应下标数的字符相等就循环
		if (*a == '\0')return 0;//若是有一个等于'\0'说明这两串相等
		a++, b++;//++比较下一位
	}
	return *a - *b;//不满足循环就返回差值
}
int main(){
	char a[30], b[30];
		printf("请输入2个字符串:");
		gets(a);
		gets(b);
		int flag = My_strcmp(a, b);
		if (!flag)printf("两个字符串是相等的--返回%d\n",flag);
		else printf("两个字符串是不相等的--返回%d\n",flag);
		return 0; 
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

⭐️48.模拟字符串拷贝函数strcpy

//模拟字符串拷贝函数
void My_strcpy(char *a, char *b){
	while (*a++ = *b++);//先用后加 先用*a的空  和*b的内容 换句话说就是
	//把*b的内容放到*a的空间中  然后a在++ b在++
}
int main(){
	char a[20], b[20];
	printf("请输入一个字符串:");
	gets(b);//b字符串拷贝到a数组
	My_strcpy(a, b);
	printf("拷贝到a数组之后:%s", a);

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

⭐️49.strncpy的模拟

⭐️拷贝给定的个数,若是输入的k大于b字符串长度，直接拷贝b字符串全部

//strncpy的模拟  拷贝给定的个数,若是输入的k大于b字符串长度，直接拷贝b字符串全部
void My_strncpy(char *a, char *b, int k){
	while (k&&(*a=*b)){//进来先判断k值 若是0退出  或者*b赋值*a之后*a是'\0'了也退出
		a++, b++;//两个指针变量指向下一个字符
		k--;//拷贝的个数减1
	}
	if (*a != '\0')*a = '\0';//若拷贝了k个b数组还没有拷贝完  也就是从k=0这个条件退出的
	//*a不是'\0'要把'\0'拷贝过去
}
int main(){
	char a[20], b[20];
	printf("请输入一个字符串:\n");
	gets(b);//b字符串拷贝到a数组
	int k = 0;
	printf("请输入拷贝的个数:\n");
	scanf("%d", &k);
	My_strncpy(a, b, k);
	printf("拷贝到a数组之后:%s\n", a);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

⭐️50.strncat模拟实现

在字符串str1后面追加给定的k个字符 思路就别strncpy多一步 先找到str1的’\0’在追加

//strncat模拟实现 
//在字符串str1后面追加给定的k个字符  思路就别strncpy多一步  先找到str1的'\0'在追加
void My_strncat(char *str1, char *str2, int k){
	while (*str1)str1++;//指向'\0'
	while (k && (*str1 = *str2)){//进来先判断k值 若是0退出  或者*str2赋值*str1之后*str1是'\0'了也退出
                     //两个指针变量指向下一个字符
		str1++, str2++;//向后指
		k--;//个数-1
	}
	if (*str1 != '\0')*str1 = '\0';//若拷贝了k个str2数组还没有拷贝完  也就是从k=0这个条件退出的
//	//*str1不是'\0'要把'\0'拷贝过去
}
int main(){
	char str1[20];
	char str2[20];
	int k = 0;
	printf("请输入两个字符串:");
	gets(str1);
	gets(str2);

	printf("请输入一个数:\n");
	scanf("%d", &k);

	My_strncat(str1, str2,k);
	printf("连接之后:%s\n", str1);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

⭐️51.模拟strncmp

⭐️比较两个字符串的前n个字符是不是相等

int My_strncmp(char *a, char*b, int k){
	int t = k;
	while (k&&*a == *b){
		if (*a == '\0'){
			printf("两个字符串都遇到的'\0' 相同 \n\n");
			return 0;
		}
		a++, b++;//指向下一个字符
		k--;//个数--
	}
	if (k == 0){//若是在k=0时退出 说明前k个字符相等
		printf("前%d个字符是相同的退出\n\n", t);
		return 0; 
	}
	else return *a - *b;//否则while循环是因为两个字符串不相等退出的返回差值
}

int main(){
	char a[30], b[30];
	int k;
	printf("请输入两个字符串:\n");
	gets(a);
	gets(b);
	printf("请输入一个数K:\n");
	scanf("%d", &k);
	int flag = My_strncmp(a, b,k);
	if (!flag)printf("两个字符串是相等的--返回: %d\n", flag);
	else printf("两个字符串是不相等的--返回: %d\n", flag);
	
	return 0;
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

⭐️52.(较难些可以不看)模拟寻找子串的函数strstr

//模拟寻找子串的函数strstr
char * My_strstr(char *a, char *b){
	if (*b =='\0')return a;//如果b数组是空数组直接返回a数组名
	char *na = NULL;//内层指针
	char *nb = NULL;//内层指针
	while (*a){
		na = a;//na每次指向下一个
		nb = b;//每次nb指向b串的第一个元素
		while (*nb == *na&&*na != '\0'&&*nb != '\0'){
			nb++, na++;//元素相等++
		}
		//如果*nb=='\0'说明上面循环nb指向'\0'前面几个元素是相等的
		if (*nb == '\0')return a;
		a++;
	}
	//a指向'\0'说明a不存在子串
	if (*a == '\0')return NULL;
}


int main(){
	char a[20];//abcdef
	char b[20];//abcdefj     查找a数组里面有没有bcd
	printf("请输入2个字符串:");
	gets(a);
	gets(b);

	char *c=My_strstr(a, b);
	if (c != NULL)printf("找的了：%s\n", c);
	else printf("没有找的子串\n");
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

⭐️53.内存拷贝函数

⭐️memcpy(src,dest,size);size代表拷贝的字节数

//内存拷贝函数memcpy(src,dest,size);size代表拷贝的字节数
void My_memcpy(void *a, void *b, int sz){
	
	char *src = (char*)a;//转化为char*可以对一个字节处理
	char *dest = (char*)b;

	while (sz){
		*src = *dest;
		src++, dest++;//向后指一的字节
		sz--;//拷贝的字节数-1
	}
}
int main(){
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int b[10] = { 0 };
	My_memcpy(b,a,20);//20字节 int 占4字节  也就是5个元素
	for (int i = 0; i < 10; i++)
		printf("%d ", b[i]);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

⭐️54.判断一个数是不是素数:

//判断一个数是不是素数:
void fun(int n){
	int i = 0;
	for (i = 2; i < n; i++){
		if (n%i == 0){
			printf("不是素数...");
			return;
		}
	}
	if (i == n)printf("是素数...");
}
int main(){
	int n = 0;
	printf("请输入一个数：\n");
	scanf("%d", &n);
	fun(n);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

⭐️55.3*3矩阵的转置

//3*3矩阵的转置
void Print(int a[][3]){
	int i = 0, j = 0;
	for (i = 0; i < 3; i++){
		for (j = 0; j < 3; j++){
			printf("%d ", a[i][j]);
		}
		printf("\n");
	}
	printf("\n");
}
int main(){
	int a[3][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int i = 0, j = 0;
	printf("转置之前=============\n");
	Print(a);
	//转置
	for (i = 0; i < 3; i++){
		for (j = 0; j < i; j++){
			int t = a[i][j];
			a[i][j] = a[j][i];
			a[j][i] = t;
		}
	}
	printf("转置之后=============\n");
	Print(a);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

⭐️56.任何比 2 大的偶数， 总能表示两个素数，

⭐️比如 24=5+19； 5 和 19 都是素数

⭐️解释：

int fun_(int n){
	int i = 0;
	for (i = 2; i < n; i++){
		if (n%i == 0)return 0;
	}
	if (i == n)return n;
}
int main(){
	int n = 0;
	do{
		printf("请输入一个偶数:");
		scanf("%d", &n);
	} while (n % 2 != 0);

	int t = 2, m = n - 2;//必须是-2
	//例如 1,2,3,4,5,6

	// 1,2,3,4,5,6,7,8

	//1,2,3,4,5,6,7,8,9,10
	//左边从2开始  右边从n-2开始
	while (t < n&&m >= 2){
		if (fun_(t) && fun_(m)){//两个全是素数才行
			printf("%d+%d=%d", t, m, n);
			break;
		}
		t++, m--;//--再试
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

⭐️57.输入四位数字输出四个字符

⭐️解释:

//输入四位数字输出四个字符
//void Switch_(int num){
//	if (num >= 10)Switch_(num / 10);
//	printf("%c ", num % 10 + '0');
//}
//int main(){
//	int num = 0;
//	printf("请输入一个数字：\n");
//	scanf("%d", &num);
//	Switch_(num);
//	return 0;
//}
1
2
3
4
5
6
7
8
9
10
11
12

⭐️58.把a数组的内容拷贝到b数组每拷贝三个放1个*

⭐️法1：

//把a数组的内容拷贝到b数组每拷贝三个放1个*

int main(){
	char a[30];
	char  b[30] = { 0 };
	int i = 0, j = 0;//j控制b数组下标

	printf("请输入一个字符串:");
	gets(a);
	for (i = 0; a[i] != '\0'; i++){
		
		b[j++] = a[i];//直接拷贝元素
		if ((i + 1) % 3 == 0){
			b[j++] = '*';//拷贝三个就加一个*
		}
	}
	printf("%s", b);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

⭐️法2:

//把a数组的内容拷贝到b数组每拷贝三个放1个*

int main(){
	char a[30];
	char  b[30] = { 0 };
	int i = 0, j = 0;//j控制b数组下标

	printf("请输入一个字符串:");
	gets(a);
	char *p = a;
	while (*p){

		//拷贝3个或者*p=='\0'是结束
		for (i = 1; i <= 3 && *p != '\0'; i++, p++)
			b[j++] = *p;//拷贝p所指向的字符串中的字符
		if (*p!='\0')
			b[j++] = '*';//放一个*

	}
	printf("拷贝之后: %s\n", b);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

⭐️59.输入一串字符串把其中最长的字母拷贝放到另一个数组

#include<string.h>
void FindWord(char *a, char *b){
	//"1abc22hello";

	char *na = a;
	while (*a){
		na = a;//让na指针变量去改变
		while (*na >= 'a'&&*na <= 'z' || *na >= 'A'&&*na <= 'Z'){
			na++;//向后指一个
		}//退出条件：是非字母字符就退出

		int flag = na - a;//指针-指针代表指针之间经历的元素个数
		int len = strlen(b);//获得字符串b的长度

		if (flag > len){
			strncpy(b, a, flag);
		}
		if (*na == '\0')break;//最大单词在最后 na指向了'\0' 下面的else a = na + 1;
		//就跳过去了，所以在这判断一下
	

		if (na == a)a++;//没有进while就外层指针+1
		else a = na + 1;//否则就进了，+1是因为while退出时指向了非字母字符要跳过去

	}
}
int main(){
		char a[256] = "1abc22hello";
		char b[256] = { 0 };//存最大单词；
		printf("请输入一个字符串:");
		gets(a);
		FindWord(a, b);//找的最长的单词放到b数组
		printf("最长的单词是: %s\n", b);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

⭐️60.16进制转换位10进制

//16进制转换位10进制
void deal(char *a){
	int num = 0, i;
	for (i = 0; a[i]; i++){
		if (a[i] > '0'&&a[i] <= '9'){
			num = num * 16 + a[i] - '0';//公式记住就可
		}
		else if (a[i] >= 'a'&&a[i] <= 'f'){
			num = num * 16 + a[i] - 'a' + 10;
		}
	}
	printf("转换为十进制为：%d\n", num);
}
int main(){
	char a[9];
	printf("请输入一个16进制数:\n");
	gets(a);
	deal(a);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

⭐️61.输入10个整数，最大的和最后一个位置上的交换，最小的和最前面的那个交换

//输入10个整数，最大的和最后一个位置上的交换，最小的和最前面的那个交换写三个函数
void  deal(int *a, int sz){

	int i,max = 0, min = 0;//默认最大数和最小数在a[0]

	//思路:1.首先找到最大数下标和最小数下标
	//2.把最小数和a[0]交换 最大数和a[9]交换  
	//3.注意 先换交换  可能出现a[0]存的是最大数  你和最小数交换完之后
	//最大数的下标max要指向先前的最小数下标min
	for (i = 0; i < sz; i++){
		if (a[max] < a[i])max = i;//max总是指向大数
		if (a[min]>a[i])min = i;//min总是指向小数
	}
	int temp=0;
	if (a[0] == a[max]){//先换交换  可能出现a[0]存的是最大数
		temp = a[0];//把最小数放到a[0]
		a[0] = a[min];
		a[min] = temp;
		max = min;//a[0]存的最大数挪到了min位置  所以max=min
	}
	else {
		temp = a[0];//把最小数放到a[0]
		a[0] = a[min];
		a[min] = temp;
	}

	//把最大数放到最后
	temp = a[sz - 1];
	a[sz - 1] = a[max];
	a[max] = temp;


}
int main(){
	int a[10] = { 9, 1, 2, 3, 0, 5, 6, 7, 6, 8 };

	printf("=========交换之前==========\n");
	for (int i = 0; i < 10; i++){
		printf("%d ", a[i]);
	}

	int sz = sizeof(a) / sizeof(a[0]);
	deal(a, sz);

	printf("\n=========交换之后==========\n");

	for (int i = 0; i < 10; i++){
		printf("%d ", a[i]);
	}

	return 0;
}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

⭐️思路:
1.首先找到最大数下标和最小数下标
2.把最小数和a[0]交换 最大数和a[9]交换
3.注意 先换交换 可能出现a[0]存的是最大数 你和最小数交换完之后最大数的下标max要指向先前的最小数下标min

⭐️62.报数问题 n个人 从1报数到3，每次报数到3的那个元素被清空

//报数问题 n个人 从1报数到3，每次报数到3的那个元素被清空


int main(){
	int a[300], n, i=0, j=0, k=0;
/*思路:
1.为数组赋值n个数
2.结束条件是tt==n-1也就是 淘汰掉了n-1个还剩一个人
3.a数组元素不为0 报数+1
4.k==3报到3踢人  淘汰的人数+1 k=0 重新开始  
5.报完一轮  存活的还大于1 从新开始
	*/

	printf("请输入一个数:\n");
	scanf("%d",&n);
	for (i = 0; i < n; i++){
		a[i] = i + 1;
	}
	i = 0;
	int tt = 0;//淘汰的人数
	while (n - 1 > tt){//结束条件是tt==n-1也就是 淘汰掉了n-1个还剩一个人
		if (a[i] != 0){
			k++;//数组元素不为0 报数+1

			if (k == 3){
				a[i] = 0;//设置为0 表示踢出
				k = 0;//从新开始报
				tt++;//淘汰的数+1
			}
		}
		i++;
		if (i == n)i = 0;//报完一轮 从新开始

	}

	for (i = 0; i < n; i++){
		if (a[i] != 0)printf("幸存者：a[%d]\n", i);
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

⭐️思路:
1.为数组赋值n个数
2.结束条件是 tt == n-1也就是 淘汰掉了n-1个还剩一个人
3.a数组元素不为0 报数+1
4.k==3报到3踢人 淘汰的人数+1 k=0 重新开始
5.报完一轮 存活的还大于1 从新开始

⭐️63.输入多个字符串，排序后输出

void sort(char str[5][10]){
	int i = 0, j = 0;
	char temp[10];
	for (i = 0; i < 4; i++){
		for (j = 0; j < 5 - 1 - i; j++){
			//升序冒泡排序
			if (strcmp(str[j], str[j + 1])>0){
				strcpy(temp, str[j]);
				strcpy(str[j], str[j+1]);
				strcpy(str[j+1], temp);

			}
		}
	}
}
//输入多个字符串，排序后输出
int main(){

	char str[5][10] = { "bbbbb", "aaaaa", "ccccc", "fffff", "eeeee" };
	printf("=========排序之前========\n");
	for (int i = 0; i < 5; i++){
		printf("%s\n", str[i]);
	}
	sort(str);
	printf("\n=========排序之后========\n");
	for (int i = 0; i < 5; i++){
		printf("%s\n", str[i]);
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

⭐️64.(难可不看)输入一个字符串，将连续的数字字符串放到另一个二维数组中

//输入一个字符串，将连续的数字字符串放到另一个二维数组中

int Find_number(char a[], char ch[][20]){
	//a1265bb1234
	/*思路：
	1.外层用*a指针变量来控制循环
	2.定义char *na 在内层变化找一段数字字符
	3.判断是不是连续的 
	4.找到了就拷贝到ch数组  用一个变量控制ch数组下标 
	*/
	char *na = a, row=0;
	while (*a){
		na = a;//让na去改变

		while (*na >= '0'&&*na <= '9'){
			na++;//指向非数字字符的结束
		}

		if (na == a)a++;
		else {//否则就指向了数字字符 判断na-a之间经历的这几个数字字符是不是连续的

			char *temp = a,flag=0;//flag=1 拷贝

			//判断是不是升序连续的
			             //na-1避免temp+1等于na 
			for (temp; temp < na-1; temp++){
				//解释 前一个+1不等于后一个数那么就不是升序连续
				if ((*temp+1)!= *(temp + 1))break;
			}
			if (temp == na - 1){//说明是升序连续
				flag = 1;
			}
			else {//否则判断是不是降序连续

			temp = a;//从新赋值
			for (temp; temp < na - 1; temp++){
				//解释 前一个-1不等于后一个数那么就不是降序连续
				if ((*temp - 1) != *(temp + 1))break;
			}

			    if (temp == na - 1)	flag = 1;//说明是降序连续
			}

			if (flag == 1){//完成拷贝功能
				//na-a指针-指针代表指针之间经历的元素个数
				strncpy(ch[row++], a, na - a);
			}
			if (na == '\0')break;//如果na指向了'\0'就不用下面赋值了
			a = na + 1;//na指向的是非数字字符 +1指向下一个没判断的 赋给a
    }//else_end

}//while_end

	return row;//返回个数
}
int main(){
	char a[100];
		char ch[10][20] = { 0 };
	
		printf("请输入一串字符内包含连续数字：\n");
		gets(a);
		int row=Find_number(a, ch);

		printf("提取出来的数字字符串是:\n");

		for (int i = 0; i <row; i++){
			printf("串%d: %s\n",i+1, ch[i]);
		}
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

⭐️思路：
1.外层用a指针变量来控制循环
2.定义char na 在内层变化找一段数字字符
3.判断是不是连续的
4.找到了就拷贝到ch数组 用一个变量控制ch数组下标

⭐️65.结构体指针问题

⭐️66.三天打鱼两天晒网， 第 N 天是打鱼还是晒网？

//三天打鱼两天晒网， 第 N 天是打鱼还是晒网？

int main(){
	int days = 0;
	printf("请输入天数：\n");
	scanf("%d", &days);//123打鱼 45晒网    也就是%5==0就是晒网  14 15 19 20  都在晒网
	if (days % 5 == 0 || (days+1) % 5 == 0)printf("在晒网...");
	else printf("在打鱼...\n");
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11

⭐️67.输入多个字符串， 然后输出最短的字符串

//输入多个字符串， 然后输出最短的字符串。


void Find_minlen(char a[][20]){
	int len = strlen(a[0]);//设第一个字符串最短
	int flag = 0;
	for (int i = 1; i < 3; i++){
		if (len>strlen(a[i])){//a[i]短就进入if
			len = strlen(a[i]);//把短的这串的长度给len
			flag = i;//存最短字符串的下标
		}
	}

	printf("最短第字符串是:%s \n", a[flag]);
}
int main(){
	char a[3][20] = {"abxc","abc","hello"};
	Find_minlen(a);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

⭐️68. 3 个数， 有两个数一样， 找另一个数

//三个球， 大小一样， 其中有一个质量和其他球质量不同， 请找出
//不同的球。 也就是 3 个数， 有两个数一样， 找另一个数

int main(){
	int a[3] = { 1, 1, 3};
	int sz = sizeof(a) / sizeof(a[0]), i, j, count = 0;
	printf("=======成员情况========\n");
	for (i = 0; i < sz; i++){
		printf("%d ", a[i]);
	}
	printf("\n");
	
	for (i = 0; i < sz; i++){
		count = 0;//记录相同的个数 2个数一样 count=2 
		//j=0 从0开始遍历
		for (j = 0; j < sz; j++){
			if (a[i] == a[j])count++;
			//因为a[i]和a[j]比较时会和相同下标的比较一次也就是count最少就为1

		}
		if (count == 1)printf("单身狗是:%d\n", a[i]);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

⭐️69.有 1000 人捐款， 捐到 10 万就停止捐款。 统计捐款人数和总额

//有 1000 人捐款， 捐到 10 万就停止捐款。 统计捐款人数和总额

int main(){
	double total_money = 0, money = 0;
	int person_num = 0;

	while (total_money < 100000){

		person_num++;//人数+1

		printf("请第%d个慈善家捐款:\n",person_num);
		scanf("%lf", &money);

		total_money += money;//累加
		if (person_num >= 1000)break;//人数>=1000退出
	}
	if (person_num >= 1000 && total_money < 100000)printf("1000个人没娟够...");
	else {
		printf("捐款人数:%d\n善款总金额:%.2lf\n", person_num, total_money);
	}
	

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

⭐️70.指定位置字符串逆序

void reverse(char *s, int index){
	//index下标之前的字符逆序输出
	int i = 0;
	while (i < index){
		char t = s[i];
		s[i] = s[index];
		s[index] = t;
		i++;
		index--;
	}
}

int find_x(char *s,char x){
	for (int i = 0; s[i] != '\0'; i++){
		if (x == s[i])
			return i;
	}
	printf("没有找的返回-1\n");
	return -1;
}
int main(){
	char s[30], x;
	printf("请输入一个字符串:\n");
	gets(s);
	printf("请输入一个字符:\n");
	x = getchar();
	int index = find_x(s,x);

	if (index != -1){
		reverse(s, index);
		printf("===逆序之后====\n");
		printf("%s\n", s);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

⭐️在给定的字符串 s寻找一个特定的字符 x，如果找到，返回 x 在 s 的第一次出现的下标,在主函数中把 s 字符串x字符之前的字符逆序输出*

⭐️71.水仙花数

⭐️一个三位数 各位的立方相加等于该数就是水仙花数

int main(){
	int i = 0;
	for (i = 100; i < 1000; i++){
		int a = i % 10;//获得个位
		int b = i / 10 % 10;//获得十位
		int c = i / 100;//获得百位

		if (a*a*a + b*b*b + c*c*c == i)
			printf("水仙花数:%d\n", i);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

⭐️72.求素数因子

⭐️给一个数，求它的素数因子。一个数（素数除外），均可由若干素数相乘组成。

//给一个数，求它的素数因子。一个数（素数除外），均可由若干素数相乘组成。
int fun_1(int n){
	int i = 0;
	for (i = 2; i < n; i++){
		if (n%i == 0){
			printf("不是素数需要操作...\n");
			return 0;
		}
	}
	if (i == n){
		printf("是素数不用操作...\n");
		return 1;
	}
}
int main(){
	int n = 0;
	printf("请输入一个数：\n");
	scanf("%d", &n);
	int flag = fun_1(n);
	if (!flag){
		int i = 0;
		for (i = 2; i <=n; i++){
			while (n % i == 0){

				printf("%d ", i);
				n /= 2;
			}
		}
		//printf("%d", i);
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

⭐️73.判断一个数是不是完全平方数?

//编写函数，  功能判定完全平方数， 若一个数能表示成某个数平方形
//式， 则为完全平方数  2*2=4  3*3=9
#include<math.h>
void deal_(int n){
	int t = (int)sqrt(n);//返回来是一个double的强转为int sqrt(5) 返回来 2.多 t=2  2*2!=5

	if (t*t == n)printf("%d*%d = %d\n", t, t, n);
	else printf("不是完全平方数...\n");
}
int main(){
	int n = 0;
	printf("请输入一个数:\n");
	scanf("%d", &n);
	deal_(n);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

⭐️74.蠕虫问题

⭐️一条蠕虫长 1 寸， 其 1 分钟可以向上爬 U 寸， 但是他得休息， 休息的时候下滑 D 寸， 问什 么时候爬出去？ 不足 1 分钟按照 1 分钟计算， 蠕虫头部到达井的顶部， 则完成任务， 开始蠕 虫趴在井底（高度为 0）

int main(){
	double u, d, js,total=0;
	int time = 0;
	printf("请输入上爬u 下滑d 井深js:\n");
	scanf("%lf%lf%lf", &u, &d, &js);
	while (total+1 < js){//因为虫子长1cm  试想虫子0cm  累加到100(井深),结束条件是total==100
		//而我们虫子1cm我们total+1就行了不用算虫子的长度,也就是爬99cm就ok(忽略下滑)
		total += u;//上爬u寸
		total -= d;//下滑d寸
		time++;
		time++;
	}
	total += d;//最后一次退出到顶了，就不用下滑一次了
	time -= 1;//下滑时间-1
	printf("%d分钟 ", time);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

⭐️75.结构体排序学生情况

⭐️用结构体来描述一个学生的成绩情况， 内容包括： 姓名、 学号、 C 成绩、 微机原理成绩、 对一个班 30 同学统计求同学平均分、 分数从高到低排名， 打印出名字， 打印出 90 以上和不及格的同学名字

//用结构体来描述一个学生的成绩情况， 内容包括： 姓名、 学号、 C 成绩、 微机原理成绩、 对
//一个班 30 同学统计。
//求同学平均分、 分数从高到低排名， 打印出名字， 打印出 90 以上和不及格的同学名字

#define N 3
struct student{
	char name[10];
	int num;
	int C;
	int W;
	int ave;
};
void Print(struct student stu[], int n){
	for (int i = 0; i < n; i++){
		printf("名字: %s 学号: %d C语言: %d  微原：%d\n ", stu[i].name,
			stu[i].num, stu[i].C, stu[i].W);
	}
}

void Find(struct student stu[], int n){
	for (int i = 0; i < N; i++){
		if (stu[i].ave >= 90){
			printf("大于90的: ");
			printf("名字: %s 学号: %d C语言: %d  微原：%d\n ", stu[i].name,
				stu[i].num, stu[i].C, stu[i].W);
		}
		else if (stu[i].ave < 60){
			printf("小于60的: ");
			printf("名字: %s 学号: %d C语言: %d  微原：%d\n ", stu[i].name,
				stu[i].num, stu[i].C, stu[i].W);
		}
	}
}
void sort(struct student stu[]){
	struct student temp;
	for (int i = 0; i < N; i++){//冒泡排序
		for (int j = 0; j < N - 1 - i; j++){
			if (stu[j].ave < stu[j + 1].ave){
				temp = stu[j];
				stu[j] = stu[j + 1];
				stu[j + 1] = temp;
			}
		}
	}
	Print(stu, N);//打印

	//找大于90和不及格的  
	Find(stu, N);
}

int main(){
	struct student stu[N], temp;
	int i = 0;
	for (i = 0; i < N; i++){
		printf("请输入第%d个学生的信息:名字	学号		C   W  :\n",i+1);
		gets(stu[i].name);
		scanf("%d%d%d", &stu[i].num, &stu[i].C, &stu[i].W);
		getchar();
		int total = stu[i].C + stu[i].W;
		stu[i].ave = total /2;
	}
	sort(stu);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

⭐️76.求一元二次方程的根， ax 方＋bx + c = 0, a, b, c 自己输入

//思路， 首先判断根与系数的关系
//<0 无解
//>0 两个不同的解
//=0 两个相同的解
如果大于等于 0 x1=-b/2a+判别式/2a x2=-b/2a-判别式/2a
int main(){
	double a, b, c, disc, x1, x2, p, q;
	scanf("%lf%lf%lf", &a, &b, &c);
	disc = b*b - 4 * a*c;
	if (disc<0)
		printf("无根\n");
	else{
		p = -b / (2.0*a);
		q = sqrt(disc) / (2.0*a);
		x1 = p + q;
		x2 = p - q;
		printf("根为:\nx1=%7.2f\nx2=%7.2f\n", x1, x2);
	}
		return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

⭐️77.累加100–999之间个位数为7的素数

//设计一个函数  判断是否为素数， 是返回 1， 否返回 0， 在主函数中调用
//输出 100 - 999 之间的各位数为 7 的所有素数之和。
int fun_2(int n){
	for (int i = 2; i < n; i++){
		if (n%i == 0)return 0;
	}
	return 1;
}
int main(){
	int i = 0,total=0;
	for (i = 100; i <= 999; i++){
		if (fun_2(i)&&i%10==7){
			printf(" %5d \n", i);
			total += i;
		}
	}
	printf("100--999之间个位数为7的素数和是:%d\n", total);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

⭐️78.斐波那契兔子

⭐️本质就是求斐波那契数列:

//一对兔子， 从出生后的第 3 个月起， 每个月都要生一对兔子， 小兔子长到 3 个月之后每个月
//又生一对兔子， 假如兔子都不死， 请问第一个月出生的一对兔子， 至少繁衍到
//几个月时兔子总数才可以达到 N 对？
//1 1 2 3  5 8
int main(){
	int month = 1, total = 0, a = 1,b=0;
	int nums;
	printf("请输入一个数：");
	scanf("%d", &nums);//兔子个数
	if (nums == 1)printf("需要1个月\n");
	//2月之后的
	else {
		while (total < nums){

			total = a + b;
			b = a;     //前面1个加前面2个等于当前这个
			a = total;
			month++;
			printf(" %d ", total);
		}
		printf("需要%d个月\n", month);
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

⭐️78.迭代求平方根

int main(){
	double a = 0, x0 = 0, x1 = 0;
	printf("请输入一个数:\n");
	scanf("%lf", &a);
	x1 = a;//先给x1赋个值
	while (fabs(x0 - x1) > 1e-6){

		x0 = x1;//x0保存上一次的结果
		x1 = (x0 + a / x0) / 2;//x1保存新的结果  迭代循环 x1根据x0变化  x1会越变越小

		
	}
	printf("%.2lf的平方根是: %.2lf\n", a, x1);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

⭐️79.累加二维数组边缘元素的和

//累加二维数组边缘元素的和
void Show(int a[][4], int row, int col){
	printf("=====数组情况======\n");
	for (int i = 0; i < row; i++){
		for (int j = 0; j < col; j++){
			printf("%d ", a[i][j]);
		}
		printf("\n");
	}
}
void add(int a[][4], int row, int col){
	int i = 0, j = 0,total=0;
	//累加行
	int n = 2;//总共加最上面一行和最下面一行
	while (n > 0){
		for (j = 0; j < col; j++)
			total += a[i][j];
		i = row - 1;//最后一行
		n--;
	}
	//累加列
	n = 2;
	j = 0;//一次加第0列
	while (n > 0){
		
		for (i = 0; i < row; i++)
			total += a[i][j];
		
		j = col - 1; // 第二次加 最后一列
		n--;
	}
	//累加完之后 四个角上的元素多加了一次 减去
	total = total - a[0][0] - a[0][col - 1] - a[row - 1][0] - a[row - 1][col - 1];
	//                a[0][0]  a[0][3]         a[2][0]         a[2][3]
	Show(a,row,col);
	printf("总和是:%d\n", total);


}

int main(){
	int a[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 }, s = 0;
	add(a, 3, 4);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

⭐️80.逗号表达式方面小题

⭐️81.白马百担问题

⭐️百马百担问题： 有 100 匹马， 驮 100 担货， 大马驮 3 担， 中马驮 2 担， 两匹小马驮 1 担， 问大、 中、 小马各多少匹 ?

int main(){
	int dm, zm, xm;
	for (dm = 0; dm <=100; dm++){
		//大妈xx头和中马最多100-dm头  小马最多100-dm-zm头 循环试
		for (zm = 0; zm <=100 - dm; zm++){
			
				xm = 100 - dm - zm;

				//等式两边乘以2 dm一个驮3袋
				if (dm * 6 + zm * 4 + xm == 200){
					printf("大妈：%d  中妈：%d 小马: %d\n", dm, zm, xm);
				}
			

		}
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

⭐️82.八进制转10进制

⭐️以下程序的功能是将无符号八进制数字构成的字符串转换为十进制整数。 例如输入的字符串为“556”， 则输出十进制整数 366。

//以下程序的功能是将无符号八进制数字构成的字符串转换为十进制整数。 例如输入的字符串
//为“556”， 则输出十进制整数 366。

int main(){
	char a[9];
	int num = 0;
	printf("请输入一个八进制数:\n");
	scanf("%s", a);
	char *p = a;//a是数组名，数组名是常数不能++要放到指针变量去

	while (*p){
		num = num * 8 + *p - '0';
	          //公式可以推导一下和之前一道题16进制转10进制差不多
		p++;
	}
	printf("转换为的十进制数是: %d\n", num);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

⭐️83.func(func(x++, y++), func(–x, --y));函数调用问题

⭐️VS2013上测试:

⭐️解释：

⭐️DEVC++上面测试:

⭐️84.水手分桃子

⭐️思路： 五个人每人独自醒了一次，把全部的桃子分成5份余1个 拿一份给自己 剩下的四份在合起来成为一个整体在去分，也就是最后每个人各自给你自己分了一份，最后一起醒来把剩下的又分为5份余一个，定义一个数组a[6]

/*
思路：
五个人每人独自醒了一次，把全部的桃子分分成5份余1个 那一份给自己 剩下的四份在合起来成为一个整体
在去分，也就是最后每个人各自给你自己分了一份，最后一起醒来把剩下的又分为5份余一个，
定义一个数组a[6]  
*/
int main(){
	int index = 0, i = 0, num = 0, a[6] = { 0 };
	while (1){
		i++;
		num = i;//让num去试看看是不是要寻找的那个数
		while (num % 5 == 1){
			num=(num-1)/ 5;//减去给猴子的一个
			a[index++]=num;
			num *= 4;//把剩余的4份组合成一份
		}
		if (index == 6)
			break;//正常退出数组满了分好了
		if (index != 6)index = 0;//数组下标置为0继续找
	}
	for (index = 0; index < 5; index++){
		printf("第%d个人分了%d个\n", index + 1, a[index] + a[5]);
	}
	printf("全部=%d\n", i);//加上了给猴的6个

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

⭐️85.挖素数

//挖素数打印1-100之间的素数

int main(){
	int a[100],i,j;
	//给数组赋值
	for (i = 0; i < 100; i++){
		a[i] = i + 1;
	}
	//
	a[0] = 0;//a[0]=1 不是素数 挖去

	for (i = 1; i < 100; i++){
		if (a[i] == 0)continue;//分母不能为0
		for (j = i + 1; j < 100; j++){
			if (a[j] % a[i] == 0 && a[j] != 0){
				a[j] = 0;
			}
		}
	}

	//打印
	for (i = 0; i < 100; i++){
		if (a[i]!=0)printf("%d ", a[i]);
	}

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

⭐️86.两个有序递增 的数组存到另一个数组还是有序的

//两个有序递增 的数组存到另一个数组还是有序的

#define N 6
#define M 5

int main(){
	int a[N] = { 2, 4, 5, 8, 10, 12 };
	int b[M] = { 1, 3, 5, 7, 9 };
	int c[N*M];
	int ai=0, bi=0, k = 0;

	while (ai<N&&bi<M){//有一个数组传递完就退出
		//如果数组1的元素都比数组2小就提前传送完退出

		//必须有一个是<=否则就会死循环
		if (a[ai] <=b[bi]){//如果a数组元素小于b数组元素把a数组元素放到C数组
			c[k++] = a[ai++];
		}
		else if (b[bi] < a[ai]){//如果b数组元素小于a数组元素把b数组元素放到C数组
			c[k++] = b[bi++];
		}
	}


	while(ai != N){//ai下标没有到最大值就把a数组剩余的拷贝过来
		c[k++] = a[ai++];
	}
	while(bi != M){//bi下标没有到最大值就把b数组剩余的拷贝过来
		c[k++] = b[bi++];
	}
	for (int i = 0; i < k; i++){
		printf("%d ", c[i]);
	}

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

⭐️87.把字符串中的空格去掉

//把字符串中的空格去掉

int main(){
	char a[20] = "123 456 789";
	int i = 0, j = 0;
	printf("去掉空格之前: %s\n", a);
	for (i = 0; a[i]; i++){
		if (a[i] != ' ')a[j++] = a[i];
		//j也指向a数组用空间，i指向数组a用内容  只有i指向的元素不是空格才赋值
	}
	a[j] = '\0';//最后把j下标的赋值'\0'
	printf("去掉空格之后：%s\n", a);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

⭐️88.将b字符串的内容插入到a字符串，a字符串保持升序

//将b字符串的内容插入到a字符串，a字符串保持升序

int main(){
	char a[10] = "bceg";
	char b[10] = "adf";
	int i = 0, j = 0;//j控制b数组下标
	for (j = 0; b[j]; j++){
		i = strlen(a);
		a[i + 1] = a[i];//上来先把'\0'向后挪1位
		for (--i; i >= 0; i--){
			if (a[i] > b[j]){
				a[i + 1] = a[i];//如果a[i]的元素大于b[j]那么a[i]向后挪1位
			}
			else {//否则b[j]这个元素大于等于a[i],b[j]放到a[i+1](空的)的位置
				a[i + 1] = b[j];
				break;
			}
		}
		if (i == -1){//如果a[0]位置的元素都大于b[j]元素那么a[0]挪到a[1]位置,b[j]放到a[0]位置
			a[i + 1] = b[j];
		}
	}

	printf("操作之后:%s\n", a);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

⭐️89.用递归的方法把字符串逆序

//用递归的方法把字符串逆序abcde  转换为edcba

void reverse_(char *a){
	char *p = a,ch='\0';
	while (*p)p++;//指向'\0'
	p--;//指向'\0'下一个字符
	if (a < p){//>=就不进
		ch = *a;//前面这几个字符在存到的临时变量的ch中
		*a = *p;//把后面的这几个字符放到前面
		*p = '\0';//*p='\0'下次递归调用*p位置就不会被再次交换

		reverse_(a + 1);
		//每次递归返回返回到这

		*p = ch;//第一次p指向e的位置   第二次递归调用p指向e的位置

	}

	

}
int main(){
	char a[20] = "abcde";
	printf("逆序之前：%s\n",a);
	reverse_(a);
	printf("逆序之后：%s\n", a);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

⭐️90.分解质因数

//分解质因数，若150 分为 1 * 2 * 3 * 5 * 5 负数就是 - 1乘

int main(){
	int n = 0;
	printf("请输入一个数：\n");
	scanf("%d", &n);
	if (n > 0){
		printf("1");
	}
	else if(n<0){
		printf("-1");
	}
	for (int i = 2; i <=n; i++){
		while (n%i == 0){//第一次%2把2这个质因子都找出来  下一次在找3 不会出现非素数
			printf("*%d", i);
			n /= i;
		}
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

⭐️91.10进制转16进制

//10进制转16进制
void deal(int n){
	char a[20] = { 0 };
	int r = 0,i=0;
	while (n){
		r = n % 16;//%16取余
		n /= 16;
		if (r >= 10){
			a[i++] = r + 55; //'A'--65
		}
		else {
			a[i++] = r + '0';//0~9之间直接加'0'
		}
	}

	printf("转换之后:");
	for (--i; i >= 0; i--){
		printf("%c", a[i]);
	}
}

int main(){
	int n = 0;
	printf("请输入一个数：\n");
	scanf("%d", &n);
	deal(n);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

⭐️92.10进制转8进制

//10进制转8进制
void deal(int n){
	char a[10] = { 0 };
	int r = 0,i=0;
	while (n){
		r = n % 8;//%8取余 r最后不会大于等于8
		n /= 8;
		a[i++] = r + '0';
	}
	

	printf("转换之后:");
	for (--i; i >= 0; i--){
		printf("%c", a[i]);
	}
}

int main(){
	int n = 0;
	printf("请输入一个数：\n");
	scanf("%d", &n);
	deal(n);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

⭐️93.计算并输出n以内10个最大素数的和

//计算并输出n以内10个最大素数的和
int oop(int n){
	int i;
	for (i = 2; i < n; i++){
		if (n%i == 0)return 0;
	}
	return 1;
}
int main(){
	int  n = 0;
	printf("请输入一个数: ");
	scanf("%d", &n);
	int total = 0, t = 0;
	int count = 0;
	while (n){
     //从n开始向下递减1
		if (oop(n)){
			count++;
			total += n;
			printf("(%d). %d  ", count, n);
		}
		n--;
		if (count == 10)break;
	}
	if (count <= 0){
		printf("\n输入的%d值太小后面没有10个素数\n", n);
	}
	else
	printf("\n和是:%d\n", total);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

⭐️94.完数

⭐️如果一个数恰好等于它的真因子之和，则称该数为“完全数”。第一个完全数是6，第二个完全数是28，第三个完全数是496，他的所以因子相加等于他本身这个数就是完数

//如果一个数恰好等于它的真因子之和，则称该数为“完全数”。第一个完全数是6，第二个完全数是28，第三个完全数是496，
//他的所以因子相加等于他本身这个数就是完数
int main(){
	int i, total = 0;
	for (i = 1; i < 1000; i++){
		total = 0;
		          //i的因子最多不会>i/2;
		for (int j = 1; j <= i / 2; j++){
			if (i%j == 0)total += j;//累加因子
		}
		if (total == i)printf("是完数:%d\n", i);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

⭐️95.打印X型图案

//打印X型图案

int main(){
	int i, j;
	int n = 0;
	do{
		printf("请输入一个数:\n");
		scanf("%d", &n);
		for (i = 0; i < n; i++){
			for (j = 0; j < n; j++){

				//主对角线      副对角线
				if (i == j || j == n - 1 - i)printf("*");
				else printf(" ");
			}
			printf("\n");
		}
	} while (n >= 2);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

⭐️96.打印空心正方形

//打印空心正方形

int main(){
		int i, j;
		int n = 0;
		do{
			printf("请输入一个数:\n");
			scanf("%d", &n);
			for (i = 0; i < n; i++){
				for (j = 0; j < n; j++){
	
					//主对角线      副对角线
					if (i == 0|| j == 0||j==n-1||i==n-1)printf("* ");
					else printf("  ");
				}
				printf("\n");
			}
		} while (n >= 2);
		return 0;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

⭐️97.判断一个数组是否有序

⭐️利用冒泡排序,看记号flag的变化

//判断一个数组是否有序

int main(){
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, flag1 = 1, flag2 = 2, i, j;
	for (i = 0; i < 9; i++)
	{
		for (j = 0; j < 10 - 1 - i; j++){
			if (a[j]>a[j + 1]){//内层循环if一次没进去说明前一个总比后一个大--降序
				flag1 = 0;
			}
			if (a[j] < a[j + 1]){//内层循环if一次没进去说明前一个总比后一个小--升序
				flag2 = 0;
			}
		}
		//测试出升序或降序了
		if (flag1 == 1 || flag2 == 2)break;

	}
	for (i = 0; i < 10; i++){
		printf("%d ", a[i]);
	}

	if (flag1 == 1)printf("\n是升序\n");
	else if (flag2 == 2)printf("\n是降序\n");
	else
		printf("\n无序\n");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

⭐️98.整形数组删除指定的数字

//整形数组删除指定的数字
int main(){
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int sz = sizeof(a) / sizeof(a[0]), n, i, j;
	printf("请输入一个数字：\n");
	scanf("%d", &n);
	for (i = 0,j=0; i < 10; i++){
		if (a[i] != n)//a[i]==n就不拷贝
			a[j++] = a[i];
	}
	//如果没有找到这个n j就一直被改变了，j和之前数组元素个数是一样的
	if (j == sz)printf("没有找到给定数字...\n");
	else {
		printf("=====已删除数组情况=====\n");
		for (i = 0; i < j; i++){
			printf("%d ", a[i]);
		}
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

⭐️99.给字符数组每个元素中间添加一个空格

//给字符数组每个元素中间添加一个空格

int main(){
	char a[30] = "abc";
	int i = 0;
	// i不能=0    a b c
	//            01234
	for (i = strlen(a) - 1; i > 0; i--){
		a[2 * i] = a[i];
		a[2 * i - 1] = ' ';
	}

	printf("%s", a);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

⭐️100.旋转字符

//旋转字符
#include<Windows.h>
int main(){
	char *arr = "\/-|";
	int i = 0;
	while (1){
		i %= 4;//\r只回车不换行
		printf("[%c]\r", *(arr + i));
		i++;
		Sleep(60);
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

⭐️101.求sinx近似值

int main(){
	double x = 0, x0 = 0, x1 = 0, total = 0, n = 1, m = 1;
	printf("请输入一个数:\n");
	scanf("%lf", &x);
	total += x;//第一次+X
	x1 = x;//先给前面一项赋个值
	int i = 2,f=1; //f是符号
	m = x;//m存x的初值
	while (fabs(x1 - x0) > 1e-6){
		
		x0 = x1;
		//阶乘
		//每次乘两次
		for (int t = 2; t > 0; i++){
			n *= i;

			t--;
		}

		//幂次
		for (int t = 2; t > 0; t--){
			x *= m;//m暂存的x初始值每次进来乘2次
		}

		f = -f;//改变符号
		x1 = f*(x / n);
		total += x1;
	}

	printf("%lf", total);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33