C语言 100道经典编程题适用于专升本，专接本【详细分析版】_c语言专升本题目

2401_84247849

已于 2024-04-17 03:09:46 修改

阅读量1.2k

点赞数 23

分类专栏： 2024年程序员学习文章标签： c语言开发语言

于 2024-04-17 03:09:44 首次发布

本文链接：https://blog.csdn.net/2401_84247849/article/details/137848949

版权

2024年程序员学习专栏收录该内容

94 篇文章

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新软件测试全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上软件测试知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注软件测试）

正文

printf(“请输入(n,k):”);
scanf(“%d%d”, &n,&k);
printf(“%d”, fun(n, k));
return 0;
}

递归过程图：

⭐️非递归法:

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

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

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

⭐️递归版:

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

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

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

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

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

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

⭐️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就行

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

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

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

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

⭐️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;

}

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

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

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

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

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

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

⭐️方法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;
}

⭐️方法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;
}

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

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

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

在这里插入图片描述

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

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

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

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

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

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

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

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

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

⭐️法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);
}

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

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

⭐️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.把最小数和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.结束条件是ttn-1也就是淘汰掉了n-1个还剩一个人
3.a数组元素不为0 报数+1
4.k3报到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.为数组赋值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;
}

⭐️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.外层用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;
}

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

⭐️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]);
}
}

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

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

⭐️在给定的字符串 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;
}

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

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

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

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

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

⭐️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);
}

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

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

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

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

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

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

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

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

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

⭐️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]放到ai+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;
}

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