考研C语言程序设计_编程题相关(持续更新)

BugMaker0114

已于 2024-10-31 00:58:17 修改

阅读量2.1k

点赞数 10

分类专栏： C语言文章标签：考研

于 2024-10-10 16:04:17 首次发布

本文链接：https://blog.youkuaiyun.com/qq_57030936/article/details/142823454

版权

C语言专栏收录该内容

20 篇文章

订阅专栏

一、程序设计经典编程题(C语言实现)

T1 求1~100的奇数

解法1 暴力求解:

解法2: 思考思考只要知道第一个奇数后面的+2+2+2不就行了?

总结:

解法1 循环一百次判断一百次
解法2 循环五十次不需要判断
初步领略一下算法的魅力要多思考
类似的下面这道题就可以从3开始打印每次+3+3+3 而不需要遍历判断再打印了

还有一种思路:

T2 求n!

本题很简单就是累乘
但是我眼睛瞎起来就把ret定义为0 答案恒为0了

参考代码:

	int n = 5;
	int i = 0;
	int ret = 1;//别写成0了
	for (i = 1; i <= n; i++)
		ret *= i;
	printf("%d\n", ret);

T3 求1!+2!+3!+…+10!

解法1:

思路:两层循环第一层循环产生1~10的数据第二层循环求出1! 2! 3!..并累加
注意这种写法 每次求单独求阶乘的时候 ret一定要置为1

这种解法不够好 因为有大量的重复计算 将在解法2改进

	int n = 3;//求1! + 2! + 3!
	int i = 0;
	int j = 0;
	int ret = 1;//每次求单独的阶乘的时候就用它
	int sum = 0;
	for (int j = 1; j <= n; j++)
	{
		ret = 1;//所以要记得置为1啊!! 要不然第求下一次阶乘的时候 ret就不是从1开始乘的了
		for (i = 1; i <= j; i++)
			ret *= i;
		sum += ret;
	}
	printf("%d", sum);

解法2:

思路:其实在计算10!的时候已经出现了1! 2! 3! … 9! 既然如此 就可以一边计算一边累加避免了重复计算
解法2更好是经过思考的

int main()
{
	int n = 10;
	int i = 0;//控制循环
	int ret = 1;//用于产生1! 2! 3!...10!
	int sum = 0;
	for (i = 1; i <= n; i++)
	{
		ret *= i;//在产生10!的过程中 其实已经产生了1! 2! 3!...
		sum += ret;//边乘边加
	}
	printf("%d ", sum);
	return 0;
}

T4 在一个`有序数组`中查找具体的某个数字n(二分查找)

解法1 直接暴力求解:

解法2 二分查找:

前提是:有序 所以不能乱给测试数组
right = mid-1; left = mid+1; 我一开始没有+-1 会导致死循环
int right = len - 1; -1别忘记了 right是下标
出循环之后有两种写法 可以利用flag 也可以直接判断

写法一:

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,11 };//测试数组 一定是有序的
	int len = sizeof(arr) / sizeof(int);//数组元素个数
	
	int k = 11;//查找目标
	int flag = 0;//假设一开始默认找不到k 找到了就把第flag置为1
	
	int left = 0;
	int right = len - 1;
	int mid = 0;
	// = 也是可以取的 当left=right的时候 肯定还要进去判断一次
	while (left <= right)
	{
		//每次进循环 都要算出一个新的mid进行判断
		mid = (left + right) / 2;
		if (arr[mid] < k)
		//说明k在mid的右边
		{
			left = mid + 1;
		}
		else if (arr[mid] > k)
		//说明k在mid的左边
		{
			right = mid - 1;
		}
		else
		{
			//这里已经可以输出mid的信息了 但是我放在下面打印
			//把提示信息统一都放在循环外处理
			flag = 1;
			break;
		}
	}
	//程序执行到这 有两种可能
	//1.while全都判断完 自然结束 也就是最终没找到k 此时flag = 0
	//2.flag = 1之后 break到这里来
	if (flag)
		printf("找到了下标是:%d\n", mid);
	else
		printf("没找到");
	return 0;
}

写法二: 主要差异在于出循环之后我怎么输入"没找到"比较合适

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10};
	int num = 0;
	while (2)
	{
		printf("输入你要查到的数字:\n");
		scanf("%d", &num);
		int left = 0;
		int right = (sizeof(arr) / sizeof(int))-1;
		int mid = 0;
		while (left <= right)
		{
			mid = (left + right) / 2;
			if (arr[mid] > num)
				right = mid-1;
			else if (arr[mid] < num)
				left = mid+1;
			else
			{
				printf("找到了 下标是%d\n", mid);
				break;
			}
		}
		//走到这里 有两种情况 1.找到了break出来 2.没找到 但是left不<=right 循环结束了
		//我直接判断一下此时mid对应的元素是不是num就能确定找没找到了 不需要flag也行
		if (arr[mid] != num)
			printf("没找到\n");
	}

	return 0;
}

T5 编写代码，演示多个字符从两端移动，向中间汇聚

题目描述:
打印hello world!
############
h##########!
he########d!
hel######ld!
hell###r#ld!
hello##orld!
hello world!

解法1:

双"指针" 一左一右开始打印有效字符
每次肯定都是打印十个字符 打印几次由while来决定
left和right把10个要打印的字符分成三部分 [0,left]打印对应的有效字符 [right,len-1]打印对应的有效字符剩余部分打印#
相较于思路2 更节省空间

错因:

打印#的判断条件写错了左右不分??!! 开区间(left,right)范围打印#
每一次for循环结束 不要忘记++和-- 也不要忘记换行

#include<stdio.h>
#include<windows.h>
#include<string.h>
int main()
{
	char ch[] = "hello world!";
	int len = strlen(ch);//12
	int left = 0;
	int right = len - 1;
	int i = 0;

	while (left<=right)
	{
		for (i = 0; i < len; i++)
		{
			if (i > left && i < right) //易错
				printf("#");
			else
				printf("%c", ch[i]);
		}
		printf("\n");
		Sleep(1000);
		left++;
		right--;
	}
	return 0;
}

解法2:

给出两个数组一个是字符一个是# 注意#和字符的个数肯定都是一样的
然后也是用了两个指针一左一右依次把字符赋给放#的那个数组
打印的时候 用%s专门只打印#的那个数组即可

错因:

len–>求的是元素个数也就是字符个数 故下标最大值是len-1
判断部分是<= 当左右指针指向同一个元素的时候也要进入循环的

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<windows.h>
#include<string.h>
int main()
{
	char ch1[] = "zhuchenyang66dds6!";
	char ch2[] = "******************";
	int len = strlen(ch1);
	int left = 0;
	int right = len - 1;
	for (left = 0, right = len - 1; left <= right; left++, right--)
	{
		ch2[left] = ch1[left];
		ch2[right] = ch1[right];
		printf("%s\n", ch2);
		Sleep(100);
	}
	return 0;
}

或者写成while循环都是一样
Sleep()的头文件是windows.h
system()的头文件是stdlib.h
在这里插入图片描述

T6 模拟用户登录(三次机会)

题目描述:
编写代码实现，模拟用户登录情景，并且只能登录三次。（只允许输入三次密码，如果密码则提示登录成，如果三次均输入错误，则退出程序。

解法1 利用strcmp函数:

定义要输入的密码正确密码 count是还剩下几次机会
只要count还没==0 就可以进去输入密码

我的错因:

一开始用的是下图这种定义方式这样定义的话 其实数组大小是确定的 数组里放了一个空格一个\n 元素个数(strlen)是1 大小(sizeof)是2字节 下面输入密码肯定会越界的

2. 比较字符串是否相等 不能用== 要用strcmp()函数第一个参数比第二个参数大就返回>0 相等的话返回0

#include<stdio.h>
#include<string.h>
int main()
{
	char pswd[100] = " ";
	char answer[100] = "zhukefu123";
	int count = 3;

	while (count>0)
	{
		printf("您还有%d次机会,请输入密码:\n",count);
		scanf("%s", pswd);
		if (strcmp(pswd, answer) != 0)
		{
			printf("密码错误!\n");
			count--;
			continue;
		}
		else
		{
			printf("密码正确!\n");
			break;
		}
	}
	if (count == 0)
		printf("您没有机会了!!\n");
	return 0;
}

解法2 直接暴力求解相当于模拟实现了strcmp:

这里我犯了一个离谱的错误 多打了一个; 也就是这个if 啥也不干! 然后继续往下执行!

下图这部分写错了左闭右开的话 右边就是循环次数 也就是字符串长度 是不需要-1的 -1会导致少判断最后一个字符 也就是zcygst667也被算成密码正确了

char ch[10] = " "; 10给的太小了!!! 要么限定用户只能输入多少的字符(一般交给前端限制) 要么给大点否则 如果我测试的时候输入了一个zcysdshjadhshkd 会有栈溢出err
这个错误算是值得注意的点我要是用flag这种写法的话 每次给你一次新机会输入密码的时候 flag都应该重置为1!!!! 否则在以下情况会出现问题: 当我第一次输入zcygst667 进入for的时候把flag置为0 如果我后面输入了正确密码zcygst666 虽然不会执行flag=0 但是for循环出来走到if (flag == 1)的时候发现flag上次已经给他置为0了所以不进入if 直接继续下一次循环了仿佛跳过了这次正确的输入
主要就三个点的错误(下图已经修正)

int main()
{
	int total = 8;
	int i = 0;
	char ch[1000];
	char real[1000] = "zcygst666";
	int flag = 1;
	while (total > 0)
	{
		flag = 1;
		scanf("%s", ch);
		if (strlen(real) == strlen(ch))
		{
			for (i = 0; i < strlen(ch); i++)
			{
				if (ch[i] != real[i])
				{
					printf("错误\n");
					total--;
					flag = 0;
					printf("还剩%d次机会\n", total);
					break;
				}
			}
			//程序走到这这里 
			//1.break出来的  flag已经是0
			//2.判断发现全相等 循环自然结束 flag仍然是1
			if (flag == 1)
			{
				printf("正确\n");
				break;
			}
		}
		else
		{
			printf("两个字符串长度都不一样!!错误\n");
			total--;
			printf("还剩%d次机会\n", total);
		}
	}
	
	return 0;
}

其实我想说的是针对解法2那个flag置为1的错误还是要具体问题具体分析的具体看自己的思路是什么灵活编写代码
比如下面的代码(一开始给flag初始化的是0 密码正确再改为1) 就不需要每次都置为1 所以要多写多练多反思该置为1的时候我自己心里有数就行

int main()
{
	int i = 10;
	char real[20] = "zcygst";
	char input[20];
	int flag = 0;
	while (i > 0)
	{
		scanf("%s", input);
		if (strcmp(real, input) != 0)
		{
            //密码错误 那就不要动flag 本身就是0!
			i--;
			printf("err还剩%d次机会\n", i);
		}
		else
		{
            //输对了才改为1
            flag = 1;
			printf("yes\n");
			break;
		}
	}
    //1.要么是break到这里的时候 此时flag为1
    //2.要么就是一次都没输对 不满足i>0跳到这里来 此时flag一直保持是0
	if (flag == 0)
		printf("你没机会了\n");
	return 0;
}

T7 输入三个数并从大到小输出

思路:
确定三个数了用排序似乎有点小题大做了
其实比较三次即可保证a放的最大 c放的最小然后打印abc即可
而且三次比较都要交换不如封装成一个函数但是注意这个函数就必须要传地址了

#include<stdio.h>

void swap(int* x,int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

int main()
{
	int a = 1;
	int b = 1;
	int c = 1;
	printf("请输入三个数:>\n");
	scanf("%d %d %d", &a, &b, &c);
	//目标:让a里放最大 b其次 c最小
	//前两个if可以保证a最大 第三个if让c最小
	if (a < b)
		swap(&a, &b);
	if (a < c)
		swap(&a, &c);
	if (c > b)
		swap(&b, &c);
	//从大到小输出
	printf("%d %d %d", a, b, c);

	return 0;
}

T8 打印100~200的素数(质数)

思路:

素数只能被1和本身整除 如果能找到一个非1非本身的因数就可以判断不是素数
判断i是不是素数的时候 可以从闭区间[2,i-1]试除
优化1:只要试除[2,根号i] 比如16 如果有因数一定是成对出现的 比如1-16 2-8 4-4 如果只看一半的话 肯定是不会大于根号16的(≤)
优化2:偶数肯定不是素数 直接从101开始每次i+2 从奇数里面找素数

double sqrt (double x);需要math.h的头文件 不放心的话循环里也可以强转成int
以上的方法 都叫"试除法" 推荐博文:<<素数求解的N种境界>>

#include<stdio.h>
#include<math.h>
int main()
{
	int i = 0;
	int j = 0;
	int flag = 1;
	//产生100-200的素数
	for (i = 100; i <= 200; i++)
	{
		//每次产生的i 开始都先认为他是个素数
		flag = 1;
		//这里是<=啊 写<的话 49也被判断成素数了
		for (j = 2; j <= (int)sqrt(i); j++)
		{
			if (i % j == 0)
			{
				flag = 0;//那就不是素数
				break;//只要有一次能进来 就直接break了
			}
		}
		//走到这儿来 可能是
		//1.break到这儿来 此时flag=0 
		//2.循环条件结束 此时flag仍未1 也就是i%j一次都不等于0 没机会把flag置为0 说明是素数
		if (flag)
			printf("%d ", i);
	}
	return 0;
}

T9 打印1000~2000之间的闰年

1. 能被4整除但是不能被100整除的是闰年
2. 能被400整除也是闰年
3. 其实可以i+=4 从1.2.的规则来看闰年肯定能被4整除

	int i = 0;
	for (i = 1000; i <= 2000; i++)
	{
		if ((i % 400 == 0) || ((i % 4 == 0) && (i % 100 != 0)))
			printf("%d ", i);
	}

注意了如果要用if来写的话
就是俩个if(并列关系都需要判断的)
而不能是else if(非此即彼只有一个入口)了
如果写的是else if 2000本身是闰年但是判断他不是因为只能进去第一个if

T10 求最大公约数(含递归)

解法1:暴力求解
两个数的最大公约数的范围肯定是[1,较小值]
比如18和6 最大公约数不可能超过6 所以从1到6找就行

	int m = 18;
	int n = 24;
	//假设m和n的较小值为最大公约数
	int min = m > n ? n : m;
	//然后从较小值开始 往下试除
	int i = 0;
	for ( i = min; i >= 1; i--)
	{
		if ((m % i == 0) && (n % i == 0))
			break;
	}
	printf("%d", i);

下图是while的写法

解法2:辗转相除法:
主要用到的一个结论就是:(a,b)的最大公约数等于(b,a%b)的最大公约数
最大公约数：即两个数据中公共约数的最大者。
思路：
例子：18和24的最大公约数
第一次：a = 18 b = 24 c = a%b = 18%24 = 18 再使:a = 24 b=18
第二次：a = 24 b = 18 c = a%b = 24%18 = 6 再使:a = 18 b = 6
第三次：a = 18 b = 6 c=a%b = 18%6 = 0 循环结束此时的b就是最大公约数
下面有两种不同的风格写法 建议写第二种

int main()
{
	int m = 18;
	int n = 24;
	int k = m % n;
	while (k != 0)
	{
		m = n;
		n = k;
		k = m % n;
	}
	printf("%d", n);
	return 0;
}

int main()
{
	int a = 18;
	int b = 24;
	int c = 0;
	//当某一次 c = a%b = 0  为假了 就不进去循环了 此时b就是最大公约数
	while(c=a%b)
	{
		a = b;
		b = c;
	}
	printf("%d\n", b);
	return 0;
}

解法3:递归法
可以看出求18 24->求24 18->求18 6(递归的出口)
递归的关键在于能否找到子问题

#include<stdio.h>

void IsCommon(int a, int b)
{
	if (a % b == 0)
	{
		printf("最大公约数是%d ", b);
		return;
	}
	else
		IsCommon(b, a % b);
}

int main()
{
	int a;
	int b;
	
	while (1)
	{
		scanf("%d %d", &a, &b);
		IsCommon(a, b);
	}

}

补充:辗转相除法的证明

详细的证明过程可以参考:
辗转相除法原理

注意除了参考视频里的两个结论,具体实现证明还需要引入一个公理:整数a,b的最大公约数d1一定大于or等于整数a,b,c的最大公约数d2的(当c有一个约数恰好是d1时取等号)

T11 求最小公倍数

设两数的最大公因数=X
则：两数可以表示为：aX,bX(a,b一定互质)
所以aX,bX的最小公倍数=abX=(aX*bX)/X
即最小公倍数=两数之积/最大公约数

那么也可以进一步证明出:两个数的乘积 = 最大公因数与最小公倍数的乘积
即aX*bX = X*(abX)=(aX)*(bX)

代码思路:
暴力求解的话和前面类似不过这次是拿两者较大的值开始试
比如6和8的最小公倍数就用[8,6*8]的范围试
或者先求出最大公约数然后最小公倍数就 = 两数之积/最大公约数
注意:如果用int，最小公倍数可能会溢出建议结果用long long保存

T12 打印99乘法口诀表

就提几个注意点:

%数字d 不要写成数字%d
-2是左对齐两位(就记成按照我平时的习惯就喜欢写-2左对齐) 2是右对齐两位
不要乱用对齐 这里前两位乘数就不可能有两位不需要对齐 只有结果可能是两位

这就是 %2d的样子是右对齐

int main()
{
	for (int i = 1; i <= 9; i++)
	{
		for (int j = 1; j <= i; j++)
		{
			printf("%d*%d=%d ", i, j, i * j);
		}
		printf("\n");
	}
	return 0;
}

T13 不排序求十个整数中的最大值

思路:

定义一个数组放10个整数
假设第一个元素是最大值max
然后循环 让max和第二个开始的元素一一比较 如果遇到比max大的就重新赋值给max

错因:

max应定义为arr[0] 而不是一个具体的数 比如max=0 如果arr都是负数呢?
在数组里挑一个最大的肯定是以数组里元素的为标杆 不能随便找一个标杆在我们班找一个最能打的能找泰森作为标杆吗?
如果是自己输入的数据 那max一定要等输入完再定义为arr[0]

T14 求1/1-2/1+1/3-4/1…-100/1

思路:
虽然下面两种想法代码写出来一模一样但是思考方式不一样

分子恒为1 产生正负交替的分母 累加即可:sum += 1.0 / (i*symbl);
分子恒为1 分母每次递增1 让整体的计算结果正负交替:sum += symbol * (1.0 / i);

注意:1.0默认是double 计算出来的sum也就是double
如果定义的是float double->float会报警告 最好double sum 然后用%lf打印

思路很多还可以分两部分计算
奇数项是+ 偶数项是-

T15 计算给定数组中多个数的最大公约数

问题描述:
前面只会求两个数的最大公约数那怎么求一组数的最大公约数呢?

思路:
M=aX N=bX 且ab互质则gcd(M,N)=X
若再gcd(X,K)=z
则gcd(M,N,K)=z

第1次循环:求gcd(0,1) result放的是 0和1的最大公约数
第2次循环:求gcd(0和1的最大公约数,2) result放的是 0和1和2的最大公约数
第3次循环:求gcd(0和1和2的最大公约数,3) result放的是 0和1和2和3的最大公约数
…

int gcd(int m, int n)
{
	int c = 0;
	//当某一次 c = a%b = 0  为假了 就不进去循环了 此时b就是最大公约数
	while (c = m % n)
	{
		m = n;
		n = c;
	}
	return n;
}

int main()
{
    int arr3[] = { 26, 39, 52, 65, 78, 91 };
    //用于存放结果
    int result = arr3[0];

    for (int i = 1; i < 6; i++)
    {
        result = gcd(result, arr3[i]);
    }

    printf("%d ", result); // 输出最大公约数
    return 0;
}

这是我写的代码
看似利用了数组循环次数也少了但属实没必要呀!
微不足道的提升而且不如前面的代码好理解!!
除非他题目真的要求不准新建变量倒确实可以这么写
自己画图看看的话其实两个代码的思路是完全一样的前面的思路更清晰!!!

T16 求整数1-100中数字9出现的次数

错因:
下面的错误在于 个位和十位都要被判断到
假如是99 进去第一个if 判断个位是9 ++之后 就不会进入else if了
直接开始判断100 少判断了一个99的十位9
if elseif else 是一个整体只有一个入口
而这道题就是要每一位都作为一个入口每一位都要判断一下

写||也不对 99还是只判断了一次

两种情况都需要判断的情况 不能用if elseif
if - if 符合要求个位要判断一下十位也要判断一下:

int main()
{
	int count = 0;
	for (int i = 1; i <= 100; i++)
	{
		if (i / 10 == 9)
			count++;
		if (i % 10 == 9)
			count++;
	}
	printf("%d", count);
	return 0;
}

T17 递归实现n的k次方(n,k都是整数考虑k是负数)

思路:

任何数的0次方都为1
2的10次方 = 2*(2的9次方) = 2*2*(2的8次方) = 2*2....*(2的1次方)
则递推方程 (n,k) = n*(n,k-1)
因为是return 所以下图加不加else 其实是一样的

一个瑕疵:n,k是整数 为什么不考虑负整数?

既然这样当k=0 return 1.0 整体也更好
不仅1.0*其他数会提升成double 1.0也和返回值的double对应了

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
double myPow(int num,int k)
{
	if (k == 0)
		return 1.0;
	//如果k是负数 那就是返回-k次方的倒数
	else if (k < 0)
		return 1.0 / myPow(num, -k);
	else
		return num * myPow(num, k - 1);
}

int main()
{
	printf("%.3f ", myPow(2, -3));
	printf("%.3f ", myPow(2, -2));
	printf("%.3f ", myPow(2, -1));
	printf("%.3f ", myPow(2, 0));
	printf("%.3f ", myPow(2, 1));
	printf("%.3f ", myPow(2, 2));
	printf("%.3f ", myPow(2, 3));
	printf("%.3f ", myPow(2, 4));
	printf("%.3f ", myPow(2, 5));
	return 0;
}

T18 递归求一个正整数的每一位数字的和

题目描述:

思路:
大问题:(1729)
拆成子问题 = (172) + 9 = (17) + 2 + 9 = (1) + 7 + 2 + 9

int DigitSum(int num)
{
	if (num <= 9)
		return num;
	else
		return num % 10 + DigitSum(num / 10);
}
int main()
{
	printf("%d\n", DigitSum(1234));
	printf("%d\n", DigitSum(1729));
	return 0;
}

*T19 字符串逆序(不是逆序打印是真的逆序)

题目描述:

不让使用库函数就是想让你自己写一个strlen 在C语言专栏函数章节已经介绍过
唯一要注意的是参数已经给你定死了 只有一个char*
注意:这里只是训练一下递归 其实这道题用递归大可不必!!
因为这道题逼着我用递归逼着我只有一个参数 所以才写出下面比较复杂的思路的

先把递归的正确答案和思路写在前面后面也介绍了其他思路:

按照C语言专栏函数部分说的那样第一步我先假设出函数功能 假设reverse(char str) 能逆序一个字符串*
然后开始拆分自己问题首先交换收尾字符然后reverse(中间剩余字符)
此时bug出现了: 如下图 abcdef\0->fbcdea\0 再传一个str+1进去子问题成了逆序bcdea了
也就是说在程序眼中
从str+1往后看看到的是bcdea\0 处理的是bcdea无法准确处理我们想象中的那个子问题(bcde)
因为我只有一个参数str 如果说我用str代表一整个字符串的话肯定要去找\0 受到\0的约束!!

不要慌 这说明子问题拆分的还不够彻底 所以重新拆分:

先假设出函数功能假设reverse(char* str) 能逆序str~\0之间的一个字符串

“不要彻底交换”:
先把首字符暂存给tmp
再用末字符覆盖首字符
然后先不把tmp的首字符给直接给末字符而是把\0给末字符构造一个正确的子问题

处理新的子问题也就是reverse(掐头去尾的子串) 把中间的子串进行逆序

reverse()完之后 别忘了用之前tmp暂存的首字符去覆盖那个为了构造正确子问题而新增的'\0'
其实也就是把tmp赋给原先末字符的位置

考虑递归的结束条件 if什么条件我才需要执行第三步的reverse(子问题)?
显然:"\0"没有子问题 "a"没有子问题 "ab"有子问题!
也就是下一个子问题的字符串的长度>=2
也就是strlen(str+1)>=2

好好理解一下为什么是strlen(str+1)>=2
其实写strlen(str)>=2也是对的 但是这只是恰好对或者说并不严格符合前面的思路
就拿"abc"来说其实一上来先处理了ac了
然后继续reverse子问题的时候只要确保a和c中间的子串>=2 然后reverse(ac中间的子串)即可
如果写的是strlen(str)>=2 画图会发现:
最后一次的操作其实是reverse(b\0) 对字符b做了一系列没用的操作 仿佛让b原地跟自己换了个位置

再来理解一下过程下面红色高亮的部分就是主要过程:
abcdef\0 这是原始字符串 经过初始的处理构造出正确的子问题:fbcde\0\0 tmp暂存a
此时子问题就是reverse(bcde) 也就是reverse(str+1) 则处理这个子问题即f reverse(bcde\0) \0 tmp暂存a
假设处理完了子问题reverse(bcde) 也就是:fedcb\0\0 tmp暂存a
还需要再把a给倒数第二个\0 才成了fedcba
下面的代码其实就是按照这个思路写下去的

void reverse(char* str)
{
	//abcdef\0 -->fbcde\0\0  tmp = a
	char* begin = str;
	char* terminalFore = str + strlen(str) - 1;
	char tmp = *str;
	*str = *terminalFore;
	*terminalFore = '\0';

	//\0; a; ab; abc 需要
	//fbcde\0\0  tmp = a ---> fedcb\0\0 tmp暂存a
	if (strlen(str + 1) >= 2)
		reverse(++str);
	
	//fedcb\0\0 tmp暂存a --> fedcba
	*terminalFore = tmp;
}

int main()
{
	char ch[] = "abcdef";
	printf("%s\n", ch);

	reverse(ch);
	printf("%s\n", ch);
	return 0;
}

迭代法其实比递归更容易读懂
循环交换首字符和末字符就行

下面是我写的递归(假如不限制传参个数就是这么简单就不会像一开始那么复杂了):
但是题目限制了参数!! 严格来说我直接就是错的!!
我的思路也很简单:
倒置abcdef–>af交换+倒置bcde–>af交换+be交换+倒置cd
这个思路和前面第一次一开始上来的代码是一样的
只不过这里我传了两个参数所以能正确找到子问题(也就是逆序中间的子串) 而不被\0所影响
错误1:reverse2(pleft++, pright–); 写成了后置的这样会导致死递归(后置是先使用这导致不会每次都接近出递归条件)
问题2:把交换写在了函数开始如下图 (也就是一进去不管啥情况都做一下交换)
这种情况无法处理只有两个字符的子问题 因为会交换两次相当于没交换

感觉这个递归和迭代没啥区别迭代反而不容易错 不要为了递归而递归

void reverse2(char* pleft, char* pright)
{
	if (pleft < pright)
	{
		char tmp = *pleft;
		*pleft = *pright;
		*pright = tmp;
		reverse2(++pleft, --pright);
	}
}

int main()
{
	char ch[] = "abcdef";
	int sz = strlen(ch);
	char* right = ch + sz - 1;
	//reverse1(ch,sz);
	reverse2(ch,right);
	printf("%s\n", ch);
}

T20 不创建临时变量模拟先实现strlen()

思路:不创建临时变量只能用递归法(创建临时变量用迭代法其实更简单)

注意:不要忘记return 0
不写return 0 不仅是语法上的错误更是逻辑上的错误
本题的递归出口就是:遇到\0 就要返回0了
也就说每次传参都离\0越来越近

参考代码:

int MyStrlen(char* ch)
{
	//hello 1+ello 1+1+llo 1+1+1+lo 1+1+1+1+o 1+1+1+1+1+0
	if (*ch == '\0')
	//递归出口
		return 0;
	else
		return 1 + MyStrlen(++ch);
}

int main()
{
	char ch[] = "hello";
	printf("%d ", MyStrlen(ch));
	return 0;
}

思考:关于T19和T20++副作用的问题

首先肯定都不可以用后置++ 这是毫无疑问的
但是请思考:
T20可以写MyStrlen(++ch) 请问T19可不可以写成reverse(++str)? 也就是前置++?
答案是可以的 按照本文T19那段递归参考代码完全是可以的

但是请看下图如果这样写还可不可以?
这就不可以了!!!
因为前面T19 其实在str++之后再也没有用到str了
但是下图这种写法我还要用str 我想要的是一开始的str 你不能把他++之后再给我!!
所以最好都写成str+1 ch+1
因为这一步传参只是希望传入ch或者str的下一个地址
并没有想改变他们本身的值
而++操作符本身是带有自增的副作用的

T21 完成整型数组的初始化,打印,逆序三个函数

题目描述:
在这里插入图片描述

思路:
跟逆序字符串很类似 所以这类问题用迭代绝对比递归简单的
前面逆序字符串只是逼着我们学习一下递归的思想
可以写成while循环也可以写成for循环完整代码在下面

参考代码:

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

void print(int* arr, int len)
{
	int i = 0;
	for (i = 0; i < len; i++)
		printf("%d ", arr[i]);
	printf("\n");
}

void init(int* arr, int len)
{
	int i = 0;
	for (i = 0; i < len; i++)
		arr[i] = 0;
}

void reverse(int* arr, int len)
{
	int left = 0;
	int right = len - 1;
	int tmp = 0;
	for (left = 0, right = len - 1; left < right; left++, right--)
	{
		tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = tmp;
	}
}
int main()
{
	int arr[] = {1,2,3,4,5,6,7,8,9,0};
	int len = sizeof(arr) / sizeof(arr[0]);
	print(arr, len);

	reverse(arr, len);
	print(arr, len);

	init(arr, len);
	print(arr, len);

	return 0;
}

T22 打印菱形图案

题目描述+思路1:
每一行都打印13个元素用if把要打印*的位置找出来 else就打印空格
>头脑清醒找对规律就不会错
当然有很多种找规律的角度这是我的思路

思路1参考代码: 注意看注释

int main()
{
	int line = 0;//上三角的高
	int i = 0;
	int j = 0;
	while (scanf("%d", &line) != EOF)
	{
		//上三角 line 7
		for (i = 0; i < line; i++)
		{
			for (j = 0; j < 2 * line - 1; j++)
			{
				//i=0 第一行:(line - 1) - 0   (line - 1) + 0  这个范围打印* 其余打印空格
				//i=1 第二行:(line - 1) - 1   (line - 1) + 1  这个范围打印* 其余打印空格
				//找规律:(line - 1) - i      (line - 1) + i
				//line -1 - i                 line -1 + i
				if ((line -1 - i) <= j && j <= (line -1 + i))
				{
					printf("*");
				}
				else
				{
					printf(" ");
				}
			}
			printf("\n");
		}


		//下三角 line-1=6
		for (i = 0; i < line - 1; i++)
		{
			for (j = 0; j < 2 * line - 1; j++)
			{
				//i=0 第一行:(line - 1) - 5   (line - 1) + 5  这个范围打印* 其余打印空格
				//i=1 第二行:(line - 1) - 4   (line - 1) + 4  这个范围打印* 其余打印空格
				//找规律:(line - 1) - [(line-1)-i-1]        (line - 1) + [(line-1)-i-1]
				//i+1                        2line-i-3
				if ((i + 1) <= j && j <= (2 * line - i - 3))
				{
					printf("*");
				}
				else
				{
					printf(" ");
				}
			}
			printf("\n");
		}
	}

	return 0;
}

思路2:
也是分成思路1的上下俩三角形 line也是上三角的高
但是打印每一行的时候找规律的思路不一样
下图是上三角
先打印空格找空格的规律
再打印* 找*的规律
自己数数找规律然后跟i关联起来就行

然后是下三角同样先找空格的规律再找*的规律

思路3:
第一次写想了很久的一个复杂化的思路:
我的思路是利用距离D 来找规律的得到一个判断的不等式
代码写少了就会这样
太复杂了我已经不想复盘了!!!
第二次写这道题想到的就是思路一已经满足了

参考代码:很复杂不建议看

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>

int main()
{
	int i = 0;
	int j = 0;
	int line = 7;
	while (1)
	{
		scanf("%d", &line);
		//上半部分 1,2,3,4.....,line 正三角  有line行
		//列都是2 * line - 1列 每一列(空格+* 有这么多)
		for (i = 1; i <= line; i++)
		{
			for (j = 1; j <= 2 * line - 1; j++)
			{
				//打印*的条件:
				//1.当j和最中间的那个元素(也就是当j=line的时候)之间的距离 小于D的时候 打印*
				//2.发现D=i-1
				//3.j和line的距离表示为|j-line|
				//4.|j-line|<=i-1
				if ((line + 1 - i <= j) && (j <= line - 1 + i) || (j == line))
				{
					printf("*");
				}
				else
				{
					printf(" ");
				}
			}
			printf("\n");


		}

		//下半部分 行数比上半部分少1    
		//列都是2 * line - 1列 每一列(空格+* 有这么多)
		for (i = 1; i <= line - 1; i++)
		{

			//打印*的条件:
			//1.当j和最中间的那个元素(也就是当j=line的时候)之间的距离 小于D的时候 打印*
			//2.发现D+i=line-1---->D=line-i-1
			//3.j和line的距离表示为|j-line|
			//4.|j-line|<=line-i-1
			for (j = 1; j <= 2 * line - 1; j++)

			{
				if ((i + 1 <= j) && (j <= 2 * line - 1 - i) || (j == line))
				{
					printf("*");
				}
				else
				{
					printf(" ");
				}
			}
			printf("\n");
		}
	}
	return 0;
}

T23 判断是不是自幂数(水仙花数)

题目描述:

思路:直接暴力求
最好把函数解耦后面会解释原因
有以下两个错因:
计算几位数的时候这里写成了num>9
吸取教训 以后类似的情况举例子带进去算算就清晰了!!!

此外 pow的返回值类型是double 如果不想看到这个警告可以强转一下

参考代码:

#include<math.h>

//计算num是几位数
int numOfDigit(int num)
{
	int count = 0;
	//153 1     15  2    1 3
	while (num > 0)
	{
		count++;
		num /= 10;
	}
	return count;
}

//判断
int isSelfPower(int num)
{
	int sum = 0;//求和
	int count = numOfDigit(num);//位数
	int flag = num;//保存原来num的值

	//1234  4       123   3       12 2     1 1
	while (num > 0)
	{
		sum += (int)pow(num % 10, count);
		num /= 10;
	}
	return sum == flag;
}

int main()
{
	int i = 0;
	for (i = 1; i <= 100000; i++)
	{
		if (isSelfPower(i))
			printf("%d ", i);
	}
	return 0;
}

把各个函数功能解耦有什么好处?
如果全都写在同一个函数里 就会反复使用到同一个参数num
容易写出下图这种bug
如果解耦成不同的函数就可以避免

一些细节问题:
一开始也看到了 0这个特殊的数也是个自幂数
正常思路应该是 0是1位数那么0¹=0 所以满足条件
虽然我给出的参考代码 没有严格按照规则去判断但是可以完成任务
我的代码:当i=0的时候 sum=0 count=0 flag=0
直接rerun flag==sum 刚好满足条件所以判断0也是自幂数
如果觉得这样不好那就在isSelfPower里一上来就写一句
if(num == 0) return 1
也没问题的

T24 求Sn=a+aa+aaa+… 其中a是一个0~9的整数共有n项

思路1:
2 + 22 + 222 + 2222 + 22222
2*(1+11+111+1111+11111)
()里是固定的一个数 把他求出来然后乘上2就行了 (ret = sum * a;)

参考代码:

#include<math.h>
int main()
{
	int a = 0;
	int n = 0;
	while (scanf("%d %d", &a, &n) != EOF)
	{
		int sum = 0;//求1+11+111+1111.....
		int tmp = 0;
		int ret = 0;

		//求1+11+111+1111.....
		for (int i = 0; i < n; i++)
		{
			tmp = tmp * 10 + 1;
			sum += tmp;
		}

		ret = sum * a;
		printf("%d\n", ret);
	}

	return 0;
}

思路2:
找规律 其实就是把思路1一步到位了

T25 换汽水喝(两种思维)

题目描述:
其实感觉有歧义小时候大家肯定都做过这个"脑筋急转弯"
最后有一个空瓶的时候可以"赊账" 喝完再抵掉
但是本题不考虑"赊账" 简单点
后面会继续介绍一种思维方式:其实能得出真正意义上的最多能喝几瓶水(值等于能赊账的值)

思路1:
既然不考虑赊账那直接暴力求解了
错因:
头脑不清晰思路不明确仿佛在迷信式写代码
改一下调试一下不对继续改思路完全不清晰
把while循环里的两句话先后都写反了那就错了
其实就两个核心:换来喝->更新空瓶数量->换来喝->更新空瓶数量…
更新空瓶的思路也要清晰:上次没换完剩的瓶子+刚喝完几瓶又新换了几瓶
如果觉得直接赋初值很突兀可以这么写:
达到的效果是一样的

参考代码:

int main()
{
	//初始值直接给出
	int BottleSum = 20;
	int left = 20;

	//开始换气水喝
	while (left >= 2)
	{
		//换汽水 然后喝掉 把喝掉的瓶数加给sum
		BottleSum += (left / 2);

		//更新剩下的空瓶:1.上次没换完剩的+2.刚喝完换到手的多的
		//然后继续循环 再把更新后的空瓶换汽水喝
		left = (left % 2) + (left / 2);
	}
	printf("%d", BottleSum);

	return 0;
}

思路2:动脑思考
1元=1瓶水=2空瓶则1空瓶=0.5元
那20元最多产生40个空瓶(价值交换) 也就是最多能喝40瓶水
事实上上述代码不考虑"赊账" 答案是39 假如考虑"赊账" 答案真的就是40
所以40才是理论上的最多值
或者也可以说自己找到了规律:2*money-1
其实这就是寻求算法求解的过程

T26 调整数组使奇数全部都位于偶数前面

题目描述:

思路1:双指针(不允许创建新的数组)
左边找偶数右边找奇数找到了就交换
下面是我第二次写还犯的错误必须要注意
本质就在于 如果left<right 说明还没处理完
如果left=right了说明全都处理完了就不需要再继续了

其实 最下面的if 如果说不满足if 只有一种可能就是left=right
多一个if 只是避免了自己跟自己交换这个没意义的动作 不加其实答案效果是一样的

思路1参考代码:

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

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

	Print(arr, len);

	int left = 0;
	int right = len - 1;
	int tmp = 0;
	
	while (left < right)
	{
		//找偶数
		while ((arr[left] % 2 == 1) && (left < right))
			left++;

		//找奇数
		while ((arr[right] % 2 == 0) && (left < right))
			right--;

		if (left < right)
		{
			tmp = arr[left];
			arr[left] = arr[right];
			arr[right] = tmp;
			left++;
			right--;
		}
	}
	
	Print(arr,len);

	return 0;
}

思路2:暴力

如果是 22222222222222222 复杂度很高是O(n²)
如果是双指针 最坏的情况也就是遍历一遍数组复杂度是O(n)

思路2参考代码:

void func(int* arr,int len)
{
	for (int i = 0; i < len; i++)
	{
		//发现一个偶数 你不应该在前面
		if (arr[i] % 2 == 0)
		{
			//从i+1开始 去找第一个出现的奇数 跟他交换
			for (int j = i+1; j < len; j++)
			{
				if (arr[j] % 2 == 1)
				{
					int tmp = arr[i];
					arr[i] = arr[j];
					arr[j] = tmp;
					break;
				}
			}
		}
	}
}

思路3:双指针的另一种视角
和下面的BC98可以说是一模一样的思路
只不过BC98在 “复用当前数组直接覆盖INDEX就行”
这里 不能覆盖而是交换

思路3参考代码:

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

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int len = sizeof(arr) / sizeof(arr[0]);
	Print(arr, len);

	int i = 0;//遍历的指针
	int INDEX = 0;//有效位置--放奇数的

	for (i = 0; i < len; i++)
	{
		if (arr[i] % 2 != 0)//找有效数组-->找奇数
		{
			//不能直接覆盖 而是交换
			int tmp = arr[i];
			arr[i] = arr[INDEX];
			arr[INDEX] = tmp;
			INDEX++;
		}
	}

	Print(arr, len);
	return 0;
}

T27 预测比赛名次

题目描述:

思路:
核心就在于怎么用代码表示"只对了一半"
也就是一真一假 1和0 那就是1+0=1
其次怎么让名次唯一
让名次唯一:
我试了A+B+C+D+E==15 不行
我试了(A != B) && (B != C) && (C != D) && (D != E) 也不行
A * B * C * D * E == 120 这个值肯定是唯一的彳亍!!

参考代码:

#include<stdio.h>

int main()
{
	int A = 0;
	int B = 0;
	int C = 0;
	int D = 0;
	int E = 0;

	//穷举所有名次可能
	for (A = 1; A <= 5; A++)
	{
		for (B = 1; B <= 5; B++)
		{
			for (C = 1; C <= 5; C++)
			{
				for (D = 1; D <= 5; D++)
				{
					for (E = 1; E <= 5; E++)
					{
						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)
							&& (A * B * C * D * E == 120)
							)

						{
							printf("A:%d B:%d C:%d D:%d E:%d\n", A, B, C, D, E);
						}
					}
				}
			}
		}
	}
	return 0;
}

T28 找凶手

题目描述:

思路1:
ABCD四个人每个人都有0或者1两种取值
0代表清白 1代表是凶手
四个人的描述都加起来结果应该是3 因为有三个人说真话
但是凶手只有一个所以A+B+C+D = 1

思路1参考代码:

int main()
{
	int A = 0;
	int B = 0;
	int C = 0;
	int D = 0;
	for (A = 0; A <= 1; A++)
	{
		for (B = 0; B <= 1; B++)
		{
			for (C = 0; C <= 1; C++)
			{
				for (D = 0; D <= 1; D++)
				{
					if (
						((A == 0) + (C == 1) + (D == 1) + (D == 0)) == 3
						&& (A + B + C + D) == 1
						)
					{
						printf("%d %d %d %d\n", A, B, C, D);

					}
				}
			}
		}
	}
	return 0;
}

思路2:
定义出killer 假设killer是A B C D
然后写出四个人对应的描述
加起来结果是3 看看哪个猜测是对的
其实这个代码更符合我们人的思考模式

T29 杨辉三角

题目描述:

思路:
先在数组里放入如下内容
第一列都是1 最右边都是1
其余的元素计算得出即可
然后打印的时候做一个格式控制
//一共打印LINE(5)行
//第一行打印之前先打印4个空格
//第二行打印之前先打印3个空格
//第三行打印之前先打印2个空格
//第四行打印之前先打印1个空格
//第五行打印之前先打印0个空格

参考代码:

#define LINE 5
int main()
{
	    //1          //4 
	   //1 1        //3   
	  //1 2 1      //2      
	 //1 3 3 1    //1     
	//1 4 6 4 1  //0     

	int arr[LINE][LINE] = { 0 };
	//放元素
	for (int i = 0; i < LINE; i++)
	{
		for (int j = 0; j <= i; j++)
		{
			if ((j == 0) || (i == j))
				arr[i][j] = 1;
			else
				arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
		}
	}
	//打印
	for (int i = 0; i < LINE; i++)
	{
		//先打印空格
		for (int k = 0; k < LINE - 1 - i; k++)
		{
			printf(" ");
		}
		//再打印有效元素
		for (int j = 0; j <= i; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}

	return 0;
}

T30 杨氏矩阵

题目描述:

思路:
假设矩阵是
1 2 3
4 5 6
7 8 9
每次都以最右上角的那个元素为准(是一行里最大的同时也是一列里最小的)
如果要找的元素比3大那可以去掉一行
如果要找的元素比3小那可以去掉一列
每次去掉1行/1列之后都以新的右上角的元素为准如此循环
最多N次都可以遍历整个矩阵
既然右上角可以那每次以左下角为准也可以
但是左上角和右下角就不可以 无法直接去掉一行或者一列
&ROW和&COL不仅可以作为输入参数还可以接收返回值把返回值带出去
这是一种不错的设计思路

参考代码:

int find_num(int arr[3][4], int* pROW, int* pCOL, int tar)
{
	int ROW = 0;
	int COL = *pCOL - 1;
	while ((ROW <= *pROW - 1) && (COL >= 0))
	{
		//去掉一列
		if (arr[ROW][COL] > tar)
		{
			COL--;
		}
		else if (arr[ROW][COL] < tar)
		{
			ROW++;
		}
		else
		{
			*pROW = ROW;
			*pCOL = COL;
			return 1;
		}
	}
	return 0;
}

int main()
{
	int arr[3][4] = { {1,3,5,6}, {7,8,9,12}, {20,30,70,90} };
	int tar = 11;
	int ROW = 3;
	int COL = 4;

	int ret = find_num(arr, &ROW, &COL, tar);
	if (ret)
		printf("找到了:arr[%d][%d]\n", ROW, COL);
	else
		printf("没找到\n");
}

思考:如果不止一个目标数呢?
其实很简单
当找到了一个目标数由于目标数所在的行和列都是单调递增的所以不可能重复
那么直接跳过一行并且跳过一列 继续寻找即可

参考代码:

int main()
{
	int arr[4][3] = { {1,2,3},{9,20,30},{20,30,40},{30,40,60} };
	int tar = 30;
	int ROW = 0;
	int COL = 2;

	while ((ROW <= 3) && (COL >= 0))
	{
		if (arr[ROW][COL] > tar)
		{
			COL--;
		}
		else if (arr[ROW][COL] < tar)
		{
			ROW++;
		}
		else
		{
			printf("找到了:arr[%d][%d]\n", ROW, COL);
			ROW++;
			COL--;
		}
	}
	return 0;
}

T31 字符串左旋

题目描述:

思路1:暴力法
假如是ABCD 左旋一个字符就是BCDA
那么首先把第一个字符暂存然后BCD往前挪最后再把暂存的A放到最后
如果左旋的是两个那么继续对B进行此操作
每次都把第一个字符暂存然后后面的字符往前挪最后把暂存的字符放在最后

思路1参考答案:

void move(char* arr, int k)
{
	//暴力法思路:
	//1.左旋1个 就是把第一个元素先存着 然后后面整体往前挪动 然后再把第一个元素放到最后
	//2.左旋k个 就是重复k次上面的动作
	int len = strlen(arr);
	k = k % len;
	for (int i = 0; i < k; i++)
	{
		//1.存第一个元素
		char tmp = *arr;
		//2.后面整体往前挪动
		for (int j = 0; j < len - 1; j++)
		{
			*(arr + j) = *(arr + j + 1);
		}
		//3.把第一个存的元素给最后位置
		*(arr + len - 1) = tmp;
	}
}

思路2:找规律或者我认为这就是算法的力量
比如ABCD 我希望左旋两个那就把ABCD分为AB CD
先把两部分分别逆序得到BA DC
再把整体逆序
得到CDAB 就已经完成了左旋两个字符
同时也和暴力法一样左旋n个和左旋n%4个是一模一样的
为了防止越界每次都需要%4

参考代码:

void reverse(char* start, char* end)
{
	char tmp = ' ';
	while (start < end)
	{
		tmp = *start;
		*start = *end;
		*end = tmp;
		start++;
		end--;
	}
}

int main()
{
	char str[] = "abcdefg";
	int len = strlen(str);

	int num = 0;
	printf("你要左旋几个字符?\n");
	scanf("%d", &num);
	num = num % len;

	reverse(str, str + num - 1);
	reverse(str + num, str + len - 1);
	reverse(str, str + len - 1);

	printf("%s", str);
	return 0;
}

T32 判断一个字符串是不是由另一个字符串旋转得到

题目描述:

思路1:暴力法
首先明确一点:这里说的是旋转没有说明左旋还是右旋
仍然以ABCD为例
左旋一个:BCDA
右旋三个:BCDA
所以暴力的时候可以一律都当做左旋来处理
而这里的思路用暴力就很简单了
参考T31 每次左旋1个然后判断一下 (字符串判断一定要用strcmp) 循环字符串长度次
注意一个易错点:

参考代码:

#include<stdio.h>
#include<string.h>
void reverse(char* start, char* end)
{
	char tmp = ' ';
	while (start < end)
	{
		tmp = *start;
		*start = *end;
		*end = tmp;
		start++;
		end--;
	}
}

void left_move(char*str,int num)
{
	int len = strlen(str);
	num = num % len;

	reverse(str, str + num - 1);
	reverse(str + num, str + len - 1);
	reverse(str, str + len - 1);
}

//判断ch2是不是由ch1旋转得到
int is_move(char* ch1, char* ch2)
{
	if (strlen(ch1) == strlen(ch2))
	{
		for (int i = 0; i < strlen(ch1); i++)
		{
			//每次循环 左旋一个 然后判断
			left_move(ch1, 1);
			if (strcmp(ch1, ch2) == 0)
			{
				return 1;
			}
		}
		return 0;
	}

	else
	{
		return 0;
	}
}

int main()
{
	char ch1[] = "AABCD";
	char ch2[] = "BCDAA";
	if (is_move(ch1, ch2))
		printf("是的\n");
	else
		printf("不是\n");
	return 0;
}

思路2:利用库函数
首先要知道假设是ABCD 那么ABCD旋转的所有可能性
无论是左旋还是右旋 都是ABCDABCD的一个子串
那就先给ABCD追加一个自己
然后判断是否是追加后的子串即可

参考代码:

#include<stdio.h>
#include<string.h>

int is_move(char* str1, char* str2)
{
	if (strlen(str1) != strlen(str2))
		return 0;
	//再往下 就能保证长度是相等的了
	strncat(str1, str1, strlen(str1));

	if (strstr(str1, str2) != NULL)
	{
		return 1;
	}

	//能走到这 就说明没有return 1 
	//也就是没有子串 那肯定就不是旋转所得
	return 0;
}

int main()
{
	char ch1[100] = "AABCD";//要追加 ch1空间给大点
	char ch2[] = "ADAAB";
	if (is_move(ch1, ch2))
		printf("是的\n");
	else
		printf("不是\n");
}

二、力扣

面试题 17.04. 消失的数字题目链接

解法一:首先^遵循交换律且0^N=N N^N=0 把所有的元素都^起来相同的都成0 剩下一个单独的就是消失的数字相当于找单身狗
解法二:既然题目描述里的n 其实应该等于numsSize 也就是我应该有的元素是0,1,2,3,4,n(numsSize) 把他们全都加起来去减数组的值结果就是那个孤儿
解法二还可以优化 1-n求和直接用公式都不需要遍历

//我的代码:
int missingNumber(int* nums, int numsSize) {
    int ret = 0;
    int sum = 0;
    for (int i = 0; i < numsSize; i++) {
        scanf("%d", &nums[i]);
        ret = ret ^ nums[i];
        ret = ret ^ i;
    }
    ret = ret ^ numsSize;

    //思路二:
    // for (int i = 0; i <= numsSize; i++) {
    //     sum += i;
    // }

    // for (int i = 0; i < numsSize; i++) {
    //     scanf("%d", &nums[i]);
    //     sum -= nums[i];
    // }
    return ret;
}

考研C语言程序设计_编程题相关(持续更新)

目录

一、程序设计经典编程题(C语言实现)

T1 求1~100的奇数

T2 求n!

T3 求1!+2!+3!+…+10!

T4 在一个有序数组中查找具体的某个数字n(二分查找)

T5 编写代码，演示多个字符从两端移动，向中间汇聚

T6 模拟用户登录(三次机会)

T7 输入三个数 并从大到小输出

T8 打印100~200的素数(质数)

T9 打印1000~2000之间的闰年

T10 求最大公约数(含递归)

补充:辗转相除法的证明

T11 求最小公倍数

T12 打印99乘法口诀表

T13 不排序 求十个整数中的最大值

T14 求1/1-2/1+1/3-4/1…-100/1

T15 计算给定数组中多个数的最大公约数

T16 求整数1-100中数字9出现的次数

T17 递归实现n的k次方(n,k都是整数 考虑k是负数)

T18 递归求一个正整数的每一位数字的和

*T19 字符串逆序(不是逆序打印 是真的逆序)

T20 不创建临时变量 模拟先实现strlen()

思考:关于T19和T20++副作用的问题

T21 完成整型数组的初始化,打印,逆序 三个函数

T22 打印菱形图案

T23 判断是不是自幂数(水仙花数)

T24 求Sn=a+aa+aaa+… 其中a是一个0~9的整数 共有n项

T25 换汽水喝(两种思维)

T26 调整数组使奇数全部都位于偶数前面

T27 预测比赛名次

T28 找凶手

T29 杨辉三角

T30 杨氏矩阵

T31 字符串左旋

T32 判断一个字符串是不是由另一个字符串旋转得到

二、力扣

面试题 17.04. 消失的数字题目链接

三、牛客网

BC49 判断两个数的大小关系

BC84 计算y的值

BC101 班级成绩输入输出

BC23 时间转换

BC50 计算单位阶跃函数

BC117 小乐乐走台阶

BC112 小乐乐求和(注意数据类型的格式)

BC114 小乐乐排电梯(考察细心)

JZ15 二进制(补码)中1的个数

JZ15拖展1 判断某个正整数n是不是2的k次方

JZ15拖展2 分别打印整数num二进制补码的奇数位和偶数位

JZ15拖展3 求两个int的二进制补码 有多少个位不同

BC54 获得月份天数

BC90 矩阵计算

BC111 小乐乐与进制转换

BC107 矩阵转置

BC98 序列中删除指定数字

HJ106 字符逆序

BC106 上三角矩阵判定

BC105 矩阵相等判定

BC100 有序序列合并

BC96 有序序列判断(牛客网有bug)

HJ108 求最小公倍数

OR62 倒置字符串

T4 在一个`有序数组`中查找具体的某个数字n(二分查找)

T7 输入三个数并从大到小输出

T13 不排序求十个整数中的最大值

T17 递归实现n的k次方(n,k都是整数考虑k是负数)

*T19 字符串逆序(不是逆序打印是真的逆序)

T20 不创建临时变量模拟先实现strlen()

T21 完成整型数组的初始化,打印,逆序三个函数

T24 求Sn=a+aa+aaa+… 其中a是一个0~9的整数共有n项

JZ15拖展3 求两个int的二进制补码有多少个位不同