题后总结！常看常新！
如有错误，还望指正！
注：题源于未来教育题库
题型一：数组问题
1-1 删除字符
实现fun，其功能是:将s所指字符串中ASCII值为奇数的字符删除，剩余字符形成的新串放在t所指数组中。
例如，若s所指字符串中的内容为: "ABCDEFG12345"，其中字符A的ASCII码值为奇数字符1的ASCll码值也为奇数都应当删除，其它依此类推。最后t所指的数组中的内容应是:"BDF24"。
#include <string.h>//说明可以使用strlen()，一般题目未明确说不能使用strlen()，就可以直接使用该函数来计算字符串长度
void fun(char *s, char t[])
{
int i,j=0;//j作为数组t的数组长度
for(i=0;i<strlen(s);i++)
{
if(!(s[i]%2==1)) t[j++]=s[i];//数组t赋值后,j自增
}
t[j]='\0';//设置休止符
}
批注：
（1）ASCII码值为奇数字符满足s[i]%2==1；ASCII码值为偶数字符满足s[i]%2==0
（2）逻辑非！的使用
（3）新数组单独计数t[j++]=s[i];
【同类型题1】编写函数fun该函数的功能是:将s所指字符串中ASClI码值为偶数的字符删除,串中剩余字符形成一个新串放在t所指的数组中
if(!(s[i]%2==0)) t[j++]=s[i];
【同类型题2】函数fun的功能是:将s所指字符串中下标为偶数同时ASCII值为奇数的字符删除，s所指串中剩余的字符形成的新串放在t所指的数组中。
if(!(i%2==0&&s[i]%2==1)) t[j++]=s[i];
【同类型题3】删除字符串中所有的空格
if(str[i]!=' ')str[j++]=str[i];
【同类型题4】在此程序中，规定输入的字符串中只包含字母和*号。请编写函数fun，其功能是:除了字符串前导的*号之外，将串中其它*号全部删除。在编写函数时，不得使用C语言提供的字符串函数。【利用指针进行字符的删除】
例如，字符串中的内容为:****A*BC*DEF*G*******，删除后，字符串中的内容应当是: ****ABCDEFG。
void fun( char *a )
{
int k=0;
char *p=a;
while(*p&&*p=='*')//如果当前内容*p不为空且内容为星号则存入数组a中
{
a[k++]=*p++;
}
while(*p)//继续遍历
{
if(*p!='*') {a[k++]=*p++;}//如果非星号则存入数组a中，并指针向前
else p++;//如果是星号则指针向前
}
a[k]='\0';//设置休止符
}【同类型题5】 在此程序中，规定输入的字符串中只包含字母和*号。请编写函数fun，其功能是:将字符串尾部的*号全部删除，前面和中间的*号不动。
例如，字符串中的内容为:“****A*BC*DFF*G********"，删除后，字符串中的内容应当是:"****A*BC*DEF*G"。在编写函数时，不得使用C语言提供的字符串函数。
void fun( char *a )
{
while(*a)//使指针指向休止符的位置
{
a++;
}
a--;//使指针指向最后一个字符的位置
while(*a=='*')//如果是*则指针后移
{
a--;
}
*(a+1)='\0';//设置休止符，意味着在非星号后赋值为休止符，起到删除字母后的所有的星号的作用
}【同类型题6】在此程序中，规定输入的字符串中只包含字母和*号。请编写函数fun，其功能是︰将字符串中的前导*号全部移到字符串的尾部。
例如，字符串中的内容为:"*******A*BC*DEF*G****”，移动后，字符串中的内容应当是:"A*BC*DEF*G***********“。在编写函数时,不得使用C语言提供的字符串函数。
void fun( char *a )
{
int n=0,k=0;//n用于记录字母前的星号数量，k表示字符串（数组）a的字符个数
char *p=a;//使p指针指向字符串a的首地址
while(*p&&*p=='*')//记录字母前的星号数量
{
n++;
p++;
}
while(*p)//从字母开始对数组进行赋值
{
a[k++]=*p++;
}
while(n--)//数组加上n个星号
{
a[k++]='*';
}
a[k]='\0';//设置休止符
}【同类型题7】请编写函数fun,其功能是:只删除字符前导和尾部的*号,串中字母间的*号都不删除。形参n给出了字符串的长度，形参h给出了字符串中前导号的个数，形参e给出了字符串中尾部*号的个数。在编写函数时，不得使用C语言提供的字符串函数。
例如，字符串中的内容为: "****A*BC*DEF******".
删除后，字符串中的内容应当是: "A*BC*DEF*G" 。
void fun( char *a, int n,int h,int e )//n：字符串的长度，h:字符串中前导号的个数，e :字符串中尾部*号的个数
{
int i,j=0;
for(i=h;i<n-e;i++)//截取索引值在[h,n-e-1]的字符
{
a[j++]=a[i];
}
a[j]='\0';
}【同类型题8】请编写函数fun,fun的功能是按顺序将形参a所指的字符串中每个单词的第一个字母取出，依次存放到形参b所指的字符串中去。形参a所指的字符串中的单词以一个或多个空格进行分隔，字符串首部和尾部可以有一个或多个空格。
思路：a找到一个单词首字母，就放到b指向的内存空间，b移动到下一个内存空间，a继续找，如果又找到啦，就放到b指向的内存空间，依次类推。就是一个寻找和存放的过程。【或者想象成在所有的班里依次找到各班的第一名，放在一起组成一个新的班级】
void fun(char *a,char *b)
{
while(*a==' ')//找到字符串的第一个单词的首字母
{
a++;
}//结束该循环时，则意味着已经找到了第一个字母
*b++=*a++;//使b指向a所指的字符（第一个单词的首字母），然后指针a向前，指向下一个字符。
指针b也向前，指向下一个内存空间；
while(*a)//遍历剩余字符串，若遍历到休止符则结束循环。a有四种指向结果：1.单词首字母。2.非单词首字母。3.空格。4.休止符
{
if(*(a-1)==' '&&*a!=' ')//遍历到单词的首字母（首字母前有空格）
{
*b++=*a;//使b指向a所指向的单词的首字母，然后指针b向前，指向下一个内存空间
}
a++;//指针后移，继续遍历
}
*b='\0';//赋休止符
}批注：
（1）*b++=*a++;意味着先赋值，后指针向前
（2）休止符'\0'的ASCII码是0。即printf("%d",'\0');输出为0。
【同类型题9】请编写函数fun，其功能是从一行单词字符串数组a中分别提取每个单词尾部的字母组成一个新的字符串数组b，并通过实参返回。单词分隔是以—个空格或几个空格进行分隔。
例如:This is a C program
输出:ssaCm
方法一：
void fun(char a[], char b[])
{
while(*a)
{
if((*(a+1)==' '||*(a+1)=='\0')&& *a!=' ')
{
*b++=*a;
}
a++;
}
*b='\0';
}方法二：
void fun(char a[], char b[])
{
int i,j = 0;
for ( i = 0; a[i]!='\0'; i++)
{
if (a[i] != ' ' && (a[i+1]=='\0' || a[i + 1] == ' '))
b[j++] = a[i];
}
b[j] = '\0';
}1-2 数组去重
编写函数fun，该函数的功能是:删除一维数组中所有相同的数，使之只剩一个。数组中的数已按由小到大的顺序排列，函数返回删除后数组中数据的个数。
例如，若—维数组中的数据是:2 2 2 3 4 4 5 6 6 6 6 7 7 8 9 9 10 10 10删除后，数组中的内容应该是:2 3 4 5 6 7 8 9 10
int fun(int a[], int n)
{
int i,j;
for(i=0,j=1;j<n;j++)
{
if(a[i]!=a[j]) a[++i]=a[j];//j位置的元素与前一个i的元素不相等，则排在位置i的后面(++i)
}
return ++i;//由于i代表的数组a最后一个元素的索引值，而数组元素个数=最后一个元素索引值+1
}批注：
（1）for(循环变量赋初值；循环条件；循环变量增值）循环变量赋初值表达式可多个，用逗号“,"隔开。只执行一次。
循环循环变量增值表达式可多个，用逗号“,"隔开。用于调整循环。
循环条件使用逻辑表达式。
（2）区分a[++i]=a[j];与a[i++]=a[j];
当i初始值为0时，a[++i]=a[j]意味着a[j]赋值给a[1]，后面的赋值同理i先自增再赋值
当i初始值为0时，a[i++]=a[j]意味着a[j]赋值给a[0], 后面的赋值同理i先赋值再自增
1-3 元素转换
编写一个函数fun，它的功能是:将ss所指字符串中所有下标为奇数位置的字母转换为大写(若该位置上不是字母，则不转换)。
例如，若输入"abc4Efg"，则应输出"aBc4EFg"。
#include <string.h>
void fun( char *ss )
{
int i;
for(i=0;i<strlen(ss);i++)
{
if(i%2==1&&'a'<=ss[i]&&ss[i]<='z')
ss[i]-=32;
}
}批注：小写字母=对应大写字母+32；例如：'a'='A'+32。若忘记这个数量关系，可以在程序中通过printf("%d",'a'-'A');来得到。
【同类型题1】请编写函数fun，其功能是:将形参数组x中的偶数下标位置元素用2求余，奇数下标位置元素用3求余，用求余的结果更新数组原有位置处的元素。函数形参n是数组中的元素个数。
例如:当数组x内容为11,24,16,79,60,2，则程序的输出结果是:1,0,0,1,0,2,
void fun(int x[], int n)
{
int i;
for(i=0;i<n;i++)
{
if(i%2==0)x[i]=x[i]%2;//偶数下标位置元素用2求余的结果来代替
else x[i]=x[i]%3;//奇数下标下标位置元素用3求余的结果来代替
}
}【同类型题2】请编写函数fun，其功能是将形参s所指的字符串中的数字字符转换为—个整数并返回。形参s所指的字符串中的第一个字符可以为“+”或“-”，字符串中可以包含字母或数字，当碰到第一个字母时，转换过程结束。
例如:当s所指的字符串为“-123”时，返回值为-123;当s所指的字符串为“123”时，返回值为123。
int fun(char *s)
{
int n=0,flag=1;
if(*s=='-')
{
flag=-1;
s++; //指针后移
}
else if(*s=='+')
{
s++;
}
while(*s>='0'&&*s<='9')//数字字符
{
n=n*10+(*s-'0'); //字符转整数
s++;
}
return n*flag;
}1-4 移动字符
fun的功能是:移动字符串中的内容，移动的规则是把第1~m个字符，平移到字符串的最后，把第m + 1到最后的字符移到字符串的前部。【前移m个字符】
例如，字符串中原有的内容为"ABCDEFGHIJK"，m的值为3，移动后，字符串中的内容应该是"DEFGHIJKABC"。
void fun (char *w,int m)
{
char a;//用于存储每次移动前的首字符
int i,j;
for(i=0;i<m;i++)//移动m次
{
a=w[0];//保存每次移动前的首字符
for(j=1;j<strlen(w);j++)
{
w[j-1]=w[j];//元素前移
}
w[j-1]=a;//将移动前的首字符赋值给移动后的最后位置
}
}批注：退出内循环时，最后一个元素位置为j-1,休止符位置为j
【同类型题1】编写函数fun,函数的功能是:移动一维数组中的内容，若数组中有n个整数，要求把下标从0~p(含p,p小于等于n-1)的数组元素平移到数组的最后。例如,—维数组中的原始内容: 1,2,3.4,5,6,7,8,9,10;p的值为3。移动后，一维数组中的内容应为:5,6,7,8,9,10,1,2,3.4。
void fun(int *w, int p, int n)
{
int i,j,t;
for(i=0;i<=p;i++)
{
t=w[0];
for(j=1;j<n;j++)
{
w[j-1]=w[j];
}
w[j-1]=t;
}
}1-5 计数
编写函数fun，该函数的功能是:统计各年龄段的人数。N个年龄通过调用随机函数获得，并放入主函数的age数组中。要求函数把0～9岁年龄段的人数放在d[0]中，把10~19岁年龄段的人数放在d[1]中，把20~29岁年龄段的人数放在d[2]中，依此类推，把100岁(含100岁)以上年龄的人数都放在d[10]中。结果在主函数中输出。
# define N 50
# define M 11 // int age[N], i, d[M];
void fun(int *a, int *b) // fun( age, d);
{
int i;
for(i=0;i<M;i++)//数组b初始化，M个年龄组
{
b[i]=0; //b[0]~b[10]
}
for(i=0;i<N;i++)//N个年龄
{
if(a[i]>100) b[10]++; //年龄大于100的放入b[10]，由于年龄大于100进行a[i]/10可能会超出b数组的长度
else b[a[i]/10]++; //其余年龄的年龄组序号=年龄/10
}
}
批注：
(1)计数数组记得初始化！否则会报错！
(2)由于年龄大于100进行a[i]/10可能会超出b数组的长度，也会报错！
【同类型题1】在此程序中，编写函数fun,该函数的功能是:统计一行字符串中单词的个数，作为函数值返回。字符串在主函数中输入，规定所有单词由小写字母组成，单词之间有若千个空格隔开，一行的开始没有空格。
int fun( char *s)
{
int i,n=0;
for(i=0;i<strlen(s);i++)
{
if(s[i]!=' '&&(s[i+1]==' '||s[i+1]=='\0'))//把每个单词看成一个整体，如果该单词不是空格且后面不是空格或休止符，则算一个单词
{
n++;
}
}
return n;//返回单词个数
}【同类型题2】请编写函数fun，其功能是:找出用1、2、3、4四个数字，能组成多少个互不相同且无重复数字的三位数，然后把这些三位数按从小到大的顺序依次存入相应的数组xxx中，符合条件的个数由函数值返回。
int fun(int xxx[])
{
int i,j=0,a,b,c;
for(i=123;i<=432;i++)
{
a=i/100;//百位数
b=i/10%10;//十位数
c=i%10;//个位数
if(a!=b&&b!=c&&c!=a&&a>0&&a<5&&b>0&&b<5&&c>0&&c<5)//互不相等，且a=[1,4],b=[1,4],c=[1,4]
{
xxx[j++]=i;
}
}
return j;
【同类型题3】请编写函数fun，其功能是:从一个整数数组中，统计出有重复数字数的个数存于m中,m值由函数值返回。***
例如:2430,3001,1798,199,498,277,229,851,369,1146其中如:3001中有重复的数字0
输出: Total Num=5
方法一：
int fun(int a[], int n)
{
int i,j,num=0,flag=0;//num用于计数，flag用来判断数字是否重复
for(i=0;i<n;i++)
{
int b[11]={0};//辅助计数数组初始化，每记录一个数，就重新初始化一次，注意！！！
while(a[i])//依次记录各个位数的数字（对应位置加一）
{
b[a[i]%10]++;
a[i]=a[i]/10;
}
b[10]='\0';//计数数组赋休止符
for(j=0;j<10;j++)
{
if(b[j]>1) flag=1;//b[j]>1意味有重复数字出现
}
if(flag==1)
{
num++;//个数加一
flag=0;//对flag重新赋值为0，方便判断下一个数是否有重复数字，易错！！！
}
}
return num;
}方法二：
int fun(int a[], int n)
{
int j,k,s,m, b[10],i=0,sum=0,flag=0;
for(;i<n;i++)
{
j=0;//数组b重新赋值
while(a[i])//把数字的各个位数依次放入数组b中
{
b[j++]=a[i]%10;
a[i]=a[i]/10;
}
for(k=0;k<j;k++)//对数组b进行比较操作
{
s=b[k];//当前这个数字和后面所有数字依次比较
for(m=k+1;m<j;m++)
if(s==b[m]) flag=1;
}
if(flag==1)
{
sum++;
flag=0;//flag标志重新赋值为0，继续判断下一个数
}
}
return sum;
}【同类型题4】请编写函数fun(char*sp,int *ct)，其功能是，对传给sp的字符串，分别统计两个相连字母“ea”, “ou”和“iu°出现的次数(不能使用函数strstr（）)，并将统计结果存入ct所指数组中。
例如:若字符串的内容为"abeaeafeeaoukgdoouuoiouifwieeotiu"，则运行结果为:3,3,1。
方法一：
void fun(char*sp ,int *ct)
{
char *p1=sp,*p2=sp,*p3=sp;
ct[0]=0;ct[1]=0;ct[2]=0;//计数数组初始化
while(*p1)//分组统计
{
if(*p1=='e' &&*(p1+1)=='a'){ct[0]+=1;}
p1++;
}
while(*p2)
{
if(*p2=='o' &&*(p2+1)=='u'){ct[1]+=1;}
p2++;
}
while(*p3)
{
if(*p3=='i' &&*(p3+1)=='u'){ct[2]+=1;}
p3++;
}
}方法二：
void fun(char*sp ,int *ct)
{
int i;
for (i = 0; i < 3; i++)//计数数组初始化
{
ct[i] = 0;
}
for (i = 0; sp[i]!='\0'; i++)//分三种情况统计
{
if (sp[i] == 'e' && sp[i+1] == 'a')
{
ct[0]++;
}
else if (sp[i] == 'o' && sp[i+1] == 'u')
{
ct[1]++;
}
else if (sp[i] == 'i' && sp[i+1] == 'u')
{
ct[2]++;
}
}
}批注：一般涉及对字符串中的字符的操作，可以使用指针，更为方便。
1-6 字符串分解
请编写函数fun，其功能是:编写函数char *fun(char * s0,char*s1,char *s2, char *s3)，要求实现:
将sO所指字符串分解成三个字符串，分别存入s1、s2、s3所指内存中。分解的方法是，s1、s2、s3从sO中依次顺序每隔3个字符取1个。
例如，sO为"abcdefghij"时，分解完成后，s1、s2、s3分别为:"adgj". "beh"、"cfi。
void fun(char * s0,char *s1,char *s2, char *s3)
{ //思路：分组进行赋值
int i,n1=0,n2=0,n3=0;
for(i=0;i<strlen(s0);i=i+3)
{
s1[n1++]=s0[i];
}
for(i=1;i<strlen(s0);i=i+3)
{
s2[n2++]=s0[i];
}
for(i=2;i<strlen(s0);i=i+3)
{
s3[n3++]=s0[i];
}
s1[n1]='\0';//注意设置休止符
s2[n2]='\0';
s3[n3]='\0';
}1-7 字符串合并
请编写函数fun，其功能是:将具有n个元素的形参数组x中的偶数依原顺序输出到字符数组str中，每个数字后面加—个小数点，并生成一个结果字符串str由函数返回。
例如，当数组x内容为1,4,19,82,61,2，输出结果是:4.82.2.
/* 函数int_to_str的功能是将参数n中的整数转换成字符串，整数转换成字符串 */
void int_to_str(int n,char *s)
{
sprintf(s,"%d",n);
}
char *fun(int x[], int n)
{
static char str[200],s[10];
int i;
*str = 0;
/* 请在这里填入你编写的代码*/
for(i=0;i<n;i++)
{
if(x[i]%2==0)//x[i]为偶数
{
int_to_str(x[i],s);//把x[i]转换成字符串，整数转换成字符串
strcat(str,s);//把s加在str的后边
strcat(str,".");//把小数点加在str的后边
}
}
return str;
}批注：常见字符串函数#include <string.h>
（1）strcat函数用于字符串的连接。strcat（str1,str2):把str2加在str1的后边。
注意：strcat(str,".");是双引号，strcat是对两个字符串进行操作。
（2）strcpy函数用于字符串的复制。strcpy(str1,str2):将str2复制到(覆盖)str1。可用于字符串的初始化。
（3）strcmp函数用于字符串的比较。strcmp(str1,str2):自左向右依次比较str1和str2中的字符的ASCII码，直到遇到不同的字符或休止符为止。
strcmp(str1,str2)的三种结果：
- 0：str1==str2
- 正数：str1>str2
- 负数：str1<str2
题型二：数学问题
2-1 长整型
函数fun的功能是:将a、b中的两个正整数合并形成一个新的整数放在c中。合并的方式是:将a中的十位和个位数依次放在变量c的十位和千位上， b中的十位和个位数依次放在变量c的个位和百位上。
例如，当a=45, b=12。调用该函数后，c=5241。
void fun(int a, int b, long *c)
{
*c=(a/10)*10+(a%10)*1000+(b/10)+(b%10)*100;
}批注：
（1）得到a的十位数:a/10; 得到a的个位数:a%10;
（2）long *c表示指针变量c所指向的内存地址存放long类型的数据，c为指针变量名，表示指针变量所指向的内存地址，*c是指针所指向的地址所存放的内容。
//&取地址符号，%p输出地址的格式符
int i=1;
int *p=&i; //使一级指针p指向i的内存地址
printf("%p",p);//输出000000000062FE14
printf("\n%p",&i); //000000000062FE14
printf("\n%d",*p); //输出1，*p表示p指向的内存地址所存放的内容
printf("\n%d",i); //输出1
int **P=&p; //使二级指针P指向p的内存地址
printf("\n%p",*P); //输出000000000062FE14
printf("\n%p",&p); //输出000000000062FE08
printf("\n%p",&*P); //输出000000000062FE08
printf("\n%d",**P); //输出1
printf("\n%d",*P); //输出6487572
printf("\n%d",p); //输出6487572
【同类型题1】编写函数fun，其功能是:将a、b中的两个两位正整数合并成一个新的整数放在c中。合并的方式是:将a中的十位和个位数依次放在变量c的百位和个位上，b中的十位和个位数依次放在变量c的十位和千位上。
例如，当a=45,b=12，调用该函数后c =2415。
void fun(int a, int b, long *c)
{
*c=(a/10)*100+(a%10)+(b/10)*10+(b%10)*1000;
}【同类型题2】编一个函数double fun(double h)，该函数的功能是:使变量h中的值保留两位小数，并对第三位进行四舍五入(规定h中的值为正数)。
例如，若h值为1234.567，则函数返回1234.570000;若h值为1234.564，则函数返回1234.560000。
double fun ( double h )
{
long a=(h*1000+5)/10; //1234.567 ->1234567 ->1234572 -> 123457 ->
return a*0.01; // 1234.570000，将长整型转浮点型
}批注：
（1）long int 取值范围：-2147483648 ~ 2147483647
unsigned long int 取值范围：0 ~ 4294967295
2-2 平均数
在此程序中，m个人的成绩存放在score数组中，请编写函数fun,它的功能是:将低于平
均分的人数作为函数值返回，将低于平均分的分数放在below所指的数组中。
例如，当score数组中的数据为10、20、 30、40、50、60、 70、80、90时，函数返回的人数应该是4，below中的数据应为10、20、30、 40。
int fun(int score[], int m, int below[])
{
int i,n=0;
double sum=0.0;
for (i = 0 ; i < m ; i++)//计算总分
{
sum+=score[i];
}
for (i = 0 ; i < m ; i++)
{
if(score[i]<sum/m)//若小于平均分则放入below数组
{
below[n++]=score[i];
}
}
below[n]='\0';
return n;
}【同类型题1】在此程序中，学生的记录由学号和成绩组成。N名学生的数据已放入主函数中的结构体数组s中，请编写函数fun，其功能是〉把高于等于平均分的学生数据放在b所指的数组中，高于等于平均分的学生人数通过形参n传回，平均分通过函数值返回。
double fun( STREC *a, STREC *b, int *n )
{
int i,k=0;//k用于记录分数>=平均分的人数
double sum=0.0;
for(i=0;i<N;i++)//求分数总和
{
sum=sum+a[i].s;
}
for(i=0;i<N;i++)//将分数>=平均分的人存放到数组b
{
if(a[i].s>=sum/N) b[k++]=a[i];
}
*n=k;//将分数>=平均分的人数通过n返回
return sum/N;//返回平均分
} 【同类型题2】请编写函数fun，其功能是:在一个含有11个四位数的数组中，统计出这些数的奇数、偶数个数，然后计算出个数多的那些数的算术平均值并由函数返回，个数通过yy传回。
例如，若11个数据为:
1101,1202,1303,1404,1505,2611,2712,2813,2914,3202,4222则输出: yy=6, pjz=2609.33
double fun( int xx[], int *yy )
{
int i,n1=0,n2=0;
double sum1=0.0,sum2=0.0;//函数要求返回double 型
for(i=0;i<N;i++)
{
if(xx[i]%2==0) //偶数
{
n1++; //计数
sum1=sum1+xx[i]; //求和
}
else
{
n2++;
sum2=sum2+xx[i];
}
}
if(n1>n2) //若偶数个数多于奇数个数
{
*yy=n1; //通过yy返回偶数个数
return sum1/n1; //返回平均值
}
else //否则返回奇数个数，所有奇数的平均值
{
*yy=n2;
return sum2/n2;
}
}2-3 除数
编写函数void fun (int x, int ppD, int *n),它的功能是:求出能整除x且不是偶数的各整数，并按从小到大的顺序放在pp所指的数组中，这些除数的个数通过形参n返回。
例如，若x中的值为30，则有4个数符合要求，它们是1、3、5、15。
void fun ( int x, int pp[], int *n )
{
int i,j=0;
for(i=1;i<x;i++)//i的除数范围[1,i-1]
{
if(x%i==0&&i%2==1) pp[j++]=i;
}
pp[j]='\0';
*n=j;
}批注：也可以通过改变i的步长来排除偶数除数for(i=1;i<x;i=i+2)
若i+2，则i不会发生变化！i=i+2才能让i值发生变化。
【同类型题1】请编写函数fun，其功能是:统计出x所指数组中能被e整除的所有元素，这些元素的和通过函数值返回主函数，元素个数通过形参num返回主函数。x所指数组的元素个数通过形参n传入。
例如，当数组x内容为1,9,8,6,12，整数e内容为3时，输出结果应该是:sum=27,num=3
int fun(int x[], int n, int e, int *num)
{
int i,sum=0,k=0;
for(i=0;i<n;i++)
{
if(x[i]%e==0) //数组x中可以被e整除的数
{
sum=sum+x[i];//求和
k++;//个数+1
}
}
*num=k;//通过num返回数组x中可以被e整除的数的个数
return sum;
}批注： 记录个数也可以通过：
*num=0;//赋初值
for(i=0;i<n;i++)
{
if(x[i]%e==0) //数组x中可以被e整除的数
{
(*num)++;
}
}
【同类型题2】请编写函数fun，其功能是∶统计出x所指数组中能被e整除的元素个数，通过函数值返回主函数;同时,计算不能被e整除的元素之和,放到形参sum所指的存储单元中。
例如，当数组x内容为1,7,8,6,10,15,11,13,29,31，整数e内容为3时,输出结果应该是:n=2.sum=110
int fun(int x[], int e, int *sum)//返回可以被e整除的个数，sum返回不能被e整除的数之和
{
int i,n=0;
*sum=0;
for(i=0;i<N;i++)
{
if(x[i]%e==0)
{
n++;
}
else
{
*sum+=x[i];
}
}
return n;//返回可以被e整除的个数
}2-4 特别的数
请编写函数fun，其功能是:给定一个整数n (n<10000)，如果n加上100后是一个完全平方数(所谓“完全平方数”，就是开方后的结果是整数的数)，并且n加上268也是一个完全平方数，则函数值返回1，否则返回0。
int fun(long n)
{
int a,b;
a=(int) sqrt((double) n+100);
b=(int) sqrt((double) n+268);
if(a==sqrt((double) n+100)&&b==sqrt((double) n+268)) return 1;//判断开方后是否为整数，若左式==右式，则代表开方后为整数
else return 0;
}
批注：
（1）求开方 ：double sqrt((double) n)
（2）强制转换：a=(int) sqrt((double) n+100);
涉及强制转换的例题：求双精度aa的整数部分和小数部分
void fun( double aa, int *x, double *y )
{
*x=(int)aa;//整数部分
*y=aa-*x;//小数部分}
【同类型题1】请编写函数fun，其功能是:求n (n<10000)以内的所有四叶玫瑰数并逐个存放到result所指的数组中，四叶玫瑰数的个数作为函数值返回。
如果一个4位正整数等于其各个数字的4次方之和，则称该数为四叶玫瑰数。
例如，1634 = 1*1*1*1+6*6*6*6＋ 3*3*3*3＋4*4*4*4，因此1634就是一个四叶玫瑰数。
int fun(int n, int result[])//n = fun(9999, result);
{
int i,a,b,c,d,j=0;
for(i=1000;i<n;i++)//i为四位正整数数
{
a=i/1000;//千位数
b=i/100%10;//百位数
c=i/10%10;//十位数
d=i%10;//个位数
if(i==a*a*a*a+b*b*b*b+c*c*c*c+d*d*d*d)//判断是否是四叶玫瑰数
{
result[j++]=i;
}
}
result[j]='\0';
return j;//数组result的长度就是四叶玫瑰数的个数
}
【同类型题3】有一个很奇怪的车牌号，它是一个4位十进制数，是某一个数的平方数，且这4个数字从右至左一个比一个小。程序的功能是把这个车牌号找出来。请编写函数fun，其功能是:将一个4位数的每一位数分离出来，并依次存放在结构体变量成员中，通过函数值返回给主函数。
例如，一个4位数n为2579，则应把2放在res.m3中，把5放在res.m2中，把7放在res.m1中，把9放在res.m0中。
程序正确运行后的输出结果是:No. is 1369
struct BITS { int m3, m2, m1, m0; };//千位，百位，十位，个位
struct BITS fun(int n)//对结构体进行赋值
{
struct BITS res;
/* 在这里将函数代码补充完整 */
res.m3=n/1000; //千位
res.m2=n/100%10; //百位
res.m1=n/10%10; //十位
res.m0=n%10; //个位
return res;
}
main( )//主函数
{ struct BITS a;
int i=0, n=0;
for (i=32; i<100; i++)
{ n = i * i; //平方数
a= fun(n);
if (a.m3 < a.m2 && a.m2 < a.m1 && a.m1 < a.m0) //判断车牌号
printf("No. is %d\n", n);
}
}2-5 素数
编写-个函数void fun(int m,int k,int xx[]),该函数的功能是:将大于整数m且紧靠m的k个素数存入xx所指的数组中。
例如，若输入17 5,则应输出19、23、29、31、37。
void fun(int m,int k,int xx[])
{
int i,j,n=0;
for(i=m+1;n<k;i++)//大于m的k个素数，所以要循环k次
{
for(j=2;j<i;j++)//i的除数范围[2,i-1]
{
if(i%j==0)break;//非素数i：i可以被j整除，就结束循环，此时i<j
}
if(j>=i) xx[n++]=i;//素数：不可以被j整除，此时j>=i
}//若改成if(j<i) xx[n++]=i; 则xx里的非素数为18 20 21 22 24
xx[n]='\0';
}批注：用循环判断素数i，若能被j整除则中断循环，此时仍符合循环条件i<j【非素数】，则意味着不能被整除时j>=i【素数】
【同类型题1】找出小于或等于lim的素数存入aa数组中并统计素数个数
int fun(int lim, int aa[MAX])
{
/* 以下代码仅供参考 */
int i,j,k=0;
/* 其中变量k用于统计素数个数 */
for(i=2;i<=lim;i++)
{
/* 以下找出小于或等于lim的素数存入aa数组中并统计素数个数 */
for(j=2;j<i;j++)
{
if(i%j==0) break;
}
if(j>=i) aa[k++]=i;
}
return k;
}【同类型题2】编写函数fun，该函数的功能是:判断字符串是否为回文，若是，则函数返回1，主函数中输出YES"，否则返回o，主函数中输出"NO"。回文是指顺读和倒读都—样的字符串。
例如，字符串LEVEL是回文，而字符串123312就不是回文。
int fun(char *str)
{
int i,j;
int frag=0;
for(i=0;i<=strlen(str)/2;i++)
{ //第一个和倒数第一个比较，依次比较（字符串长度/2）次
if(str[i]!=str[strlen(str)-1-i]) break; //当不是回文时，i<=strlen(str)/2
}
if(i>strlen(str)/2) frag=1;//不符合for循环的循环条件就是回文，即i>strlen(str)/2
return frag;
}【同类型题3】根据哥德巴赫猜想，任意一个大偶数都可以分解为两个素数之和。但许多偶数分解为两个素数之和并不是唯一的。
请编写函数fun，其功能是:求1000(不包括1000)以内的所有恰好能分解成10组两个素数之和(5+109和109+5被认为是同一组)的偶数，并依次存入数组a中并在屏幕上打印出来，打印时每个数单独一行，符合条件的个数通过函数值返回。
例如，114=5+109=7+107=11+103=13+101=17+97=31+83=41+73=43+71=47+67=53+61
114恰好可以分解为10组素数之和，因此114是我们要找的偶数。
而116=3+113=7+109=13+103=19+97=37+79=43+73
120=7+113=11+109=13+107=17+103=19+101=23+97=31+89=37+83=41+79 =47+73=53+67=59+61116可以分解为6组素数之和，120可以分解为12组素数之和，因此116和120都不是我们要找的偶数。
函数prime用来判断—个数n是否为素数，是则返回1，否则返回0。
int prime(int n)
{ int k,flag=1;
for (k=2; k<=(int)sqrt((double)n); k++)
if (n%k == 0)
flag=0;
return flag;
}
int fun(int m, int a[])
{
int k, s, count, i=0;
for(k=6; k<=m; k+=2)
{ count = 0;
/* 请在此处填写代码 */
for(s=2;s<=k/2;s++)//把k拆分两个素数之和，注意s的范围[2，k/2],注意从2开始，1不是素数！
{
if(prime(s)==1&&prime(k-s)==1) // k分为一组素数之和k=s+(k-s)
count++;
}
if (count == 10) {
printf("%d\n", k);
a[i++] = k;
}
}
return i;
} 
【同类型题4】请编写函数fun，其功能是:验证参数n是否可以分解成2个素数相乘，是则返回1，否则返回0，并通过指针变量x、y返回分解后的2个素数值，要求*x<*y。主程序中将打印出分解结果。
例如，111= 3*37，当函数fun的参数n为111时，可以分解为2个素数（(3和37)的乘积，函数返回值为1。
补充：
int prime(int m)//判断m是否是素数
{
int k,flag=1;
for(k=2;k<(int)sqrt((double)m);k++)
if(m%k==0)
flag=0;
return flag;
}
int fun(int n,int *x,int *y)
{
int k,flag=0;int t;
for(k=2;k<=(int)sqrt((double) n);k++)//注意k的范围，[2,√n]
{
if(n%k==0&&prime(k)==1&&prime(n/k)==1)//n可以被因子k整除，n由两个素数相乘所得
{
*x=k;
*y=n/k;
flag=1;
}
}
return flag;
}
2-6 幂
结构体struct mpow两个成员的意义是:a为幂的底，t为幂的指数。
请编写函数fun，其功能是:计算出x所指数组中n个幂数之和并返回。
例如，当结构体数组用如此数据12,0,9,2,23,1,7,2初始化时，程序的输出结果应该是:sum=154.000000
double fun(struct mpow *x,int n)
{
int i,j,k;
double sum=0.0;
for(i=0;i<n;i++)
{
k=1;//每计算一个幂数，k就初始化一次
for(j=0;j<x[i].t;j++)//计算幂，相当于pow(x[i].a,x[i].t);x[i].a的x[i].t次幂
{
k*=x[i].a;//整数*整型=整型
}
sum=sum+k;//双精度浮点型+整型=双精度浮点型
}
return sum;
}2-7 最值
请编写函数fun，该函数的功能是:找出成绩最高的学生记录，通过形参返回主函数(规定只有一个最高分)。
补充：
#define N 10
typedef struct ss /*定义结构体*/
{ char num[10];
int s;
} STU;STU a[N]={{ "A01",81},{ "A02",89},{ "A03",66},{ "A04",87},{ "A05",77},
{ "A06",90},{ "A07",79},{ "A08",61},{ "A09",80},{ "A10",71}},m;fun(a,&m);
void fun(STU a[], STU *s)
{
int i;
*s=a[0];//赋初值
for(i=1;i<N;i++)
{
if(s->s<a[i].s)//找最高分
*s=a[i];
}
}批注：结构体数组用.使用结构体成员，结构体指针用->使用结构体成员
【同类型题1】已知学生的记录由学号和学习成绩构成，N名学生的数据已存入a结构体数组中。请编写函数fun，该函数的功能是:找出成绩最低的学生记录，通过形参返回主函数(规定只有一个最低分)。已给出函数的首部，请完成该函数。
void fun( STU a[], STU *s )
{
int i;
*s=a[0];
for(i=1;i<N;i++)
{
if(s->s>a[i].s) *s=a[i];//找最低分
}
}【同类型题2】编写一个函数，其功能是:从传入的num个字符串中找出最长的一个字符串，并通过形参指针max传回该串地址(每个字符串都用****作为结束输入的标识，最后只输出****则停止输入)。
char *fun(char (*a)[81], int num, char *max)
{
int i;
max=a[0];//赋初值
for(i=0;i<num;i++)
{
if(strlen(max)<strlen(a[i])) max=a[i]; //由于#include<string.h>，所以可以引用strlen()来计算字符串长度
}
return max;
}【同类型题3】在此程序中，N名学生的成绩已在主函数中放入一个带有头节点的链表结构中，h指向链表的头节点。请编写函数fun，其功能是:找出学生的最高分，并由函数值返回。
double fun( STREC *h )
{
double max=h->s;//给最高分赋初值
h=h->next;//使指针指向下一个结点，也可以忽略这步，直接开始遍历链表
while(h)//如果指针不为空，开始遍历链表
{
if(max<h->s) max=h->s;//更新最大值
else h=h->next;//否则继续遍历
}
return max;
}【同类型题4】在整数数组中，如果一个数的出现次数和它的数值大小相等，我们就称这个数为“幸运数”，请编写函数fun，其功能是:从给定的长度为n(ns1000)的整数数组a中，找出其中最大的幸运数并返回;如果该数组中不存在幸运数，则返回-1。
例如:当a数组长度为6，元素值为:1,3,3,3,2,2时，应返回最大幸运数3。
当a数组长度为5，元素值为:2,3,2,3,2时，应返回-1。
int fun(int a[], int n)
{ int c[1000]={0}; /* 计数器，每个数的出现次数 */
int t[1000]; /* 去掉重复后的整数系列 */
int k=0,i,j, lucky;
for (i=0; i<n; i++)
{
for (j=0;j<k;j++)
if (a[i] == t[j])
{
c[j]++;
break;
}
if (j>=k)
{ t[k] = a[i];
c[k] = 1;
k++;
}
}
lucky = -1;
/* 请在此处填入必要的代码，找出最大幸运数 */
for (i=0; i<n; i++)
{
if(c[i]==t[i]&&t[i]>lucky)lucky=t[i];//c为计数数组，t为去重数组
}
return lucky;
} 【同类型题5】请编写函数fun,其功能是:把指定分数范围内的学生数据放在b所指的数组中,分数范围内的学生人数由函数值返回。
例如,输入的分数是60、69,则应当把分数在60~69的学生数据输出，包含60分和69分的学生数据。主函数中把60放在low中,把69放在heigh中。
int fun( STREC *a,STREC *b,int l, int h )// n=fun( s,h,low,heigh );
{
int i,k=0;
for(i=0;i<N;i++)
{
if(a[i].s>=l&&a[i].s<=h)
{
b[k++]=a[i];
}
}
return k;
}【同类型题6】请编写函数void fun(int*dp, int n, int upordown)，其功能是，找出dp所指数组中的最小或最大值并与其第1个元素交换。形参n为元素的个数，形参upordown为查找标志:值为0时找最小值;值为1时找最大值。
void fun (int *dp,int n,int upordown)
{
int i,t;
int max=0,min=0;
for(i=1;i<n;i++)//找最大值元素的位置
{
if(dp[max]<dp[i])max=i;
}
for(i=0;i<n;i++)//找最小值元素的位置
{
if(dp[min]>dp[i])min=i;
}
if(upordown==0)//若标志==0，则最小值元素与第一个元素互换位置
{
t=dp[0];
dp[0]=dp[min];
dp[min]=t;
}
else//若标志==1，则最大值元素与第一个元素互换位置
{
t=dp[0];
dp[0]=dp[max];
dp[max]=t;
}
}【同类型题7】编写一个函数int fun(int *s, int t, int *k)，用来求出数组的最大元素在数组中的下标并存放在k所指向的存储单元中。
例如，输入如下整数:
876675896 101301401980 431451777则输出结果为6,980。
int fun(int *s, int t, int *k)//k指向数组s中的最大值的下标
{
int i;*k=0;
for(i=1;i<t;i++)
{
if(s[*k]<s[i]) *k=i;
}
return s[*k];//返回最大值
}2-8 排序
在此程序中，学生的记录出学号和成绩组成，N名学生的数据已放入主函数中的结构体数组s中，请编写函数fun，其功能是:按分数降序排列学生的记录，高分在前，低分在后。
#define N 16
typedef struct
{ char num[10];
int s;
} STREC;
void fun( STREC a[] )//冒泡排序
{
int i,j;STREC p;
for(i=1;i<N;i++)//N个数要比较N-1次
{
for(j=0;j<N-1;j++)//每个数又要比较N-1次
{
if(a[i].s>a[j].s)//若当前元素成绩小于后一个元素成绩就交换，实现降序排列。
{ //若升序输出，则改>为<
p=a[i];
a[i]=a[j];
a[j]=p;
}
}
}
}void fun( STREC a[] )//插入排序
{
int i,j;STREC p;
for(i=1;i<N;i++)//N个数要比较N-1次
{
p=a[i];//暂时保存元素
for(j=i-1;j>=0&&p.s>a[j].s;j--)//从后往前找元素的插入位置
{
a[j+1]=a[j];//后移
}
a[j+1]=p;//插入元素
}
}void fun( STREC a[] )//选择排序
{
int i,j,max;STREC p;
for(i=0;i<N-1;i++)
{
max=i;//定义当前位置为最大值
for(j=i+1;j<N;j++)
{
if(a[max].s<a[j].s) max=j;//更新最大值位置
}
if(max!=i)//和之前定义最大值位置不一致就交换
{
p=a[i];
a[i]=a[max];
a[max]=p;
}
}
}2-9 矩阵
在此程序中，定义了N×N的二维数组，并在主函数中自动赋值。请编写函数fun(int a][N]，int n)，该函数的功能是:使数组左下半三角元素中的值乘以n。
#define N 5
void fun(int a[ ][N], int n)
{
int i,j;
for(i=0;i<N;i++)
{
for(j=i;j<N;j++)
{
a[j][i]*=n;
}
}
}【同类型题1】使数组右上半三角元素中的值乘以m
void fun ( int a[][N], int m )
{
int i,j;
for(i=0;i<N;i++)
{
for(j=i;j<N;j++)
{
a[i][j]*=m;//右上元素a[i][j],左下元素是a[j][i]
}
}
}【同类型题2】程序中定义了N×N的二维数组，并已在主函数中赋初值。请编写函数fun，其功能是:将a所指数组主对角线上的元素分别乘以2;次对角线上的元素分别乘以3，依次放入指针p所指的数组中。计算过程中不得修改a所指数组中的数据。
void fun( int a[N][N],int *p)
{
int i,j=0;
for(i=0;i<N;i++)
{
p[j++]=a[i][i]*2;//主对角线*2
}
for(i=0;i<N;i++)
{
p[j++]=a[i][N-i-1]*3;//次对角线*3
}
}【同类型题3】在此程序中，定义了N×N的二维数组，并在主函数中自动赋值。请编写函数fun(int a][NJ)，该函数的功能是:将数组左下半三角元素中的值全部置成0。只需令 a[j][i]=0;
【同类型题4】实现矩阵的转置
void fun(int array[3][3])
{
int i,j,t;
for (i=0;i<3;i++)
{ for (j=i+1;j<3;j++) //右上和左下三角元素交换
{
t=array[i][j]; //array[i][j]表示列元素
array[i][j]=array[j][i]; //array[j][i]表示行元素
array[j][i]=t;
}
}
}
【同类型题5】实现矩阵的转置
void change(int p[][N],int n)
{
int i,j,t;
for(i=0;i<N;i++)
{
for(j=i;j<N;j++)//或者for(j=i+1;j<N;j++)，两两交换
{
t=p[i][j];
p[i][j]=p[j][i];
p[j][i]=t;
}
}
}【同类型题6】编写函数fun，该函数的功能是:将M行N列的二维数组中的数据，按行的顺序依次放到一维数组中，一维数组中数据的个数存放在形参n所指的存储单元中。
void fun(int (*s)[10], int *b, int *n, int mm, int nn)//mm为行数，nn为列数
{
int i,j,k=0;
for(i=0;i<mm;i++)
{
for(j=0;j<nn;j++)
{
b[k++]=s[i][j];//按行存储，若按列存储则是b[k++]=s[j][i];
}
}
*n=k;//通过指针*n返回数组b的元素个数
}【同类型7】编写函数fun，该函数的功能是:将M行N列的二维数组中的字符数据，按列的顺序依次放到—个字符串中。
#define M 3//行数
#define N 4//列数
void fun(char s[][N], char *b)
{
int i,j,n=0;
for(i=0; i < N;i++) /* 请填写相应语句完成其功能 */
{
for(j=0;j<M;j++)
{
b[n++]=s[j][i];//按列存储
}
}
b[n]='\0';
}【同类型题8】编写函数fun，该函数的功能是:将放在字符串数组中的M个字符串(每串的长度不超过N)，按顺序合并组成一个新的字符串。
例如，若字符串数组中的M个字符串为(“AAAA”， "BBBBBBB"，“CC”}则合并后的字符串内容应该是“AAAABBB8BBBCC”,
void fun(char a[M][N], char *b)
{
/* 以下代码仅供参考 */
int i,j,k=0; *b=0;
for(i=0;i<M;i++)
{
for(j=0;a[i][j]!='\0';j++)
{
b[k++]=a[i][j];
}
}
b[k]='\0';
}【同类型题9】矩阵周边元素的平均值
double fun ( int w[][N] )
{
int i,j,n=0,sum=0;//n用于记录周边元素的个数，或者用N*N-(N-2)*(N-2)
for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
{
if(i==0||i==N-1||j==0||j==N-1)//周边元素为第一行、最后一行、第一列、最后一列
{
sum+=w[i][j];//周边元素求和
n++;
}
}
}
return sum*1.0/n;//返回double型的平均值
}2-10 多项式求和
#include <math.h>//pow(long double x,int y)的头文件
double fun(double x , int n)
{
int i;
double sum=1.0,s=1.0;//赋初值
for(i=1;i<=n;i++)
{
s*=i;//分母
sum+=pow(x,i)/s;//pow(long double x,int y)用于计算x的y次幂
}
return sum;
}批注：pow(long double x,int y)用于计算x的y次幂
【同类型题1】fun的功能是。根据以下公式求Π的值(要求精度0.0005，即某项小于0.0005时停止迭代)。
double fun ( double eps)
{
double sum=0.0,s=1.0;//sum算的是Π/2，从0.0开始求各项和
int n=1;
while(s>=eps)//当前这一项不小于eps则继续迭代
{
sum+=s;//各项求和
s=s*n/(2*n+1);//各项,如果是s*=n/(2*n+1);则运行报错，因为n为整数，(2*n+1)也是整数，所以二者的商为整数，这个结果在成*s结果就不精确了！
n++;
}
return sum*2;//由于sum算的是Π/2，则Π=sum*2;
}批注：
（1）也开始使用for循环来实现
for(n=1;s>=eps;n++)
{
sum+=s;
s=s*n/(2*n+1);
}（2）C语言中：整数/整数=整数； 浮点型/整数=浮点型；
【同类型题2】编写函数fun，其功能是:根据以下公式计算s，并计算结果作为函数值返回，n通过形参传入。
float fun(int n)
{
int i,s1=0; //s1为除数
float s=0.0; //返回值浮点型值s赋初值
for(i=1;i<=n;i++)
{
s1+=i; //修改除数，除数为整数之和
s+=1.0/s1; //求和，由于除数s1为整型，所以修改被除数为浮点型，以保证结果为浮点型
}
return s;
}【同类型题3】编写函数fun，其功能是∶根据以下公式求P的值，结果由函数值带回。m与n为两个正整数且要求m>n,
例如:m= 12,n=8时，运行结果为495.000000。
float fun(int m, int n)
{
float a=1.0,b=1.0,c=1.0;
int i;
for(i=1;i<=m;i++) //m的阶乘
{
a*=i;
}
for(i=1;i<=n;i++) //n的阶乘
{
b*=i;
}
for(i=1;i<=m-n;i++) //(m-n)的阶乘
{
c*=i;
}
return a/(b*c);
}【同类型题4】
double fun(int n)
{
int i;
double S=0.0;
for(i=1;i<=n;i++)
{
S=S+1.0/(i*(i+1)); //注意是1.0/(i*(i+1))，若是1/(i*(i+1))结果为0
}
return S;
}考试顺利，天天开心~
扫一扫
2756
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
