9 月全国计算机等级考试 | q=p+i; | p=j; |
二级C 语言上机题库100 | ||
/**found**/ | /**found**/ | |
套 | while(q>p) | p=i; |
（超级最新完整版） | 3 程序设计 | 3. 程序设计 |
提议拷贝岛U 盘使用word 编辑 | 学生统计由学号和成绩组成, N 名 | 请编写一个fun 函数, 它功效是: 求出1 |
菜单中查找和定位功效百分百 | 学生数据已在主函数中放入结构体数组s | 到m 之间（含m）能被7 或11 整除全部 |
（注意查找时输入文字不要是 | 中, 请编写了函数fun, 它功效是: 把指定 | 整数放在数组a 中, 经过n 返回这些数个 |
在考试题目中常常出现文字, | 分数范围内学生数据放在b 所指数组中, | 数。 |
比如第一套不要输入‘学生’两 | 分数范围内学生人数由函数值返回。 | void fun(int m,int *a,int *n) |
字查找要输入‘三门课成绩’这么 | int fun(STREC *a,STREC *b,int l,int h) | { |
正确度就高多了）最终祝大家全 | {int i,j=0; | int i; |
部能经过。 | for(i=0;i<N;i++) | *n=0; |
if((a[i].s>=1&&a[i].s<=h) | for(i=7;i<=m;i++) |
第一套
1. | 程序填空 | b[j++]=a[i]; | if((i%7==0)||(i%11==0)) |
return j; | a[(*n)++]=i; |
程序经过定义学生结构体数组,存放了
} }
若干个学生学号、姓名和三门课成绩。
第二套 第三套
函数fun功效是将存放学生数据结构体数
1. | 程序填空 | 1. 程序填空 |
组,根据姓名字典序（从小到大排序）。
给定程序中已建立一个带有头结 函数fun功效是:逆置数组元素是值。
请在程序下划线处填入正确内容并把下划
点单向链表,链表中各结点按数据域递增 比如:若a所指数组中数据依次为:1、2、
线删除,使程序得出正确结果。
有序连接。函数fun功效是:删除链表 3、4、5、6、7、8、9,则逆置后
第一处structstudent t;
中数据域值相同结点,使之只保留一个。 依次为:9、8、7、6、5、4、3、2、
第二处for(i=0;i<n-1;i++)
第一处free(q); 1。形参n给出数组中数组中数据个数。
第三处if(strcmp(a[i].name,a[j].name)>0)
2 | 程序修改 | 第二处 q=p->next; | 第一处 for(i=0;i<n/2;i++) |
第三处 q=q->next; | 第二处 a[i]=a[n-1-i]; |
给定程序MODI1.C中函数fun功效是:
2. 程序修改 第三处a[n-i-1]=t;
在p所指字符串中找出ASCII码值最大字
给定程序MODI1.C中函数fun功 2程序修改
符,将其放在第一个位置上;并将该字符
效是:用选择法对数组中n各元素按从小 给定程序MODI1.C中函数fun功
前原字符向上次序移动。
到大次序进行排序。 效是:将一个由八进制数字字符串组成字
/**found**/
/**found**/ 符串转换为和其面值相等十进制整数。
要求输入字符串最多只能包含5 位八进制 | 在带有头结点单向链表中, 查找数据域中 | 给定程序中, 函数fun 功效是: 计 | ||
数字字符。 | 值为ch 结点。找到后经过函数值返回该 | 算下式前n 项和作为函数值返回。比如: | ||
/**found**/ | 结点在链表中所处次序号: 若不存在值为 | 当形参n值为10 时, 函数返回: 9.6125588。 | ||
n=*p-‘0’; | ch 结点, 函数值返回0. | 第一处 s=0; | ||
/**found**/ | 第一处 while(p!=0) | 第二处 for(i=1;i<=n;i++) | ||
n=n*8+*p-‘0’; | 第二处if(p->data==ch)return n; | 第三处 s=s+(2.0*i-1)*(2.0*i+1)/(t*t); | ||
3. 程序设计 | 第三处 k=fun(head,ch); | 2. 程序修改 | ||
学生统计由学号和成绩组成, N 名 | 2. 程序修改 | 给定程序MODI1.C 中函数fun 功 | ||
学生数据已在主函数中放入结构体数组s | 给定程序MODI1.C 中函数fun 功 | 效是: 统计substr 所指字符串在str 所指字 | ||
中, 请编写了函数fun, 它功效是: 函数返 | 效是: 删除p 所指字符串全部空白字符（包 | 符串中出现伯次数。 | ||
回指定学号学生数据, 指定学生号在主函 | 含制表符、回车符及换行符）。输入字 | /**found**/ | ||
数中输入, 若没有找到指定学号, 在结构 | 符串时用‘#’结束输入。 | for(i=0;str[i];i++) | ||
体变量中给学号置空串, 给成绩置-1, 作 | /**found**/ | /**found**/ | ||
为函数值返回。 | （用于字符串比较函数是 | for(i=0,t=0;p[i];i++) | if(substr[k+1]==’\0’) | |
strcmp）。 | /**found**/ | 3. 程序设计 | ||
STREC fun(STREC*a,char *b) | c[t]=’\0’; | 请编写一个函数fun, 它功效是: | ||
{ | 3. 程序设计 | 依据以下公式求JI 值（要求满足精度 | ||
STREC c; | 请编写一个函数fun, 将ss 所指 | 0.0005, 即某项小于0.0005 时停止送代）: | ||
Int i; | 字符串中全部下标为奇数位置上字母转换 | 程序运行后, 假如输入精度为0.0005, 则 | ||
c.num[0]=’\0’; | 为大写（若该位置上不是字母, 则不转换）。 | 程序输出为3.14…。 | ||
c.s=-1; | void fun(char *ss) | double fun(double eps) | ||
for(i=0;i<N;i++) | { | { double s=1,t=1./3; | ||
if(strcmp(a[i].num,b)==0) | int i; | int n=1; | ||
{strcpy(c.num,a[i].num); | for(i=1;i<strlen(ss);i+=2) | while(t>=eps) | ||
c.s=a[i].s;break;} | {if(ss[i]>=’a’&&ss[i]<=’z’) | {s+=t;n++;t=t*n/(2.0*n+1) | ||
return c; | ss[i]-=32; | ;} | ||
} | } | return(s*2.0); | ||
第四套 | } | } | ||
1. | 程序填空 | 第五套 | 第六套 | |
给定程序中, 函数fun 功效是: | 1. 程序填空 | 1. 程序填空 | ||
给定程序中, 函数fun 功效是: 将 | 1. | 程序填空 | { *c=(b%10)*1000+(a/10)*100+(b/10)*10+ | |
形参s 所指定字符串中全部字母字符次序 | 程序经过定义学生结构体变量, | a%10; | ||
前移, 其它字母次序后移, 处理后字符串 | 存放了学生学号、姓名和三门课成绩。 | } | ||
首地址作为函数值返回。 | 函数fun功效是将形参a所指结构体变量s | 第八套 | ||
第一处 t[j]=s[i];j++; | 中数据进行修改, 并把a 中地址作为函数 | 1. 程序填空 | ||
第二处 for(i=0;i<k;i++) | 值返回主函数, 在主函数中输出修改后数 | 函数fun 功效是: 将形参观者工 | ||
t[j+i]=p[i]; | 据。 | 所指数组中前半部分元素中值和后半部分 | ||
第三处 t[j+k]=0; | 第一处 struct student * | 元素中值对换。 | 形参n 中存放数组中数据 | |
2. 程序修改 | fun(struct student*a) | 个数, 若n 为奇书, 则中间元素不动。 | ||
给定程序MODI1.C 中函数fun 功 | 第二处 for(i=0;i<3;i++) | 第一处 p=(n%2==0)? n/2:n/2+1; | ||
效是: 将s 所指字符串中最终一次出现和 | a->score[i]+=1; | 第二处 a[i]=a[p+i]; | ||
t1 所指字符串相同子串替换成t2 所指定字 | 第三处 return a; | 第三处 a[p+i]=t; | ||
符串, 所形成新串放在w 所指数组中。 | 2. 程序修改 | 2. 程序修改 | ||
在此处, 要求t1和t2所指字符串长度相同。 | 给定程序MODI1.C 中函数fun 功 | 给定程序MODI1.C 中函数fun 功 | ||
/**found**/ | 效是: 从N 个字符串中找出最长那个串, | 效是: 把主函数中输入三个数, 最大放在 | ||
while(*w) | 并将其地址作为函数值返回。各字符串 | a 中, 最小放在c 中, 中间放在b 中。 | ||
/**found**/ | 在主函数中输入, 并放在一个字符串数组 | /**found**/ | ||
if(*r==*p) | 中。 | float k; | ||
3. 程序设计 | /**found**/ | /**found**/ | ||
函数fun 功效是: 将s 所指字符串 | char *fun(char (*sq)[M]) | if(*a<*c) | ||
中ASCII 值为奇数字符删除, 串中剩下字 | /**found**/ | 3. 程序设计 | ||
符形成一个新串放在t 所指定数组中。 | return sp; | 学生统计由学号和成绩组成, N 名 | ||
void fun(char *s,char t[]) | 3. 程序设计 | 学生数据已在主函数中放入结构体数组s | ||
{ int i,j=0; | 函数fun 功效是: 将a、 b 中两位 | 中, 请编写了函数fun, 它功效是: 把分数 | ||
正整数合并形成一个新整数放在c 中。 | 最高学生数据放在b 所指数组中, 注意: | |||
for(i=0;i<strlen(s);i++)
合并方法是:将a中十位和个位依次放在 分数最高学生可能不止一个,函数返回分if(s[i]%2==0)t[j++]=s[i];
变量c百位和个位上,b中十位和个位数依 数最高学生人数。
t[j]=0;
intfun(STREC *a,STREC *b)次放在变量c十位和千位上。
}
#include<stdio.h> {
第七套
voidfun(int a,int b,long *c) inti,max=a[0].s,n=0;
for(i=1;i<N;i++) | 请编写函数fun, 函数功效是: 求 | 放在数组中。给定程序MODI1.C 中函数 | |
if(max<a[i].s)max=a[i].s; | 出二级数组周围元素之和, 作为函数值返 | fun 功效是: 删除数列中值为x 元素。 N | |
for(i=0;i<N;i++) | 回。二维数组中值在主函数中给予。 | 中存放是数列中元素个数。 | |
if(max==a[i].s)b[n++]=a[i]; | int fun(int a [M][N]) | /**found**/ | |
return n; | { | if(p==n) return-1’ | |
} | int tot=0,i,j; | /**found**/ | |
第九套 | for(i=0;i<N;i++) | a[i]=a[i+1]; | |
1. 程序填空 | { | 3. 程序设计 | |
给定程序中, 函数fun 功效是: 计 | tot +=a[0][i]; | 学生统计由学号和成绩组成, N 名 | |
算形参x 所指数组中N 个数平均值, （要 | tot +=a[M-1][i]; | 学生数据已在主函数中放入结构体数组s | |
求全部数均为正数）, 将所指数组中小于 | } | 中, 请编写了函数fun, 它功效是: 把分数 | |
平均值数据移至数据前部, 大于等于平均 | for(i=1;i<M-1;i++){ | 最低学生数据放在b 所指数组中, 注意: | |
数移至x 所指数组后部, 平均值作为函数 | tot +=a[i][0]; | 分数最低学生可能不止一个, 函数返回分 | |
值返回, 在主函数中输出平均值和移动后 | tot +=a[i][N-1]; | 数最低学生人数。 | |
数据。 | } | int fun(STREC *a,STREC *b) | |
第一处 for(i=0;i<N;i++) | return tot; | { | |
av+=x[i]/N | } | int i,j=0,min=a[0].s; | |
第二处 y[j]=x[i]; | 第十套 | for(i=0;i<N;i++) | |
x[i]=-1;j++;} | 1. | 程序填空 | { if(min>a[i].s){ |
第三处 i++; | 程序经过定义学生结构体变量, | j=0; | |
2. 程序修改 | 存放了学生学号、姓名和三门课成绩。 | b[j++]=a[i];min=a[i].s; | |
给定程序MODI1.C 中函数fun 功 | 函数fun 功效是将形参a 中数据进行修改, | } | |
效是: 统计字符串各元音字母（即: A、 | 把修改后数据作为函数值返回主函数进行 | else if(min==a[i].s) | |
E、 I、 O、 U）个数。注意字母不分 | 输出。 | b[j++]=a[i]; | |
大小写。 | 第一处 struct student | } | |
/**found**/ | fun(struct student a) | return j; | |
num[k]=0; | 第二处 strcpy(a.name,”LiSi”); | } | |
/**found**/ | 第三处 a.score[i]+=1; | 第十一套 | |
switch(*s) | 2 程序修改 | 1. 程序填空 | |
3. 程序设计 | 假定整数数列中数不反复, 并存 | 给定程序中, 函数fun 功效是: 计 | |
算形参x 所指数组中N 个数平均值, （要 | n+=2;} | #include <stdio.h> | |
求全部数均为正数）, 将所指数组中大于 | for(i=1;i<N-1;i++) | void fun(int a,int b,long *c) | |
平均值数据移至数据前部, 小于等于平均 | { sum+=w[i][0]+w[i][N-1]; | { | |
数移至x 所指数组后部, 平均值作为函数 | n+=2; | *c=(b%10)*1000+(a%10)*100+(b/10)*10+( | |
值返回, 在主函数中输出平均值和移动后 | } | a/10);} | |
数据。 | return sum/n; | 第十三套 | |
第一处 av=s/N; | } | 1. 程序填空 | |
第二处 y[j++]=x[i];x[i]=-1;} | 第十二套 | 给定程序中, 函数fun 功效是: 找 | |
第三处 if(x[i]!=-1) | 1. 程序填空 | 出N*N 矩阵中每列元素中最大值, 并按 | |
y[j++]=x[i]; | 给定程序中, 函数fun 功效是: 将 | 次序一次存放于形参b 所指一维数组中。 | |
2. 程序修改 | 自然数1—10 和它们平方根写到名为 | 第一处 b[i]=a[0][i]; | |
给定程序MODI1.C 中函数fun 功 | myfile3.txt 文本文件中, 然后再次序读出 | 第二处 if (b[i]<a[j][i]) | |
效是: 读入一行英文文本行, 将其中每个 | 显示在屏幕上。 | b[i]=a[j][i]; | |
单词第一个字母改成大写, 然后输出次文 | 第一处 | 第三处 fun(x,y); | |
本行（这里“单词”是指由空格隔开字符 | fprintf(fp,”%d%f\n”,i,sqrt((double)i)); | 2. 程序修改 | |
串）。 | 第二处 fclose(fp); | 给定程序MODI1.C 中函数fun 功 | |
/**found**/ | 第三处 if((fp=fopen(fname,”r”))==NULL) | 效是: 交换主函数中两个变量值。 | |
#include<stdio.h> | 2. 程序修改 | /**found**/ | |
/**found**/ | 给定程序MODI1.C 中函数fun 功 | int fun(int *x,int *y) | |
upfst (char *p) | 效是: 将n 个无序整数从小到大排序。 | /**found**/ | |
3. 程序设计 | /**found**/ | t=*x;*x=*y;*y=t; | |
程序定义了N×N 二级数组, 并 | for(i=j+1;i<n;i++) | 3. 程序设计 | |
在主函数中赋值, 请编写函数fun, 函数功 | /**found**/ | 编写函数fun, 函数功效是求出 | |
效是: 求出数组周围元素平均值并作出函 | p=i; | 小于或等于lim 全部素数并放在aa 数组中, | |
数值饭给主函数中s。 | 3. 程序设计 | 函数返回所求出素数个数。 | 函数fun 中给 |
double fun(int w[][N]) | 函数fun 功效是: 将a、 b 中两位 | 出语句仅供参考。 | |
{ int i,j,n=0; | 正整数合并形成一个新整数放在c 中。 | #include <stdio.h> | |
double sum=0; | 合并方法是: 将a 中十位和个位依次放在 | #define MAX100 | |
for(i=0;i<N;i++) | 变量c 个位和百位上, b 中十位和个位数依 | int fun(int lim,int aa[MAX]) | |
{ sum+=w[0][i]+w[N-1][i]; | 次放在变量c 十位和千位上。 | {int i,j,k=0; | |
for(i=2;i<=lim;i++) | 3. 程序设计 | /**found**/ | |
{ | 请编写函数fun, 函数功效是: 计 | t=t/10; | |
for(j=2;j<=(i/2);j++) | 算并输出给定整数n 全部因子（不包过1 | 3. 程序设计 | |
if(i%j==0)break; | 和n 本身）之和。要求n 值小于1000. | 请编写一个函数void fun（char*tt, | |
if(j>(i/2))aa[k++]=i; | int fun(int n) | int pp[ ]）, 统计在tt所指字符串中‘a’至‘z’ | |
} return k;} | { | 26 个小写字母各自出现在次数, 并依次放 | |
第十四套 | int s=0,i; | 在pp 数组中。 | |
1. 程序填空 | for(i=2;i<n;i++) | void fun(char*tt, int pp[ ]) | |
函数fun 功效是进行字母转换。 | if(n%i==0)s+=i; | { | |
若形参ch 中小写英文字母, 则转换成对 | return s; | char *p=tt; | |
应大写英文字母; 若形参ch 中是大写英文 | } | int i; | |
字母, 则转换成对应小写英文字母; 并将 | 第十五套 | for(i=0;i<26;i++) | |
转换结果作为函数值返回。 | 1. 程序填空 | pp[i]=0; | |
第一处 if((ch>=’a’)&&(ch<=’z’)) | 给定程序中, 函数功效是: 把形参 | while(*p) | |
第二处 return | s 所指字符串下标为奇数字符右移到下一 | {if(*p>=’a’&&*p<=’z’) | |
ch+’a’-‘A’ | 个奇书位置, 最右边呗移出字符串字符绕 | pp[*p-‘a’]+=1; | |
第三处 return ch; | 回放到第一个奇数位置, 下标为偶数字符 | p++; | |
2. 程序修改 | 不动（注: 字符串长度大于等于2）。比 | } | |
给定程序MODI1.C 中函数fun 功 | 如, 形参s 所指字符串为: abcdefgh, 实施 | } | |
效是: 给一维数组a 输入任意四个整数并 | 结果为: ahcbedg。 | 第十六套 | |
按下列规律输出。比如输出1、 2、 3、 | 第一处 if(n%2==0) k=n-1; | 1. 程序填空 | |
4, 程序输出一下方阵。 | 第二处 c=s[k]; | 人员统计由编号和出生年、月、日组成, | |
a) | 1 2 3 | 第三处 s[1]=c; | N 名人员数据已在主函数中存入结构体数 |
3 4 1 2 | 2. 程序修改 | 组std 中, 且编号唯一。函数fun 功效是: | |
2 3 4 1 | 给定程序MODI1.C 中函数fun 功 | 找出指定编号人员数据, 作为函数值返回, | |
1 2 3 4 | 效是: 求 s=aa…aa—…—aaa—aa—a（此 | 由主函数输出, 若指定编号不存在, 返回 | |
/**found**/ | 处aa…aa 表示n 个a, a 和n 值在1 至9 之 | 数据中编号为空串。 | |
void fun(int *a) | 间）。 | 第1 处 STU fun(STU *std, char *num) | |
/**found**/ | /**found**/ | 第2 处 if(strcmp (std[i].num, num) | |
a[j]=a[j-1]; | long s=0,t=0; | = =0) | |
第3 处 return (std[i]); | 第2 处 if(s[i]>=’0’&&s[i]<=’9’) | 将每行元素中值均右移m 个位置, 左边值 |
2. 程序修改 | n++; | 为0. |
给定程序MODI1.C 中函数fun 功 | 第3 处 *t=n; | 第1 处 for(i=0;i<N;i++) |
效是: 从s 所指字符串中, 找出和t 所指字 | 2. 程序修改 | 第2 处t[i][j+m]=t[i][j]; |
符串相同子串个数作为函数值返回。 | 给定程序MODI1.C 中函数fun 功 | 第3 处 for(j=0;j<m;j++) |
/**found**/ | 效是: 经过某种方法实现两个变量交换, | 2. 程序修改 |
r++; p++; | 要求不许可增加语句和表示式。比如变 | 给定程序MODI1.C 中函数fun 功 |
/**found**/ | 量a 中值原为8, b 中值原为3, 程序运行 | 效是: 计算并输出high 以内最大10 个素数 |
if(*r= =0） | 后a 中值为3, b 中值为8. | 之和。 high 值由主函数传给fun 函数。 |
3. 程序设计 | /**found**/ | /**found**/ |
函数fun 功效是: 将s 所指字符串 | t=*x;*x=y; | while((2<=high)&&(n<10)) |
中ASCII 值为偶数字符删除, 串中剩下字 | /**found**/ | /**found**/ |
符形成一个新串放在t 所指数组中。 | return(t); | yes=0;break; |
#include <stdio. h> | 3. 程序设计 | 3. 程序设计 |
#include <string. h> | 请编写函数fun, 函数功效是: 求 | 请编写函数fun, 函数功效是: 利 |
void fun (char*s, char t[]) | 出1 到1000 之间能被7 或11 整除, 但不 | 用一下所表示简单迭代方法求方程求方程: |
{ | 能同时被7和11整除全部整数并将它们放 | cos（x）-x=0 一个实根。 xn+1=cos（xn） |
int i, j=0; | 在a 所指数组中, 经过n 返回这些数个数。 | |
迭代步骤以下: （1）取x1 初值为0.0; | ||
for(i=0;i<strlen(s);i++) | #include <stdio. h> | （2）x0=x1, 把x1 值赋给x0; （3）x1=cos |
if(s[i]%2) t[j++]=s[i]; | viod fun (int *a,int *n) | （x0）, 求出一个新x1; （4）若x0-x1 绝 |
t[j]=0; | {int i; | 对值小于0.000001 实施步骤（5）不然实 |
} | *n=0; | 施步骤（2）; （5）所求x1 就是方程cos |
第十七套 | for(i=7;i<1000;i++) | （x）-x=0 一个实根作为函数值返回。 |
1. 程序填空 | if(((i%7)= =0││(i%11)= =0 | 程序将输出结果为: Root=0.739058。 |
给定程序中, 函数fun 功效是: 统 | &&(i%77)!=0) a[(*n)++]=i; | float fun() |
计形参s 所指字符串中数字字符出现次数, | } | { |
并存放在形参t 所指变量中, 最终在主函 | 第十八套 | float x0,x1=0.0; |
数中输出。比如, 形参s 所指字符串为: | 1. 程序填空 | do{ |
abcdef35adgh3kjsdf7。输出结果为: 4。 | 给定程序中, 函数fun 功效是: | x0=x1; |
第1 处 for(i=0;s[i]!=NULL;i++) | 有N×N 矩阵, 依据给定m（m<=n）值, | x1=cos(x0); |
}while(fabs(x0-x1)>0.000001); | 次放在变量c 个位和百位上。 | viod fun (char a[ ],char | ||
return x1; | void fun(int a,int b,int*c) | b[],int n） | ||
} | { | { | ||
第十九套 | *c=(a%10)*1000+(b%10)*100 | strncpy (b,a,n); | ||
1. 程序填空 | +(a/10)*10+(b/10); | b[n]=0; | ||
给定程序中, 函数fun 功效是: | } | strcat(b,a+n+1); | ||
将a 所指3×5 矩阵中第k 列元素左移到第 | 第二十套 | } | ||
0 列, 第k 列以后每列元素行依次左移, | 1. 程序填空 | 第二十一套 | ||
原来左边各列依次绕到右边。 | 给定程序中, 函数fun 功效是: 对 | 1. 程序填空 | ||
第1 处for(p=1;p<=k;p++) | 形参s 所指字符串中下标为奇数字符 | 给定程序中, 函数fun 功效是: 在 | ||
第2 处for(j=0;j<N-1;j++) | ASCII 码大小递增排序, 并将排序后下标 | 形参ss 所指字符串数组中, 将全部串长超 | ||
a[i][j]=a[i][j+1]; | 为奇数字符取出, 形成一个新串。 | 出k 字符串右边字符删去, 只保留左边k | ||
第3 处 a[i][N-1]=temp; | 第1 处t=i; | 个字符。 ss 所指字符串数组有N 个 | ||
2. 程序修改 | 第2 处for(j=i+2;j<n;j=j+2) | 字符串, 且串小于M。 | ||
给定程序MODI1.C 中函数fun 功 | 第3 处p[j]=0; | 第一处 void fun(char (*ss)[M], int k) | ||
效是: 依据形参m 值（2<=m<=9）, 在m | 2. 程序修改 | 第二处 while (i<N){ | ||
行m 列二维数组中存放以下所表示规律数 | 给定程序MODI1.C 中函数fun 功 | 第三处 ss[i][k]=0;i++;} | ||
据, 由main 函数输出。 | 比如, 若输入2 则 | 效是: 用下面公式求π近似值, 知道最终 | 2. 程序修改 | |
输出: | 一项近似值小于指定数（参数num）为止: | 给定程序MODI1.C 中函数fun 功 | ||
1 | 2 | 比如程序0.0001, 则程序输出3.1414。 | 效是: 依据以下公式求π值, 并作为函数 | |
2 | 4 | /**found**/ | 值返回。比如, 给指定精度变量eps 输入 | |
/**found**/ | while((fabs(t))>=num) | 0.0005 时, 应该输出Pi=30140578.。 | ||
fun(int a[][M],int m) | /**found**/ | /**found**/ | ||
/**found**/ | t=s/n | t=1; | ||
a[j][k]=(k+1)*(j+1); | 3. 程序设计 | /**found**/ | ||
3. 程序设计 | 请编写一个函数void fun（char | return(2*s); | ||
函数fun 功效是: 将a、 b 中两位 | a[ ],char b[ ],int n）, 其功效是: 删除一个 | 3. 程序设计 | ||
正整数合并形成一个新整数放在c 中。 | 字符串指定下标字符。其中, a 指向原字 | 假定输入字符串中只包含字母和* | ||
合并方法是: 将a 中十位和个位依次放在 | 符串, 删除指定字符后字符串放在b 所指 | 号。请编写函数fun, 它功效是: 将字符 | ||
变量c 十位和千位上, b 中十位和个位数依 | n 中存入指定下标。 | 串前导*号不得多于n 个; 若多于n 个, 则 | ||
删除多出*号; 若少于或等于n 个, 则什么 | 第三处 a[0][i]=a[k][i]; | 指定源文件中内容复制到指定目标文件中, | ||
也不做, 字符串中间和尾部*号不删除。 | 2. 程序修改 | 复制成功时函数返回值是1, 失败是返回 | ||
函数fun 中给出语句仅供参考。 | 给定程序MODI1.C 中函数fun 功 | 值是0.在复制过程中, 把复制内容输出到 | ||
void fun(char*a,int n) | 效是: 读入一个字符串（长度<20）,将该 | 终端屏幕。主函数源文件名放在变量 | ||
{ | 字符串中全部字符串按ASCII 码升序排序 | sfname 中, 目标文件放在变量tfname 中。 | ||
int i=0,k=0; | 后输出。比如, 若输入edcba, 则应输出: | 第一处 | ||
while(a[k]= =’*’)k++; | abcde。 | if((fs=fopen(source,”r”))==NULL) | ||
if(k>n) | /**found**/ | 第二处 while(!feof(fs)) | ||
{ | for(i=strlen(t)-1;i;i--) | 第三处 fputc(ch,ft); | ||
i=n;j=k; | /**found**/ | 2. 程序修改 | ||
for(;a[j]!=0;j++) | if(t[j]>t[j+1]) | 给定程序MODI1.C 中函数fun 功 | ||
a[i++]=a[j]; | 3. 程序设计 | 效是: 将长整型中每一位上为偶数数依次 | ||
a[i]=0; | 请编写函数fun, 函数功效是: 将 | 取出, 组成一个新数放在t 中。高位仍在 | ||
}} | ss 所指字符串中全部下标为奇数位置上字 | 高位, 低位仍在低位。 | ||
第二十二套 | 母转换为大写（若该位置上不是字母, 则 | /**found**/ | ||
1. 程序填空 | 不转换）。 | if(d%2==0) | ||
给定程序中, 函数fun 功效是: a 所 | void fun(char *ss) | /**found**/ | ||
指4×3 矩阵中第k 行元素和第0 行元素交 | { | s/=10; | ||
换。比如: 有下列矩阵 | char *p=ss; | 3. 程序设计 | ||
1 | 2 3 | inr i=0; | 函数fun 功效是: 将两位正整数a、 | |
4 5 6 | while(*p){ | b 合并形成一个新整数放在c 中。合并 | ||
7 8 9 | if((i%2)&&(*p>=’a’ &&*p<=’z’)) | 方法是: 将a 中十位和个位依次放在变量 | ||
10 11 12 | *p-=32; | c 十位和千位上, b 中十位和个位数依次放 | ||
若k 为2, 程序实施结果为 | p++; | 在变量c 百位和个位上。 | ||
7 8 9 | i++; | void fun(int a,int b,long*c) | ||
4 5 6 | } | { | ||
1 2 3 | } | *c=(a%10)*1000+(b/10)*100+(a/10)*10+(b | ||
10 11 12 | 第二十三套 | %10); | ||
第一处 void fun(int (*a)[N],int k) | 1. 程序填空 | 第二十四套 | ||
第二处 for(i=0;i<N;i++) | 给定程序功效是: 调用函数fun 将 | 1. | 程序填空 | |
程序经过定义学生结构体变量, | while(*p){ | /**foune**/ | |
存放了学生学号、姓名和三门课成绩。 | *q=*p; | d=a-i; | |
函数fun 功效是将形参a 所指结构体变量 | p++;q++; | 3. 程序设计 | |
中数据赋给函数中结构体变量b, 并修改 | } | 请编写函数fun, 它功效是: 计算 | |
b 中学号和姓名, 最终输出修改后数据。 | for(;n>0;n--) | 并输出n（包含n）以内能被5 或9 整除全 | |
第一处 b=a; | *q++=’*’; | 部自然数倒数之和。 | |
第二处 strcpy(b.name,”LiSi”) | *q=’\0’; | double fun(int n) | |
第三处 for (i=0;i<3;i++) | } | { | |
printf(“%6.2f”,b.score[i]); | 第二十五套 | int i; | |
2. 程序修改 | 1. 程序填空 | double sum=0.0; | |
给定程序MODI1.C 中函数fun 功 | 用筛选法可得到2—n（n<10000） | for(i=1;i<n;i++) | |
效是: 从s 所指字符串中删除全部小写字 | 之间全部素数, 方法是: 首先从素数2 开 | if(i%5= =0||i%9==0) | |
母c。请更正程序中错误, 使它能计算出 | 始, 将全部2 倍数数从数表中删去（把数 | sum+=1.0/i; | |
正确结果。 | 表中对应位置值置成0）; 接着从数表中 | return sum; | |
/**found**/ | 找下一个非0 数, 并从数表中删去该数全 | } | |
s[j++]=s[i]; | 部倍数, 依这类推, 直到所找下一个数等 | 第二十六套 | |
/**found**/ | 于n 为止。这么会得到一个序列: 2、 3、 | 1. 程序填空 | |
s[j]=’\0’; | 5、 7、 11、 13、 17、 19、 23……函 | 给定程序中, 函数fun 功效是建 | |
3. 程序设计 | 数fun 用筛选法找出全部小于等于n 素数, | 立一个N×N 矩阵。矩阵元素组成规律 | |
假定输入字符串中只包含字母和* | 并统计素数个数作为函数值返回。 | 是: 最外层元素值全部是1; 从外向内第 | |
号。请编写函数fun, 它功效是: 将字符 | 第一处 for(j=a[i]*2;j<=n;j+=a[i]) | 二层元素值全部为2; 第三层元素值全部 | |
串前导*号全部移到字符串尾部。 | 函数fun | 第二处 while(a[i]= =0) | 是3, …依这类推。 |
中给出函数仅供参考。 | 第三处 if(a[i]!=0) | 第一处void fun(int(*a)[N]) | |
void fun(char *a) | 2. 程序修改 | 第二处for(j=i;j<N-i;j++) | |
{ char *p,*q; | 给定程序MODI1.C 中函数fun 功 | 第二处a[k][i]=a[k][N-i-1]=i+1; | |
int n=0; | 效是: 为一个偶数寻求两个素数, 这两个 | 2. 程序修改 | |
p=a; | 素数之和等于该偶数, 并将这两个素数经 | 给定程序MODI1.C 中函数fun 功 | |
while(*p==’*’) | 过形参指针传回主函数。 | 效是: 将十进制正整数m 转换成k（2<=k | |
{n++;p++;} | /**found**/ | <=9）进制数, 并按高位到低位次序输出。 | |
q=a; | y=1; | /**found**/ | |
aa[i]=m%k; | 2. 程序修改 | 1. 程序填空 | |
/**found**/ | 给定程序MODI1.C 中函数fun 功 | 给定程序中, 函数fun 功效是: | |
printf(“%d”,aa[i-1]); | 效是: 从三个红球, 5 个白球, 6 个黑球中任 | 计算N*N 矩阵主对角线元素和方向对角 | |
3. 程序设计 | 意取出8 个作为一组, 进行输出。在没 | 线元素之和, 并作为函数值返回。注意: | |
编写一个函数, 从num 个字符串 | 组中, 能够没有黑球, 但必需要有红球和 | 要求先累加主对角线元素中值, 然后累加 | |
中找出最长一个字符串, 并经过形参指针 | 白球。组合数作为函数值返回。正确组 | 反响对角线元素值。 | |
max 传回该串地址。（注意: 主函数中 | 合数应该是15.程序中i 值代表红球数, j 代 | 第一处 sum=0; | |
用****作为结束输入标志, 函数fun 中给 | 表明球数, k 代表黑球数。 | 第二处 sum+=t[i][i]; | |
出语句仅供参考）。 | /**found**/ | 第三处 sum+=t[i][n-i-1]; | |
fun(char (*a)[81],int num,char **max) | for(i=1;i<=3;i++) | 2. 程序修改 | |
{ | /**found**/ | 给定程序MODI1.C 中函数fun | |
int i,k=0,maxlen; | if(k>=0&&k<=6) | 和funx 功效是: 用二分法求方程 | |
maxlen=strlen(a[k]); | 3. 程序设计 | 2x3-4x2+3x-6=0 一个根, 并要求绝对误差 | |
for(i=1;i<num;i++) | 请编写函数fun, 它功效是: 计算 | 不超出0.001。 | |
{ | 并输出下列多项式值: sn=1+1/1! | /**found**/ | |
if(strlen(a[i])>maxlen) | double r; | ||
+1/2!+1/3!+1/4!+……1/n!。比如: 在主函 | |||
{maxlen=strlen(a[i]); | 数中从键盘给n 输入15, 则输出为: | /**found**/ | |
k=i; | s=2.718282。注意: 要求n 值大于1 但小 | while(fabs(n-m)>0.001) | |
} | 于100。 | 3. 程序设计 | |
} | double fun(int n) | 假定输入字符串中只包含字母和 | |
*max=a[k]; | { | *号。请编写函数fun, 它功效是: 除了 | |
} | double s=1’ | 字符串前导和尾部*号之外, 将串中其它* | |
第二十七套 | long t=1; | 号全部删除。 | 形参h 已指向字符串中第一 |
1. 程序填空 | int i; | 个字母, 形参p 已指向字符串中最终一个 | |
函数fun 功效是计算f（x） | for(i=1;i<=n;i++){ | 字母。在编写函数时, 不得使用c 语言提 | |
=1+x-2/2! +3/3! -4/4! +… … 前n 项和。 | t=t*i; | 供字符串函数。 | |
若x=2.5,n=15 时, 函数值为1.917914。 | s+=1.0/t;} | void fun(char *a,char *h,char *p) | |
第一处 f=1; | return s; | { | |
第二处 t*=(-1)*x/i; | } | int j=0; | |
第三处 f+=t; | 第二十八套 | char *q=a; | |
while(*q&&q<h)a[j++]=*q++; | 编写一个函数fun, 它功效是计 | 效是: 求出两个非零正整数最大条约数, |
while(*h&&*p&&h<p) | 算: s=根号下（ln（1）+ln（2）+ln（3）+……ln | 并作为函数值返回。 |
{ | （m））S 作为函数返回, 在C 语言中能够 | /**found**/ |
if(*h!=’*’)a[j++]=*h; | 调用log（n）求ln（n）。 log 函数引用说 | t=a;a=b;b=t; |
h++; | 明是: Double log（double x）比如, 若m 值 | /**found**/ |
} | 为: 20, fun 函数值为: 60506583。 | return (b); |
while(*p)a[j++]=*p++; | double fun(int m) | 3. 程序设计 |
a[j]=0; | { | 假定输入字符串中只包含字母和* |
} | double s=0.0; | 号。请编写函数fun, 它功效是: 删除字 |
第二十九套 | int i; | 符串中全部*号。在编写函数时, 不得使 |
1. 程序填空 | for(i=0;i<=m;i++) | 用C 语言提供字符串函数。 |
给定程序中, 函数fun 功效是: | s+=log(1.0*i); | void fun(char *a) |
有N*N 矩阵, 将矩阵外围元素顺时针旋 | s=sqrt(s); | { |
转。操作次序是: 首先将第一行元素值 | return s; | int j=0; |
存入临时数组r, 然后使第一列成为第一 | } | char *p=a; |
行, 最终一行成为第一列, 最终一列成为 | 第三十套 | while(*p){ |
第一行, 临时数组中和元素成为最终一列。 | 1. 程序填空 | if(*p!=’*’) |
第一处 t[0][N-j-1]=t[j][0]; | 函数fun 功效是: 反形参a 所指数 | a[j++]=*p; |
第二处 for(j=N-1;j>=0;j--) | 组中奇数按原次序依次存放到a[0]、 a[1]、 | p++; |
第三处 t[j][N-1]=r[j]; | a | } |
2. 程序修改 | [2]……中, 把偶数从数组中删除, 奇数个 | a[j]=0; |
给定程序MODI1.C 中函数fun 功 | 数经过函数值返回。比如: 若a 所指数组 | } |
效是: 计算s=f（-n）+f（-n+1）+……+f（0） | 中数据最初排列为: 9、 1、 4、 2、 3、 | 第三十一套 |
+f（1）+f（2）+……f（n）值。比如, | 6、 5、 8、 7, 删除偶数后a 所指数组中 | 1. 程序填空 |
当n 为5 时, 函数值应该是: 10.407143。 | 数据为: 9、 1、 3、 5、 7, 返回值为5。 | 给定程序中, 函数fun 功效是: |
/**found**/ | 第一处 if(a[i]%2==1) | 在形参ss 所指字符串数组中, 删除全部串 |
double f(double x) | 第二处 j++; | 长超出k 字符串, 函数返回所剩字符串个 |
/**found**/ | 第三处 return j; | 数。 Ss 所指字符串数组有N 个字符 |
return s; | 2. 程序修改 | 串, 且串长小于M。 |
3. 程序设计 | 给定程序MODI1.C 中函数fun 功 | 第一处 for(i=0;i<N;i++) |
第二处 if(len<=k) | a[k]=’\0’; | return ave; | ||
第三处strcpy(ss[j++],ss[i]); | } | } | ||
2. 程序修改 | 第三十二套 | 第三十三套 | ||
给定程序MODI1.C 中函数fun 功 | 1. 程序填空 | 1. 程序填空 | ||
效是: 逐一比较p、 q 所指两个字符串对 | 给定程序中已建立一个带头结点 | 给定程序中, 函数fun 功效是: | ||
应位置中字符, 把ASCII 值或相等字符依 | 单向链表, 链表中各结点按结点数据域中 | 在形参ss 所指字符串数组中, 查找含有形 | ||
次存放在c 所指数组中, 形成一个新字符 | 数据递增有序链接。函数fun 功效是: | 参substr 所指子串全部字符串并输出, 若 | ||
串。 | 把形参x 值放入一个新结点并插入到链表 | 没找到输出对应信息。 Ss 所指字符串数 | ||
/**found**/ | 中, 插入后各结点数据域值仍保持递增有 | 组有N 个字符, 且串长小于M。程 | ||
int k=0; | 序。 | 序中库函数strstr（s1、 s2）功效是早s1 | ||
/**found**/ | 第一处 s->data=x; | 串中查找s2 子串, 若没有, 函数值为0, | ||
while(*p||*q) | 第二处 q=p; | 若有, 为非0。 | ||
3. 程序设计 | 第三处 q->next=s; | 第一处 for(i=0;i<N;i++) | ||
假定输入字符串中只包含字母和* | 2. 程序修改 | 第二处 if(strstr(ss[i],substr)!=NULL) | ||
号。请编写函数fun, 它功效是: 除了字 | 给定程序MODI1.C 中函数fun 功 | 第三处 if(find==0) | ||
符串前导*号之外, 将串中其它*号全部删 | 效是: 计算正整数num 各位上数字之积。 | 2. 程序修改 | ||
除。 | 在编写函数时, 不得使用C 语言提供 | /**found**/ | 给定程序MODI1.C 中函数fun 功 | |
字符串函数。 | 函数fun 中给出语句仅供参 | long k=1; | 效是: 求三个数最小公倍数。 | |
考。 | /**found**/ | /**found**/ | ||
void fun(char *a) | num/=10 | fun(int x,int y,int z) | ||
{ | 3. 程序设计 | /**found**/ | ||
int i=0,k; | 请编写函数fun, 它功效是: 计算 | return j; | ||
while(a[i]!==’*’)i++; | n 门课程平均分, 计算结果作为函数返回。 | 3. 程序设计 | ||
k=i; | float fun(float *a,int n) | 假定输入字符串中只包含字母和* | ||
while(a[i]!=’\0’) | { | 号。请编写函数fun, 它功效是: 只删除 | ||
{ | int i; | 字符串前导和尾部*号, 串中字母之间*号 | ||
if(a[i]!=’*’) | float ave=0.0; | 全部不删除。形参n 给出了字符串长度, | ||
a[k++]=a[i]; | for(i=0;i<n;i++) | 形参h 给出了字符串中前导*号个数。在 | ||
i++; | ave=ave+a[i]; | 编写函数时, 不得使用C 语言提供字符串 | ||
} | ave=ave/n; | 函数。 | ||
void fun(char *a,int n,int h,int e) | 这些数放在b 所指数组中, 这些数作为函 | 效是: 求出s 所指字符串最终一次出现t 所 |
{ | 数值返回。要求, 函数中a1 放个位数, a2 | 指字符串地址, 经过函数值返回, 在主函 |
char *p=a; | 放十位数。 | 数中输出以后地址开始字符串; 若未找到, |
int j=0,len=0; | /**found**/ | 则函数值NULL。 |
while(*p){p++;len++;} | a2=k/10; | /**found**/ |
while(j<len-h-e){ | /**found**/ | a=NULL; |
a[j]=a[h+j]; | return i; | /**found**/ |
j++; | 3. 程序设计 | if(*r==*p) |
} | 假定输入字符串中只包含字母和* | 3. 程序设计 |
a[j]=0; | 号。请编写函数fun, 它功效是: 将字符 | 函数fun 功效是: 将s 所指字符串 |
} | 串尾部*号全部删除, 前面和中间*号不删 | 中除了下标为偶数, 同时ASCII 指也为偶 |
除。 | 数字符外, 其它全部全部删除: 串中剩下 |
第三十四套
voidfun(char *a) 字符所形成一个新串放在t所指数组中。
1. 程序填空
{ voidfun(char *s,char t[ ]) 给定程序中,函数fun功效是:
{char *p=a;
在形参ss所指字符串数组中查找和形参t
while(*p)p++;p--;
inti,j=0;所指字符串相同串,找到后返回该串在字
while(*p==’*’)p--; for(i=0;i<strlen(s);i+=2)符串中位置（下标值）,未找到则返回-1。
p++; if(s[i]%2==0)t[j++]=s[i];ss所指字符串数组有N个内容不一样
*p=0; t[j]=0;
字符串,且串长小于M。
} }
第一处for(i=0;i<N;i++)
第三十五套 第三十六套
第二处
1. 程序填空 1. 程序填空
if(strcmpss[i],t)==0
函数fun功效是:进行数字字符给定程序中,函数fun功效是:
return i;
统计出带有头结点单向链表中结点个数, 转换。若形参ch中是数字字符‘0’—第三处if(n==-1)
存放在形参n所指存放单元中。 ‘9’,则‘0’转换成‘9’,‘1’转换成‘8’ printf(“\nDon’tfound!\n”);
‘2’转换成‘7’,……‘9’转换成‘0’;第一处*n=0;
2. 程序修改
第二处p=p->next; 若是其它字符则保持不变,并将转换后结 给定程序MODI1.C中函数fun功
第三处fun(head,&num); 果做函数值返回。
效是:从整数1到55之间,选出能被3整
2. 程序修改 第一处charfun(char ch)除、且有一位上数是5那些事,而且把
给定程序MODI1.C中函数fun功 第二处if(ch>=’0’&&ch<=’9’)
第三处 return ‘9’-(ch-‘0’); | 1. 程序填空 | while(j<n&&*p){ |
2. 程序修改 | 函数fun 功效是: 把形参a 所指数 | p++; |
给定程序MODI1.C 中函数fun 功 | 组中偶数按原次序依次存放a[0]、 a[1]、 | j++; |
效是: 将p 所指字符串中全部字符复制到 | a[2]……中, 把奇数从数组中删除, 偶数 | } |
b 中, 要求复制第三个字符以后插入一个 | 个数经过函数值返回。 | *p=0; |
空格。 | 第一处 if(a[i]%2==0){ | } |
/**found**/ | 第二处 a[j]=a[i];j++; |
第三十八套
b[k]=*p; 第三处returnj;
1. 程序填空
/**found**/ 2. 程序修改
给定程序中,函数fun功效是:
b[k++]=’‘; 给定程序MODI1.C中函数fun功
利用指针数组对形参ss所指字符串数组中
3. 程序设计 效是:按以下递推公式求函数值。比如,
字符串按由长到短次序排列,并输入排序
N名学生成绩已在主函数中放入 当给n输出5时,函数值为18;当给n输
结果。ss所指定字符串数组有N个
一个带头结点链表结构中,h指向链表头 入3时,函数值为14.
字符串,且串长小于M。
结点。请编写函数fun,它功效是:求出 /**found**/
第一处k=i
平均分,有函数值返回。 fun(intn)
第二
doublefun(STREC *h) /**found**/
if(strlen(ps[k])<strlen(
{ if(n==1)
ps[j]))k=j;
STREC *p=h->next; | 3. 程序设计 | 第 | 三 | 处 |
double av=0.0; | 假定输入字符串中只包含字母和* |
tp=ps[i];ps[i]=ps[k];ps[k]=tp;
intn=o; 号。请编写函数fun,它功效是:使字符
2. 程序修改
while(p!=NULL) 串中尾部*号不得多于n个;若多于n个则
已知一个数列从第0项开始前三项分别是
{ 删除多出*号;若少于或等于n个,则什么
0、0、1以后各项全部是它相邻前三项
av=av+p->s; 也不做,字符串中间和前面*号不删除。
之和。给定程序MODI1.C中函数fun功
p=p->next; voidfun(char *a,int n)
效是:计算并输出该数列前n项平方根之
n++; {
和。n值经过形参传入。
} char*p=a;
/**found**/
av/=n; intj=0;
doublefun(int n)
returnav; while(*p)p++;p--;
/**found**/
} while(*p==’*’)p--;
returnsum;
第三十七套 p++;
3. 程序设计 | /**found**/ | 3. 程序设计 |
请编写函数fun, 它功效是: 计算 | for(i=2;i<=n;i++) | 请编写函数fun, 它功效是: 求出 |
下列级数和, 和值由函数值返回。比如, | 3. 程序设计 | ss 所指字符串中指定字符个数, 并返回次 |
当n=10, x=0.3 时, 函数值为1.349859。 | 程序定义了N×N 二维数组, 并 | 值。 |
double fun(double x,int n) | 在主函数中自动赋值, 请编写函数fun, 它 | int fun(char *ss,char c) |
{double s=1.0,y=x; | 功效是: 使数组右上三角元素中值乘以m。 | { |
int i; | int fun(int a[][N],int m) | int cnt=0; |
for(i=1;i<=n;i++) | { | char *p=ss; |
{ | int i,j; | while(*p){ |
s+=y/(double)jc(i); | for(i=0;i<N;i++) | if(*p==c)cnt++; |
y*=x; | for(j=i;j<N;j++) | p++; |
} | a[i][j]*=m; | } |
return s; | } | return cnt; |
} | 第四十套 | } |
第三十九套 | 1. 程序填空 | 第四十一套 |
1. 程序填空 | 给定程序中, 函数fun 功效是: | 1. 程序填空 |
给定程序中, 函数fun 功效是: | 将s 所指字符串全部数字字符移到全部非 | 给定程序中, 函数fun 功效是: |
计算x 所指数组中N 个数平均值（要求全 | 数字字符以后, 并保持数字字符串和非数 | 将形参s 所指定字符串中数字字符转换成 |
部数均为正数）, 平均值经过形参返回主 | 字字符串原有前后次序。 | 对应数值, 计算出这些数值累加和作为函 |
函数, 将小于平均值且最靠均值数作 | 第一处 j++; | 数值返回。 |
为函数值返回, 在主函数中输出。 | 第二处 s[i]=t1[i]; | 第1 处 |
第一处 *av=s/N; | 第三处 for(i=0;i<j;i++) | if(isdigit(*s))sum+=*s-48; |
第二处 d=*av-x[i];j=i;} | 2. 程序修改 | 第2 处s++; |
第三处 return x[j]; | 给定程序MODI1.C 中函数fun 功 | 第3 处return sum; |
2. 程序修改 | 效是: 用冒泡法对6 个字符串按由小到大 | 2. 程序修改 |
给定程序MODI1.C 中函数fun 功 | 次序排列。 | 给定程序MODI1.C 中函数fun 功 |
效是: 依据整型形参n 计算以下公式值。 | /**found**/ | 效是: 计算小于形参k 最大10 个能被13 |
比如: 若n=10, 则应输出: 0.617977. | for(j=i+1;j<6;j++) | 或17 整除自然数之和。 K 值由主函数传 |
/**found**/ | /**found**/ | 入, 若K 值为500.则主函数为4622。 |
float fun(int n) | *(pstr+i)=*(pstr+j); | /**found**/ |
if((k%13= =0││(k%17= =0)) | 字母（但Z 转化成A, z 转换为a）, 其它 | 据整型形参m 计算以下公式值。 |
/**found**/ | 字符不变。 | /**found**/ |
} | /**found**/ | t=t-1.0/i; |
3. 程序设计 | while(*s) | /**found**/ |
请编写函数fun, 它功效是: 求小 | /**found**/ | return t; |
于形参n 同时能被3 和7 整除全部自然数 | s++; | 3 程序设计 |
之和平方根, 并作函数返回值。 | 3 程序设计 | 请编写一个函数, 函数功效是: 删除字符 |
double fun(int n) | void fun(int*w, int p, int n) | 串中全部空格。 |
{ | { | int fun(char *str) |
double sum=0.0; | int i,j=0,b[N]; | { |
int i; | for(i=p+1;i<n;i++)b[j++]=w[i]; | char *p=str; |
for(i=21;i<=n;i++) | for(i=0);i<=p;i++) | int i=0; |
if((i%3= =0)&&(i%7= =0))sum | b[j++]=w[i]; | while(*p){ |
+=i; | for(i=0;i<n;i++) | if(*p!=’ ’)str[i++]=*p; |
return sqrt(sum); | w[i]=b[i]; | p++; |
} | } | } |
第四十二套 | 第四十三套 | str[i]=0; |
1 程序填空 | 1 程序填空 | } |
给定程序中, 函数fun 功效是: 将不带头 | 给定程序中, 函数fun 功效是: 判定形参a | 第四十四套 |
结点单向链表结点数据域中数据从小到大 | 所指N 乘以N（要求N 为奇数）矩阵是否 | 1 程序填空 |
排序。即若原链表节点数据域从头到位 | 是“幻方”, 若是, 函数返回值是1; 不是, | 给定程序中, 函数fun功效是: 将N乘以N |
数据为10、 4、 2、 8、 6, 排序后链表 | 函数返回值为0.“幻方”判定条件是: 矩 | 矩阵中元素值按列右移一个位置, 右边被 |
结点数据域从头至尾数据为2、 4、 6、 | 阵每行、每列、主对角线及反对角线上 | 移出矩阵元素绕回左边。 |
8、 10. | 元素之和全部相等。 | 第1 处for(i=0;i<N;i++) |
第1 处q=p->next; | 第1 处row=colum=0; | 第2 处x=t[i][N-1]; |
第2 处while(q) | 第2 处 | 第3 处t[i][0]=x; |
第3 处 p=p->next; | if((row!=colum)││(row!=m1))return 0; | 2 程序修改 |
2 程序修改 | 第3 处return 1; | 给定程序MODI1.C 中函数fun 功效是: 计 |
给定程序MODI1.C 中函数fun 功效是: 将s | 2 程序修改 | 算并输出下列级数前n 项和Sn,直到Sn+1 |
所指字符串中字母转换为按字母次序后续 | 给定程序MODI1.C 中函数fun 功效是: 依 | 大于q 为止, q 值经过形参传入。 |
/**found**/ | 给定MODI1.Cfun 函数功效是: 计算s 所指 | int j,c=0;float xa=0.0; | |||
s=s+(n+1.0)/n; | 字符串中含有t 所指字符串数目, 并作为 | /**found**/ | |||
/**found**/ | 函数值返回。 | 请更正函数fun 中指定部位 | if(x[j]>=xa) | ||
return t; | 错误, 使它能得出正确结果。 | 3 程序设计 | |||
3 程序编写 | /**found**/ | 编写函数fun, 其功效是: 依据以下公式 | |||
编写函数fun, 它功效是: 求Fibonacci数列 | r=t; | 求p 值, 结果由函数值带回。 m 和n 为两 | |||
中大于t 最小一个数, 结果由函数返回。 | /**found**/ | 个正整数且要求m>n。 | |||
其中Fibonacci 数列F（n）定义为 | if(*r= =0) | p=m!/(n!*(m-n)!) | |||
F(0)=0,F(1)=1,F(n)。。。 | 3 程序设计 | float fun(int m, int n) | |||
int fun(int t) | 请编写函数fun, 函数功效是: 将放在字 | { | |||
{ | 符串数组中M 个字符串(每串长度不超出 | float p; | |||
int f0=0,f1=1,f; | N), 按次序合并组成一个新字符串, 函数 | p=1.0*jc(m)/jc(n)/jc(m-n); | |||
do | fun 中给出语句提供参考。 | return p; | |||
{f=f0+f1; | void fun (char a[M][N]),char *b) | } | |||
f0=f1; | {int i;*b=0; | 第四十七套 | |||
f1=f; | for(i=0;i<M;i++)strcat(b,a[i]); | 1 程序填空 | |||
}while(f<t); | } | 函数fun 功效是: 计算f(x)=1+x-x2∕2!+x3 | |||
return f; | 第四十六套 | ∕3!-X4/4! 直到∣xn/n!∣<10-6 | 若x=2.5, | ||
} | 1 程序填空 | 函数值为: 1.917915。 | |||
第四十五套 | 给定程序中, 函数fun 功效是: 将形参s 所 | 第1 处t=x | |||
1 程序填空 | 指字符串全部ASCII 码小于97 字符存入 | 第2 处t*=(-1.0)*x/n; | |||
给定程序中, 函数fun 功效是将带头结点 | 形 | 第3 处while(fabs(t)>=1e-6) | |||
单向链表逆置。即若原链表中从头至尾 | 第1 处*(t+n)=*s;n++;} | 2 程序修改 | |||
结点数据域依次为: 2、 4、 6、 8、 10, | 第2 处s++; | 给定程序MODI1.C 中函数fun 功效是: 求 | |||
逆置后, 从头至尾结点数据域依次为: 10、 | 第3 处return n; | 整数xy 次方低3 位值。 | 比如, 整数56 次 | ||
8、 6、 4、 2.。 | 2 程序修改 | 方为15625, 此值低3 位值为625。 | |||
第1 处p=h->next; | 给定程序MODI1.C 中函数fun 功效是: | /**found**/ | |||
第2 处if (p= =0) return; | 由形参给定n 个实数, 输出平均值以上（含 | for(i=1;i<=y;i++) | |||
第3 处p=q;q=r; | 平均值）实数个数。 | /**found**/ | |||
2 程序修改 | /**found**/ | t=t%1000; | |||
3 程序设计 | 所指字符串长度相同。 | /**found**/ |
请编写函数fun, 其功效是: 计算并输出 | /**found**/ | if(i%k= =0) |
当x﹤0.97 时下列多项式值, 直到 | while(*r) | /**found**/ |
Sn-Sn-1<0.000001 为止。 | /**found**/ | if(k>=i) |
double fun(double x) | *a=*r;a++;r++; | 3 程序设计 |
{ | 3 程序设计 | 编写函数fun, 它功效是: 求出能整除形 |
int n=1; | 函数fun 功效是: 将s 所指字符串中下标为 | 参x 切不是偶数各整数, 并按从小到大次 |
double sn=1; | 偶数字符删除, 串中剩下字符形成新串放 | 序放在pp 所指数组中, 这些除数个数经 |
double xn=1,xn1=0; | 在t 所指数组中。 | 过形参n 返回。 |
while(fabs(xn-xn1)>=0.000001) | void fun(char *s,char t[]) | void fun(int x,int pp[],int*n) |
{ | { | { |
xn=xn*x*(0.5-n+1)/n; | int i,j=0; | int i; |
n+=1; | for(i=1;i<strlen(s);i+=2) | *n=0; |
sn+=xn; | t[j++]=s[i]; | for(i=1;i<=x;i++) |
} | t[j]=0; | if((x%i==0)&&(i%2))pp[(*n)++]=i; |
return(sn); | } | } |
} | 第四十九套 | 第五十套 |
第四十八套 | 1 程序填空 | 1 程序填空 |
1 程序填空 | 给定程序中,函数fun 功效是: 把形参s 所 | 给定程序中, 函数fun 功效是: 将形参s 所 |
给定程序中, 函数fun 功效是: 计算出带 | 知字符串中最左边n 个字符复制到形参t | 知字符串中全部数字字符次序前移, 其它 |
有头节点单向链表中各节点数据域中值之 | 所指字符数组中, 形成一个新串, 若s 所 | 字符次序后移, 处理后新字符串首地址作 |
和作为函数值带回。 | 指字符串长度小于n, 则将整个字符串复 | 为函数值返回。 |
第1 处s+=p->data; | 制到形参t 所指字符数组中。 | 第1 处p[j]=s[i];j++;} |
第2 处p=p->next; | 第1 处if(n>=len)strcpy(t,s); | 第2 处for(i=0;i<k;i++)p[j+i]=t[i]; |
第3 处printf(“\nsum=%d\n”,fun(head)); | 第2 处t[j++]=s[i]; | 第3 处return p; |
2 程序修改 | 第3 处t[j]=0; | 2 程序修改 |
给定程序MODI1.C 中函数fun 功效是: 将s | 2 程序修改 | 给定程序MODI1.C 中函数fun 功效是: 首 |
所指字符串中出现和t1 所指字符串相同子 | 给定程序MODI1.C 中函数fun 功效是: 找 | 先把b 所指字符串中字符按逆序存放, 然 |
串全部替换成t2 所指字符串, 所形成新串 | 出一个大于形参m 且紧随m 素数, 并作 | 后将a 所指字符串中字符和b 所指字符串 |
放在w 所指数组中。在此处, 要求t1 和t2 | 为函数值带回。 | 中字符, 按排列次序交叉合并到c 所指数 |
组中, 过长剩下字符接在c 所指数组尾部。 | 给定程序MODI1.C 中函数fun 功效是: 将s | 据整形形参m 值: 计算以下公式值? …… |
/**found**/ | 所指字符串正序和反序进行连接, 形成一 | 比如:若m中值为5, 则应输出: 0.5363。 |
while(i<j) | 个新串放在t 所指数组中。 | /**found**/ |
/**found**/ | /**found**/ | for(i=2;i<=m;i++) |
if(*a) | void fun(char*s, char *t) | /**found**/ |
3 程序设计 | /**found**/ | y-=1.0/(i*i); |
函数fun 功效是: 将s 所指字符串中下标为 | t[2*d]=’\0’; | 3 程序设计 |
偶数同时ASCII 值为奇数字符删除, s 所 | 3 程序设计 | m 个人成绩存放在score 数组中, 请编写 |
指串中剩下字符形成新串放在 t 所指数组 | 函数fun 功效是: 将s 所指字符串中除了下 | 函数fun, 它功效是: 将低于平均分人数 |
中。 | 标为奇数、同时ASCII 值也为奇数字符 | 作为函数值返回, 将低于平均分分数放在 |
void fun(char *s,char t[]) | 之外, 其它全部字符全部删除, 串中剩下 | below 所指数组中。 |
{ | 字符所形成一个新串放在t 所指数组中。 | int fun(int score[],int m,int below[]) |
int i,j=0; | viod fun(char*s, chat t[]) | { |
for(i=0;i<strlen(s);i++) | { | float av=0.0; |
if(!((i%2)= =0&&(s[i]%2))) | int i,j=0; | int i,j=0; |
t[j++]=s[i]; | for(i=1;i<strlen(s);i+=2) | for(i=0;i<m;i++) |
t[j]=0; | if(s[i]%2) | av+=score[i]; |
} | t[j++]=s[i]; | av/=m; |
第五十一套 | t[j]=0; | for(i=0;i<m;i++) |
1 程序填空 | } | if(av>score[i]) |
给定程序中, 函数fun 功效是: 计算下式 | 第五十二套 | below[j++]=score[i]; |
s=1/22+3/42+5/62… +(2× n-1)/(2× n)2直 | 1 程序填空 | return j; |
到︱（2×n-1）/（2×n）2︱《10-3并把 | 给定程序中, 函数fun 功效是: 在3×4 矩 | } |
计算结果作为函数值返回。 比如, 若形参 | 阵中找出在行上最大, 列上最小那个元素, | 第五十三套 |
e 值le-3 , 函数值返回值为2.735678。 | 若没有符合条件元素则输出对应信息。 | 1 程序填空 |
第1 处i=0; | 第1 处max=a[i][j];c=j;} | 给定程序中, 函数fun 功效是将形参指针 |
第2 处i++; | 第2 处find=0; | 所指结构体数组中三个元素按num 组员进 |
第3 处x=(2.0*i-1) / ((2.0*i)* (2.0*i)); | 第3 处i++; | 行升序排列。 |
2 程序修改 | 第1 处void fun(PERSON*std) |
2程序修改
给定程序MODI1.C中函数fun功效是:依 第2处PERSONtemp;
第3 处fun(std); | 第3 处y[j++]=x[i]; | 母串（不区分大小写字母）。 |
2 程序修改 | 2 程序修改 | 第1 处1p=s; |
给定程序MODI1.C 中函数fun 功效是: 将m | 给定程序MODI1.C 中函数fun 功效是: 依 | 第2 处1p++;rp--;} |
（1≦m≦10）个字符串连接起来, 组成一 | 据整形形参m,计算以下公式值。 | 第3 处if(1p<rp)return 0; |
个新串, 放入pt 所指存放区中。 | /**found**/ | 2 程序修改 |
/**found**/ | double fun(int m) | 给定程序MODI1.C 中函数fun 功效是: 求 |
int k,q,i; | /**found**/ | 出以下分数序列前n 项之和。 |
/**found**/ | for(i=100;i<=m;i+=100) | 2/1+3/2+5/3+8/5+13/8+21/13+… … 和值经 |
pt[i]=str[k][i]; | 3 程序设计 | 过函数值返回main 函数。 比如n=5,则应 |
3 程序设计 | 已知学生统计由学号和学习成绩组成, N | 输出: 8.391667。 |
程序定义了N×N 二维数组, 并在主函数 | 名学生数据已存入a 结构体数组中, 轻便 | /**found**/ |
中自动赋值。 请编写函数fun（int a[ ][N]） | 鞋函数功效是: 找出成绩最低学生统计, | double fun(int n) |
函数功效是: 使数组左下三角元素中值全 | 经过形参返回主函数（要求只有一个最低 | /**found**/ |
部置成0。 | 分） | c=a;a+=b;b=c; |
int fun(int a[][N]) | fun(STU a[],STU *s) | 3 程序设计 |
{ | { | 请编写函数fun, 函数功效是: 将大于形 |
int i,j; | int i,min=a[0],s,j=0; | 参m且紧靠mk个素数存入xx所指数组中。 |
for(i=0;i<N;i++) | for(i=1;i<N;i++) | 19, 23, 29, 31, 37, 函数fun 中给出语句仅 |
for(j=0;j<=i;j++) | if(min>a[i].s){ | 供参考。 |
a[i][j]=0; | j=i; | void fun(int m,int k,int xx[]) |
} | min=a[i].s; | { |
第五十四套 | } | int i,j=1,t=m+1; |
1 程序填空 | *s=a[j]; | while(j<=k) |
给定程序中, 函数fun 功效是: 计算形参 | } | { |
x 所指数组中N 个数平均值（要求全部数 | 第五十五套 | for(i=2;i<t;i++) |
均为正数）, 作为函数值返回, 并将大于 | 1 程序填空 | if(t%i= =0)break; |
平均值数放在形参Y 所指数组中, 在主函 | 给定程序中, 函数fun功效是: 判定形参s | if(i= =t){ |
数中输出。 | 所指字符串是否是“回去”（Palindrome） | xx[j-1]=i; |
第1 处av=0; | 若是, 函数返回值为1; 不是, 函数返回值 | j++; |
第2 处av=av+x[i]/N; | 为0,“回文”是正读和反读全部是一样字 | } |
t++; | { | { | |
} | *c=(b/10)*1000+(a%10)*100+(b%10)*10+( | if(max<*(s+i)){ | |
} | a/10); | max=*(s+i); | |
第五十六套 | } | pos=i; | |
1 程序填空 | 第五十七套 | }} | |
给定程序功效是: 从键盘输入若干行文本 | 1 程序填空 | *k=pos; | |
（每行不得超出80 个字符）, 写到文件 | 给定程序中, 函数fun 功效是: 计算出形 | } | |
myfile4.txt 中, 用-1 作为字符串输入结束 | 参s 所指字符串中包含单词个数, 作为函 | 第五十八套 | |
标志。然后将文件内容读出显示在屏幕 | 数值返回。为便于统计, 要求各单词之 | 1 程序填空 | |
上。文件读写分别由自定义函数ReadText | 间用空格隔开。 | 给定程序中, 函数fun 功效是计算下式 | |
和WriteText 实现。 | 第1 处n++;flag=1;} | s=3/22－5/42 | +7/62－… +(-1)n-1(2× |
第1 处void WriteText(FILE*fw) | 第2 处if(*s= =’ ’)flag=0; | n-1)/(2×n)2直到︱（2×n-1）/(2×n2)︱ | |
第2 处fputs(str,fw);fputs(“\n”,fw); | 第3 处s++; | ≤10-3并把计算结果作为函数值返回, 比 | |
第3 处printf(“%s”,str); | 2 程序修改 | 如: 若形参e 值为-le-3,函数返回值为 | |
2 程序修改 | 给定程序MODI1.C 中函数fun 功效是: 从n | 0.551690。 | |
给定程序MODI1.C 中函数fun 功效是: 从 | （形参）个学生成绩中统计出低于平均分 | 第1 处x=3.0/4; | |
低位开始取出长整形变量s 中奇数位上数, | 学生人数, 此人数由函数值返回, 平均分 | 第2 处while(x>e) | |
依次组成一个新数t 中。高位仍在高位, | 存放在形参aver 所指存放单元中。 | 第3 处x=(2*i+1)/(t*t); | |
低位仍在低位。 | /**found**/ | 2 程序修改 | |
/**found**/ | t+=s[k]; | 给定程序MODI1.C 中函数fun 功效是: 求 | |
void fun(long s,long*t) | /**found**/ | 出以下分数序列前n 项之和。 | |
/**found**/ | *aver=ave; | 2/1,3/2,5/2,8/5,13/8,31/13…和值经过函数 | |
s1=s1*10; | 3 程序设计 | 值返回到main 函数。 | |
3 程序设计 | 请编写函数fun, 其功效是求出数组最大 | /**found**/ | |
函数fun 功效是: 将两个两位数正整数 | 元素在数组中下标并存放在k 所指存放单 | double fun(int n) | |
a 、 b 合并形成一个整数放在c 中。合 | 元。 | /**found**/ | |
并方法是: 将a 数十位和个位数依次放在c | int fun(int *s,int t,int *k) | s=s+(double)a/b; | |
数十位和百位上, b 数十位和个位数依次 | { | 3 程序设计 | |
放在c 数千位和十位上。 | int i,pos=0,max=*s; | 请编写函数fun, 它功效是: 求出一个2× | |
void fun(int a,int b,long*c) | for(i=1;i<t;i++) | M 整型二维数组中最大元素值, 并将此值 | |
返回调有函数。 | 3 程序设计 | return (value); | |||||||
fun(int a[][M]) | 某学生统计由学号、 8 门课程和平均分组 | } | |||||||
{ | 成, 学号和8 门课程成绩已在主函数中给 | 3 程序设计 | |||||||
int i,j,max=a[0][0]; | 出。 | 请编写函数fun, 它功效是;求出该学 | 要求输入字符串中只包含字母和*号。请 | ||||||
for(i=0;i<2;i++) | 生平均分放在统计ave 组员中。 | 编写函数fun ,它功效是: 将字符串中前导* | |||||||
for(j=0;j<M;j++) | void fun(STREC *a) | 号全部删除, 中间和尾部*号不删除。 | |||||||
if(max<a[i][j]) | { int i; | void fun (char *a) | |||||||
max=a[i][j]; | for(i=0;i<N;i++) | { | |||||||
return max; | a->ave=a->ave+a->s[i]; | int j=0; | |||||||
} | a->ave/=N | char *p=a; | |||||||
第五十九套 | } | while (*p=='*')p++; | |||||||
1 程序填空 | 第六十套 | while (*p){ | |||||||
函数fun 功效是: 把形参a 所指数组中最小 | 1 程序填空 | a[j++]=*p; | |||||||
值放在元素a[0],接着把形参a 所指数组中 | 给定程序中, 函数fun 功效是: 有N×N 矩 | p++; | |||||||
最大值放a[1]元素中; 再把a所指数组中次 | 阵, 以主对角线为对称线, 对称元素相加 | } | |||||||
小值放在a[2]中, 把a 所指数组元素中次 | 并将结果存放在左下三角元素中, 右上三 | a[j]=0; | |||||||
大值放在a[3]; 其它以这类推。 | 角元素来。 | } | |||||||
第1 处max=min=a[i]; | 第1 处 void fun (int) (*t)[N] | 第六十一套 | |||||||
第2 处if(max<a[j]) | 第2 处 t[i][j]=t[i][j]+t[j][i]; | 1 程序填空 | |||||||
第3 处if(min>a[j]) | 第3 处 t[j][i]=0; | 人员统计由编号和出生年、月、日组成, | |||||||
2 程序修改 | 2 程序修改 | N 名人员数据已在主函数中存入结构体数 | |||||||
给定程序MODI1.C 中函数fun 功效是: 用 | 给定程序MODI1.C 中函数fun 功效是: 计 | 组std 中。函数fun 功效是: 找出指定出 | |||||||
递归算法计算列中第n 项值。从第一项 | 算 | 函 | 数 | 值 | , | F（ | x,y,z） | 生年份人员, 将其数据放在形参k 所指出 | |
起, 斐波拉契数列为: 1、 1、 2、 3、 5、 | =(x+y)/(x-y)+(z+y)/(z-y)其中x 和y 值不等, | 数组中, 由主函数输出, 同时由函数值返 | |||||||
8、 13、 21、 …… | z 和y 值不等。比如, 当x 值为9、 y 值 | 回满足指定条件人数。 | |||||||
/**found**/ | 为11、 z 值为15 时, 函数值为-3.50。 | 第1 处if (std[i].year==year) | |||||||
switch(g) | /**found**/ | 第2 处 k[n++]=std[i]; | |||||||
/**found**/ | #define FU(m,n) ((m)/(n)) | 第3 处 return (n); | |||||||
case 1:return 1; | 2 | 程序修改 | |||||||
/**found**/
case2:return 1; 给定程序MODI1.C中函数fun功效是:读
入一个整数k（2≤k≤10000）打印它全部 | 下列矩阵: | 3 程序设计 |
质因子（即全部为素数因子）。
1 2 3 假定输入字符串中只包含字母和*号,请
/**found**/
编写函数fun,它功效是:除了尾部*号之
IsPrime(int n) 4 5 6
外,将字符串中其它*全部删除。形参p
/**found**/
7 8 9 已指向字符串中最终一个字母。在编写
if(!(n%i))
函数时,不得使用C语言提供字符串函数。
3 | 程序设计 | 交换后: |
voidfun (char *a,char *p)
已知学生统计由学号和学习成绩组成, N | 3 2 1 | { |
名学生数据已存入结构体数组a中。请
编写给函数fun, 函数功效是: 找出成绩 | 4 5 6 | char *q=a; |
int j=0;
最高学生统计, 经过形参指针传回主函数 | 9 8 7 | while (*q&&q<p){ |
（要求只有一个最高分）, 已给出函数首 | 第1 处 void fun (int t [] [N], int n) | if (*q!=' *') |
部, 请完成函数。 | 第2 处 for (i=0; i<n; i++) | a[j++]=*q; |
fun(STU a[],STU *s) | 第3 处 t [i] [n-i-1]=s; | q++; |
{
int i, max = a[0]. s, j=0; | 2 程序修改 | } |
while(*p) a [j++] = *p++;
for (i=1; i<N;i++) | 由N 个有序整数组成数列已放在一维数组 | a [j]=0; |
{ if (max<a [i].s) { | 中, 给定程序MODI1.C 中函数fun 功效是: | } |
j=i; | 利用折半查找算法查找整数m 在数组中位 | 第六十三套 |
max =a[i].s; | ||
置。若找到, 返回其下标值; 反之, 返回 | ||
} | -1.折半查找基础算法是: 每次查找前先确 | 1 程序填空 |
*s=a[j]; | 定数组中待查范围: low 和high（low﹤ | 给定程序中, 函数fun 功效是;求ss 所指字 |
} | high）, 然后把m 值大于中间位置元素中 | |
第六十二套 | 值, 则下一次查找范围落在中间位置之前 | 符串数组中长度最短字符串所在行下标, |
1 程序填空 | 元素中。直到low﹥high, 查找结束。 | 作为函数值返回, 并把其串长放在形参n |
所指变量中。 Ss 所指字符串数组M | ||
/**found**/ | ||
给定程序中, 函数fun 功效是: 将N×N 矩 | fun (int a [], int m) | 个字符串, 且串长﹤N。 |
阵主对角线元素中值和反向对角线对应位 | /**found**/ | 第1 处 for (i=0;i<M;i++) |
置上元素中值进行交换。 比如: 若N=3 有 | else if (m>a [mid]) | 第2 处 if (len<*n) |
第3处return(k);
2 程序修改 | 第1 处 for (j=i+1; j<M; j++) | 前5 项和作为函数值返回。 S=1×3/22-3 |
第2 处 k=j; | ×5/42+5×7/62-……+(-1)n-1(2×n-1)× |
给定程序MODI1.C中函数fun功效是:将tt
第3处strcpy(ss[k], t); (2×n+1)/(2×n)2比如,当形参n值为10所指字符串中小写字母全部改为对应大写
时,函数返回:-0.204491。
字母,其它字符不变。 2程序修改
第1处k=1;/**found**/
给定程序MODI1.C中函数fun功效是:判 第2处t=2*j; if(( ' a ' <=tt[i])&&(tt[i]
定ch中字符是否和str所指串中某个字符
<=' z ' )) 第3处k=k*(-1); 相同:若相同,什么也不做,则将其插在
2程序修改/**found**/ 串最终。
给定程序MODI1.C中函数fun功效是:判 2 /**found**/
tt[i ]- =32; 定一个整数是否是素数,若是返回1,不 if (*str! =ch)
3 程序设计 | /**found**/ | 然返回0. |
/**found**/ | ||
请编写函数fun, 函数功效是: 将全部大 | str [1]=0; | K++; |
于1 小于整数 m 非素数存入xx 所知数组 | 3 程序设计 | /**found**/ |
中, 非素数个数经过k 传回。 | ||
void fun (int m, int *k, int xx[]) | 请编写一个函数fun(chae*s),函数功效是 | |
if (m==k) | ||
{ | 把s 所指字符串中内容逆置。 | |
3 程序设计 | ||
int i , cnt=0; | fun (char *s) | |
请编写一个函授fun, 它功效是: 找出一 | ||
for (i=0; i<m;i++) | { | |
维整数组元素中最大值和她所在下标, 最 | ||
if (isP(i)) xx [cnt++]=i; | char b[N]; | |
大值和它所在下标经过形参传回。数组 | ||
*k=cnt; | int i=0, j; | 元素中值已在主函数中给予。主函数中x |
} | meset (b,0,N); | |
是数组名, n 是x 中数据个数, max 存放在 | ||
第六十四套 | for (j=strlen(s)-1; j>=0; j--) | |
大值, index 存放最大值所在元素下标。 | ||
b [i++]=s[j]; | ||
1 程序填空 | strcpy (s,b); | void fun (int a[], int n, int *max, int *d) |
{ | ||
给定程序中, 函数fun 功效是: 对形参ss | } | |
int i; | ||
所指字符串数组中M 个字符串按长度由 | 第六十五套 | *max=a[0];*d=0; |
短到长进行排序。 Ss 所指字符串数组中 | 1 程序填空 | for (i=1; i<n;i++) |
共有M 个字符, 且串长﹤N。 | if (*max<a[ i ]) | |
给定程序中, 函数fun 功效是: 计算下式 |
{ *max=a[ i ]; | for (i=0;i<3;i++) | 请编写函数fun, 它功效是;按分数高低排 | ||
*d=i; | for (j=0; j<3; j++) | 列学生统计, 高分在前。 | ||
} | { | int fun (STREC a[]) | ||
} | c [i][j]=a [j] [i] ; | { | ||
第六十六套 | b [i] [j]=a[i] [j] +c [i] [j] ; | STREC tmp; | ||
1 程序填空 | } | int i,j; | ||
给定程序中, 函数fun 功效是: 在形参s 所 | } | for (i=0;i<N; i++) | ||
知字符串中每个数字字符以后插入一个* | 第六十七套 | for (j=0; j<N;j++) | ||
号。 | 1 程序填空 | if (a [i]. s<a[j]. s ) | ||
第1 处 if (s[ i ]>=' 0' &&s [ i ]<=' 9') | 给定程序中, 函数fun 功效是: 找出 | { tmp =a [i]; | ||
第2 处 while (s[i+1+n]! =0)n++; | 100~999 之间（含100 和999）全部整数中 | a [i]=a [j]; | ||
第3 处 s[j+1]=s [j]; | 个位上数字之和为x(x 为一正整数)整数, | a[j] =tmp; | ||
2 程序修改 | 然后输出: 符合条件整数个数作为函数值 | }} | ||
给定程序MODI1.C 中函数fun 功效是: 依 | 返回。 | 第六十八套 | ||
据整形形参m=1,计算以下公式值。 | 第1 处 while (t<=999) | 1 程序填空 | ||
m=1+1/2*2+1/3*3+1/4*4…1/m*m | 第 | 2 处 | s1=t%10; | 给定程序中, 函数fun 功效是: 将形参n 中, |
比如, 若m 中值为5, 则应输出1.463611 | s2=(t/10)%10;s3=t/100; | 个位上为偶数数取出, 并按原来从高位到 | ||
2 /**found**/ | 第3 处 if (s1+s2+s3==x) | 低位相反次序组成一个新数。并作为函 | ||
for (i =2 ; i<= m; i++) | 2 程序修改 | 数值返回。 | ||
/**found**/ | 给定程序MODI1.C 中函数fun 功效是: 低 | 1 第1 处 if (t%2==0) | ||
位开始取出长整形变量s 中偶数位上数, | 第2 处 x=10*x+t; | |||
y+=1. 0/ ( i* i) ; | 依次组成一个新数放在t 中。高位仍在 | 第3 处 n=n/10; | ||
3 程序设计 | 高位, 低位仍在低位。 | 2 程序修改 | ||
编写函数fun, 函数功效是: 实现B=A+A’ | /**found**/ | 给定程序MODI1.C 中函数fun 功效是: 将 | ||
即把矩阵A加上A转置, 存放在矩阵B中。 | void fun (long s, long *t) | 长整数中每一位上为奇数数依次取出, 组 | ||
计算结果在main 函数中输出。 | /**found**/ | 成一个心数放在t 中。高位仍在高位, 低 | ||
void fun ( int a [3] [3], int b [3] [3]) | while (s>0) | 位仍在低位。 | ||
{ | 3 程序设计 | /**found**/ | ||
Int c [3] [3]; | 学生统计由学号和学生成家组成, N 名学 | *t=0; | ||
int i,j; | 生数据已在主函数中放入结构体数组s 中, | |||
/**found**/ | 三角形, 函数返回2, 若组成通常三角形, | 第1 处 switch (n%10) |
if (d%2!=0) | 则函数返回1, 若不能组成三角形, 则函 | 第2 处 case 1: c1++; break; |
3 程序设计 | 数返回0. | 第3 处 case 2: c2++; break; |
编写一个函数fun, 它功效是: 实现两个 | /**found**/ | 2 程序修改 |
字符串连续（不使用库函数strcat）, 即 | int fun (int a,int b, int c) | 给定程序modi1.c 中函数fun 函数功效是: |
把p2所指字符串连接到p1所指字符串后。 | 统计一个无符号整数中各位数字值为零个 |
/**found**/
void fun (char p[], char p2[]) 数,经过形参传回主函数并把该整数中各 else return 1;
{ 位上最大数字值作为函数值返回。
3程序设计
/**found**/ char *p=p1;
编写一个函数fun,它功效是:计算并输
while (*p)p++; if (t==0) 出3到n之间（含3和n）全部素数平方
while (*p2)*p++=*p2++;
/**found**/ 根之和。
*p=0; *zero =count;
double fun (int n)
} 3程序设计
{
第六十九套 请编写一个函数fun,它功效是:计算并 int i, j=0;
1程序填空 输出下列多项式值:
double s=0;
甲乙丙丁四人同时开始放鞭炮,甲每隔t1 doublefun (int n)
for (i=3;i<=n; i++){
{
秒放一个,乙每隔t2秒放一个,丙每隔t3 for (j=2; j<i;j++)
秒放一个,丁每隔t4秒放一个,每人各放 double s=0, t=1;
if( i %j==0)break;
n次。函数fun功效是经过形参提供信息, int i ;
if (j==i)
求出总共听到多少次鞭炮声作为函数值返 for ( i=1; i<=n;i++)
s =s+sqrt ( i );
回。注意,当多个鞭炮同时炸响,只算一 { t*=1;
}
声响声,第一声响是在第0秒。 s+=1. 0/t;
return s;
1第1处maxt =t1; }
}
第2处for(t=1; t< max t*(n-1); t++) return s;
第七十套
}
第3处returncount; 1程序填空
2程序修改 第七十一套
给定程序中,函数fun功效是:统计长整
给定程序MODI1.C中函数fun功效是:依 1程序填空
数n各个位数上出现数1、2、3次数,
据输入三个边长（整值型）,判定能否组 给定程序中,函数fun功效是:反形参a所 并经过外部（全局）变量c1、c2、c3返
成三角形,还是等腰三角形。若能够组 指数组中最大值放在a[0]中,接着求出a 回主函数。
成等边三角形函数返回3,若能组成等腰 所指数组中最小值放在a[1]中;再把a所指
数组元素中次大值放在a[2]中, 吧a 组元 | for( i=0 ; i<N | : i++) | 中从键盘给n输入8后, 输出为s=0.662872。 |
素中次小值放在a[3]中, 依这类推。 | if (a [i]. s<ave) | 注意: 要求n 值大于1 但小于10. | |
第1 处 void fun (int *a, int n) | { b[*n]=a[ i ]; | double fun (int n) | |
第2 处 for (i=0; i<n-1; i+=2) | (*n)++; | { | |
第3 处 for (j=i+1; j<n;j++) | } | int i ; | |
2 程序修改 | return ave; | double sum=0.0; | |
给定程序modi1.c 中函数fun 函数功效是: | } | if (n>1&&n<=100) | |
按次序给s 所指数组中元素给予从2 开始 | 第七十二套 | { for ( i=1 ; i<=n; i++) | |
偶数, 然后再按次序对每五个元素求平均 | 1 程序填空 | sum +=1. 0/(2*i - 1)- 1. 0/(2* i); | |
值, 并将这些值依次存放在w 所指数组中, | 给定程序中, 函数fun 功效是: 统计全部 | } | |
若s 所指数组中元素个数不是5 倍数, 多 | <=n（n>2）素数个数, 素数个数作为函数 | return sum; | |
出部分忽略不计。 | 值返回。 | } | |
/**found**/ | 第1 处 for ( j=2; j<i ;j++) | 第七十三套 | |
sum=0.0; | 第2 处 if (i%j==0) | ||
1程序填空
/**found**/ 第3处if(j>=i)
给定程序中,函数fun功效是:
if((i+1)%5==0) 2 程序修改
f(x)=1+x+x2/+…+xn/n!直到|x/n!|<10-6,若
3程序编写 数列中,第一项值为3,后一项全部比前
x=2.5,函数值为:12.182494。
学生统计由学号和成绩组成,N名学生数 一项增5;给定程序modi1.c中函数fun函
第1处f=1.0+x ;
据已在主函数中放入结构体数组s中,低 数功效是:计算前n（4<n<50）项累加和;
第2处t*=x/n
于平均分学生人数经过形参n传回。平 每累加一次把被4除后余2目前累加值放
第3处f+=t;
均分经过函数值返回。 入数组中,符合此条件累加值个数作为函
2程序修改
doublefun (STREC *a, STREC *b, int 数值返回主函数。
给定程序MODI1.C中fun函数功效是:
*n) /**found**/
计算n5次方值（要求n值大于2小于8）,
{ sum =0; j=0;
经过形参指针传向主函数,并计算该值个
int i;
位、十位、百位上数字之和作为函数值
doubleave=0. 0; /**found**/
返回。
*n=0; if (sum %4==2)
/**found**/
for(i=0; i<N; i++) 3程序设计
d=1; s=0 ;
ave=ave=a[ i ]. S; 请编写一个函数fun,它功效是:计算并
/**found**/
ave/=N; 输出下列多项式值:……比如,在主函数
d=d/10 ; | /**found**/ | 2 程序修改 |
3 程序设计 | c=k%10; | 给定程序MODI1.C 中fun 函数功效 |
请编写一个函数fun, 它功效是: 计算并 | 3 程序设计 | 是: 将字符串中字符按逆序输出, 但不改 |
输出给定数组（长度为9）中每相邻两个 | 请编写一个函数fun, 它功效是: 计算并 | 变字符串中内容。 |
元素之平均值平方根之和。 | 输出给定10 个数方差: 比如, 给定10 个数 | /**found**/ |
double fun (double x[9]) | 为95.0、 .0、 76.0、 65.0、 88.0、 | fun (char *a ) |
{ | 72.0、 85.0、 81.0、 90.0、 56.0、 1 输 | /**found**/ |
int i ; | 出为s=11.730729. | printf ( "%c" , *a); |
double avg=0. 0, sum=0. 0 ; | double fun (double x [10]) | 3 程序设计 |
for (i=0 ; i<8 ; i++){ | { | 编写一个函数fun, 它功效是: 比较 |
avg =( x [i] + x [i+1])/2; | Int i; | 两个字符串长度（不得调用C 语言提供求 |
sum += sqrt ( avg); | double avg =0. 0, sum =0. 0, abs =0. 0, fc; | 字符串长度函数）, 函数返回较长字符串。 |
} | for (i=0; i<10; i ++) | 若两个字符串长度相同, 则返回第一个字 |
rturn sum ; | sum +=x[ i ]; | 符串。 |
} | avg =sum/10; | char *fun (char *s, char *t) |
第七十四套 | for (i=0; i<10; i++) | { |
1 程序填空 | abs +=(x[i]- avg)*(x [i ] -avg ); | int i ; |
给定程序中, 函数fun 功效是: 计算 | fc =sqrt (abs/10); | char *p =s ,*q=t; |
f(x)=1+x+x2/+…+xn/n!前n 项。若x=2.5, | return fc ; | for (i=0; *p&&*q ; i++){ |
函数值为: 12.182340。 | } | p++ ; q++; |
第1 处 t=1 ; | 第七十五套 | } |
第2 处 for (i=1 ;i<n ;i++) | 1 程序填空 | if (*p==0&&*q==0) |
第3 处 t*=x/ i ; | 给定程序中已经建立一个带有头结 | return s; |
2 程序修改 | 点单项链表, 在main 函数中将数次调用 | if (*p) return s; |
给定程序MODI1.C 中fun 函数功效是: | fun 函数, 每调用一次fun 函数, 输出链表 | else return t; |
找出100 至n（n 小于1000）之间三位数 | 尾部结点中数据, 并释放该结点, 使链表 | } |
字相等全部整数, 把这些整数放在s 所指 | 缩短。 | 第七十六套 |
数组中, 个数作为函数值返回。 | 第1 处 t=t- >next; | 1 程序填空 |
/**found**/ | 第2 处 printf ("%d" , t->data); | 在给定程序中, 函数fun 功效是在形参s 所 |
k= i ; | 第3 处 free (t); | 指字符串中寻求和参数c 相同字符, 并在 |
其后插入一个和之相同字符, 若找不到相 | } | if (p[0]== ' - ') |
同字符则函数不做任何处理。 | 第七十七套 | { t= - 1; len--;p++;} |
第1 处for (i=0; s[ i ]!='\0' ;i++) | 1 程序填空 | else t=1; |
第2 处 n=0; | 给定程序中, 函数fun 功效是: 将形参n 所 | While (*p) |
第3 处 s[j+1] =c ; | 指变量中, 各位上为偶数数去除, 剩下数 | x =x*10 - 48 +(*p++); |
2 程序修改 | 按原来从高位到低位次序组成一个新数, | return x*t; |
在主函数中键盘输入若干个数放入数组中, | 并经过形参指针n 传回所指变量。如输 | } |
用0 结束输入并放在最终一个元素中。 | 入一个数: 27638496, 新数为729 | 第七十八套 |
给定程序MODI1.C 中函数fun 功效是: | 第1 处 { t=*n%10 ; | 1 给定程序中, 函数fun 功效是将形参给 |
计算数组元素中值为正数平均值（不包含 | 第2 处 if (t %2!=0) | 定字符串、整数、浮点数写到文本文件 |
零） | 第3 处 *n=x ; | 中, 再用字符方法以后文本文件中逐一读 |
/**found**/ | 2 程序修改 | 入并显示在终端屏幕上。请在程序下划 |
double sum =0. 0; | 给定程序modi1.c 中函数fun 函数功效是: | 线处填入正确内容分并把下划线删除, 使 |
/**found**/ | 计算n! 。比如, 给n 输入5, 则输出 | 得程序得出正确结果。 |
sum/=c; | 120.000000。 | 注意: 源程序存放在考生文件夹下 |
3 程序设计 | /**found**/ | BLANK1.C 中。 |
编写程序fun, 它功效是: 依据以下分工 | if (n==0) | 第1 处 FILE * fp; |
计算s, 计算结果作为函数值返回: n 经过 | /**found**/ | 第2 处 while (!feof (fp)) { |
形参传入。 | result *=n--; | 第3 处 putchar (ch) ; ch= fgetc (fp); } |
float fun (int n) | 3 程序设计 | 2 程序修改 |
{ | 请编写一个函数fun, 它功效是: 将一个 | 给点那个程序MODI1.C中函数fun功效是: |
int i, j, t; | 数字字符转换为一个整数（不得调用C 语 | 依次取出字符串中全部数字字符, 形成新 |
float s=0; | 言提供将字符转换为整数函数）。比如, | 字符串, 并替换原字符串。 |
for(i=1; i<=n;i++){ | 若输入字符串“-1234”, 则函数将它转换 | /**found**/ |
t=0; | 为整数值-1234. | s [j++]=s [ i ]; |
for (j=1; j<=i; j++) | long fun (char *p) | /**found**/ |
t+=j; | { | s [ j ]= ' \ 0 ' ; |
s=s+1. 0/t; | int i, len , t; | 3 程序设计题 |
} | long x=0; | 请编写函数fun, 函数功效是: 将M 行N |
return s; | len =strlen (p); | 列二维数组中字符数据, 按列次序依次放 |
到一个字符串中。 | 包含头结点）数据域中最大值, 而且作为 | x1=5.000000, | x2=3.000000, | |
void fun (char s[] [N] , char *b) | 函数值返回。 | 请更正函数fun 中所指部位 | x1*x1+x1*x2=40.000000 请在程序下划 | |
{ | 错误, 使它能得出正确结果。 | 线处填入正确内容并把下划线删除, 使程 | ||
int i, j, n=0; | /**found**/ | 序得出正确结果。 | ||
for (i=0; i<N; i++) | p= h - >next; | 第1 处 double ( *f ) () ; | ||
/*请填写其对应语句完成其功效*/ | /**found**/ | 第2 处 f = f 1; | ||
{ | p=p->next; | 第3 处 f = f 2; | ||
for ( j=0 ; j<M; j++) { | 3 程序设计 | 2 程序修改 | ||
b [n] =s [j ] [i ]; | 请编写函数fun, 函数功效是: 将M 行N | 给定程序MODI1.C 是建立一个带头点单 | ||
n= i *M+j+1; | 列二维数组中数据, 按行次序依次放到一 | 向链表, 并用随机函数为各结点赋值。 | ||
} | 维数组中。一维数组中数据个数存在形 | 函数fun 功效是将单向链表结点（不包含 | ||
} | 参n 所指存放单元中。 | 头结点）数据域为偶数值累加起来, 而且 | ||
b [n] = ' \0 ' ; | void fun ( int (*s) [10] , int *b, int *n, int | 作为函数值返回。 | 请更正函数fun 中指定 | |
} | mm, int nn) | 部位错误, 使它能得出正确结果。 | ||
第七十九套 | { | /**found**/ | ||
1 程序填空 | int i, j, k ; | p= h - >next; | ||
给定程序中, 函数fun 功效是将带头结点 | for (i=0 ; i<mm; i++) | |||
/**found**/单项链表结点数据域中数据从小到大排序, for(j=0; j<nn; j++)
p= p - >next;
即若原链表节点数据域从头至尾数据为: | { | 3 | 程序设计 |
10、 4、 2、 8、 6, 排序后链表结点数 | k=i *nn +j ; |
请编写函数fun,函数功效是:判定字符据域从头至尾数据为:2、4、6、8、 b [k] =s [ i ] [j ];
串是否为回文？是,函数返回1,主函数10。请在程序下划线处填入正确内容并 }
中输出:YES, 不然返回0,主函数中输出 *n= mm*nn;把下划线删除,使程序得出正确结果。
NO。回文是指顺读t和倒全部全部一样第1处p= h - >next ; }
字符串。
第2处q=p - > next; 第八十套
intfun ( char * str) 第3处if(p - > data >=q - >data)) 1程序填空
{
2程序修改 给定程序中,函数fun功效是用函数指针
inti , j= strlen (str) ;给定程序MODI1.C是建立一个带头结点 指向要调用函数,并进行调用。在要求
for ( i=0 ; i < j /2 ; i++)
单项链表, 并用随机函数为各节点数据赋 | 2 处使f 指向函数f1, 在 3 处使f 指向函 | if | (str [ i ] ! = str [j- i - 1]) |
值。函数fun作用是求出单项链表结点（不 | 数f2.当调用正确时, 程序输出: |
return 0 ; | int fun ( int a [ ] , int n ) | tt++; | |||
return 1 ; | { | 3 | 程序设计 | ||
} | int i , j =1 , k=a [0]; | 请编写函数fun, 函数功效是, 移动字符串 | |||
第八十一套 | for ( i = 1; i<n ; i ++) | 中内容, 移动规则以下: 把第一到m 个字 | |||
1 程序填空 | if ( k!=a [ i ]) { | 符, 平均移到字符串醉最终, 把m+1 个到 | |||
给定程序中, 函数fun 功效是将参数给定 | a [j++] =a [ i ] ; | 最终字符移到字符串前部。 | |||
字符串、整数、浮点数写到文件中, 再 | k = a [ i ] ; } | void fun (char *w, int m) | |||
用字符串方法以后文本文件中逐一读入, | a [ j ] = 0; | { | |||
并调用库函数atof 和atof 将字符串换成对 | return j ; | int i ; | |||
应整数和浮点数, 然后将其显示在屏幕上。 | } | for ( i=0 ; i<m ; i++) | |||
第1 处 FILE * fp ; | 第八十二套 | fun 1 (w); | |||
第2 处 fclose (fp) ; | 1 | 程序填空 | } | ||
第3 处 fscanf ( fp , "%s % s % s" ,str, | 给定程序中, 函数 fun 功效是依据形参i 值 | 第八十三套 | |||
str1 ,str2); | 返回某个函数年值。当调用正确时, 程 | 1 程序经过定义并赋初值方法, 利用结构 | |||
2 程序修改 | 序输出: x1=5.000000 | 体变量存放了一名学生信息, 函数fun 功 | |||
给定程序MODI1.C 中函数fun 功效是: | 第1 处 double fun ( int i , double x , double | 效是输出这位学生信息。 | |||
对N 名学生学生成绩, 按从高到低次序找 | y) | 第1 处 void show (STU tt) | |||
出前m（m<10）名学生来, 将这些学生 | 第2 处 renturn f1 (x) ; | 第2 处 printf ("%5. if " , tt . score [ i ]) ; | |||
数据存放在一个动态分配连续存放区中, | 第3 处 return f2 (x, y) ; | 第3 处 show (std) | |||
此存放区首地址作为函数值返回。 | 2 | 程序修改 | 2 | 程序修改 | |
/**found**/ | 给定程序MODI1.C 中函数fun 功效是: | 给定程序MODI1.C 中函数fun 功效是: | |||
t= ( STU *) calloc (sizeof (STU),m) ; | 比较两个字符串, 将长那个字符串首地址 | 求出数组中最大数和次最大数, 并把最大 | |||
/**found**/ | 作为函数值返回。 | 数和a[0]中数对调、次最大数和a[1]中数 | |||
/**found**/ | 对调。 | ||||
t [k] =b [ j ] ; | char *fun (char *s ,char *t) | /**found**/ | |||
3 | 程序设计 | /**found**/ | m= i ; | ||
请编写函数fun, 函数功效是, 删去一维数 | |||||
组中全部相同数, 使之只剩一个。数组 | ss++; | /**found**/ | |||
中数已按从小到大次序排序, 函数返回删 | /**found**/ | if ( a [k]>a [m]) m=k; | |||
除后数组中数据个数。 | 3 | 程序设计 | |||
请编写一个unsigned fun（unsigned | /**found**/ | 第2 处 if ( s [ i ] . sno >s [ j ] .sno) | |||
w ）, w 是一个大雨于10 无符号整数, 若 | p= ( NODE *) malloc | 第3 处 fwrite (s,sizeof (STU), N, fp); | |||
w 是n（n>=2）位整数, 函数求出w 后n-1 | (sizeof(NODE)); | 2 程序修改 | |||
位数作为函数值返回。 | /**found**/ | 给定程序MODI1.C 中函数fun 功效是: | |||
比如: w 值为5923, 则函数返回923; w 值 | 在字符串最前端加入n 个*号, 形成新串, | ||||
为923, 则函数返回23. | return h; | 而且覆盖原串。注意: 字符串长度最长 | |||
unsigned fun ( unsigned w) | 3 | 程序设计 | 许可为79. | ||
{ | 请编写函数fun, 函数功效是, 统计一行字 | /**found**/ | |||
if ( w >=10000) return w%10000; | 符串中单词个数, 作为函数值返回。一 | p=s ; | |||
if ( w >=1000) return w%1000; | 行字符串在主函数中输入, 要求全部单词 | /**found**/ | |||
if ( w >=100) return w%100; | 有小写字母组成, 单词之间由若干个空格 | ||||
return w%10; | 隔开, 一行开始没有空格。 | while (*p++) | |||
} | int fun ( char *s ) | 3 程序设计 | |||
第八十四套 | { | 请编写函数fun, 函数功效是: 统计各年 | |||
1 程序填空 | int k=1; | 纪段人数, N 个年纪能经过调用随机函数 | |||
程序经过定义学生结构体变量, 存放了学 | while (*s) | 取得, 并放在主函数age 数组中: 要求函 | |||
生学号、姓名和三门课成绩。全部学生 | { if (*s==' ')k++; s++; } | 数把0 到9 岁年纪段人数放在d[0]zhong | |||
数据均以二进制方法输出到文件中。函 | return k ; | 把10—19 岁年纪段人数放在d[1]中, 其 | |||
数fun 功效是重写形参filename 所指文件 | } | 它依这类推, 把100 岁（含100 岁）年纪 | |||
中最终一个学生数据, 即用新学生数据覆 | 第八十五套 | 段人数放在d[10]中。结果在主函数中输 | |||
盖该学生原来数据, 其它学生数据不变。 | 1 程序填空 | 出。 | |||
第1 处 fp =fopen ( filename , " rb+" ) | 程序经过定义学生结构体变量, 存放了 | void fun ( int *a , int *b) | |||
第2 处 fseek (fp ,-1L*sizeof (STU), | 学生学号、姓名和三门课成绩。全部学 | { | |||
SEEK_END); | 生数据均以二进制方法输出到文件中。 | int i , j ; | |||
第3 处 fwrite ( &n, sizeof (STU), 1, fp) ; | 函数fun 功效是从形参filename 所指文件 | for ( i=0; i<M ; i++); b[ i ]=0; | |||
2 | 程序修改 | 中读入学生书数据, 并根据从小到大排序 | for ( i=0; i<N; i++) | ||
给定程序MODI1.C 中函数Creatlink 功效 | 后, 再用二进制方法把排序后学生数据输 | { j=a [ i ]/10; | |||
是创建带头结点单向链表, 并为各结点数 | 出到filename 所指文件中, 覆盖原来文件 | if ( j>10) b [M-1]++; | |||
据域赋0 到m-1 值。 | 请更正函数Creatlink | 内容。 | else b [j ]++; | ||
中指定部位错误, 使它能得出正确结果。 | 第1 处 fp =fopen ( filename , " rb" ); | } | |||
} | { | 对字符串中头两个元素进行排序, 然后把 | |
第八十六套 | int i, j, np=0; | 第三个字符插入到前两个字符中, 插入后 | |
1 程序填空 | for ( i=0; i<nn; i++) | 前三个字符仍然有序; 再把第四个字符插 | |
给定程序中, 函数fun 功效是将不代头结 | for ( j=0; j<mm; j++) | 入到前三个字符中, ……。待排序字符 | |
点单向链表逆置。即若原链表中从头至 | { | 串已在主函数中给予。 | 请更正函数fun 中 |
尾结点数据域依次为: 2、 4、 6、 8、 | b[np] = s [ j ] [ i ]; np=i*mm+j+1; | 指定部位错误, 使它能得出真确结果。 | |
10, 逆置后, 从头至尾结点数据域依次为: | } | /**found**/ | |
10、 8、 6、 4、 2.请在程序下划线处 | *n=np ; | n=strlen (aa); | |
填入正确内容并把下划线删除, 使程序得 | } | ||
/**found**/
出正确结果。 第八十七套
ch =aa [i];
第1处NODE* fun (NODE *h) 1程序填空
3程序设计
第2处r=q- >next ;
程序经过定义学生结构体变量,存放了学 N名学生成绩已在主函数中放入一个带头 第3处q=r; 生学号、姓名和三门课成绩。全部学生
结点链表结构中,h指向链表头结点。请2程序修改 数据均以二进制方法输出到student.dat文
编写函数fun,它功效是:找出学生最高
给定程序MODI1.C 中函数fun 功效是: | 件中。 | 函数fun 功效是从指定文件中找出 |
分,由函数值返回。
将s所指字符串中在奇数位置字符或 指定学号学生数据,读入此学生数据,对
doublefun ( STREC *h ) ASCII码为偶数字符放入t所指数组中（要 该生分数进行修改,使每门分数加3分,
{
求第一个字符放在第0位中）
修改后重写文件中该学生数据,即用该学 double max=h ->s ; /**found**/ 生背后数据覆盖原数据,其它学生数据不
STREC *p ; if ( i % 2 || s [ i ]%2==0 ) 变;若找不到,则什么全部不做。请在程
p=h->next ; 序下划线处填入正确内容并把下划线删除,
/**found**/ while (p) 使程序得出正确结果。
t[ j ]= ' \0 ' ; { if (p-s>max) 第1处while(!feof (fp))
3程序设计 max=p->s ; 第2处if(n. sno ==sno) break ;
请编写函数fun,函数功效是:将M行N p=p->nest; 第3处fseek(fp, -1L*sizeof(STU),SEEK
列二维数组中数据,按列次序依次放到一 }
CUR);
维数组中。函数fun中给出语句仅供参考。 return max ; 2程序修改
#include <stdio. h> }
给定程序MODI1.C中函数fun功效是:
void fun ( int (*s) [10] , int *b , int *n, 第八十八套 利用插入排序法对字符串中字符按从小到
intmm, int nn)
大次序进行排序, 插入法基础算法是: 先 | 1 程序填空 |
给定程序中, 函数fun 功效是调用随机函 | 所指变量中。 Ss 所指字符串数组m | 给定程序中, 函数fun 功效是: 求出形参ss | |
数产生20 个互不相同整数放在形参a 所指 | 个字符串, 且串长>N。 | 所指字符串数组中最长字符串长度, 将其 | |
数组中（此数组在主函数中已置0）。 | 第1 处 int fun( char (*ss)[N], int *n) | 它字符串右边用字符*补齐, 使其和最长 | |
第1 处 while (n<N) | 第2 处 if ( i==0) *n=len; | 字符串等长。 Ss 所指字符串数组中有M | |
第2 处 if ( x==a[ i ]) break ; | 第3 处 *n=len; | 个字符串, 且串长<N。请在程序下划线 | |
第3 处 if ( i==n) { a[n] =x ; n++;} | 2 程序修改 | 处填入正确内容并把下划线删除, 使程序 | |
2 | 程序修改 | 给定程序MODI1.C 中函数fun 功效是: | 得出正确结果。 |
给定程序MODI1.C 中函数fun 功效是: | 依据形参m 计算以下公式值。比如, 若 | 第一处 n=strlen(ss[i]); | |
先从键盘上输入一个3 行3 列矩阵各个元 | 输入5, 则应输出2.283333 | 第二处 ss[i][n+j]=’*’; | |
素值, 然后输出主对角线元素之和。 | /**found**/ | 第三处 ss[i][n+j+1]=’\0’; | |
/**found**/ | t+=1. 0/ i ; | 2 程序修改 | |
sum=0 | /**found**/ | 给定程序MODI1.C 中函数fun 功效是: | |
将p 所指字符串中每个单词最终一个字母 | |||
/**found**/ | return t; | 改成大写。（这里“单词”是指由空格隔 | |
scanf ("%d" , &a [ i ] [ j ]) ; | 3 程序设计 | 开字符串）。请更正程序中错误之处, 使 | |
3 | 程序设计 | 编写一个函数, 该函数能够统计一个长度 | 它能得出正确结果。 |
编写程序, 实现矩阵（3 行3 列）转置（即 | 为2 字符串在另一个字符串中出现次数。 | /**found**/ | |
行列交换） | int fun (char *str, char *substr) | if(*p= =’ ’) | |
int fun ( int array[3] [3]) | { | /**found**/ | |
{ | int cnt =0 ; | *(p-1)=toupper(*(p-1)); | |
int i, j, arr [3] [3]; | char *p =str, *q ; | 3 请编写函数fun 对长度为7 个字符字符串, | |
memcpy(arr,array,9*sizeof(int) ); | while (*p) { | 除首、尾字符外, 将其它5 个字符ASCII | |
for ( i=0; i<3; i++) | q=strstr (p,substr) ; | 码降序排列。 | |
for ( j=0; j<3; j++) | if (q==NULL) break ; | int fun(char *s,int num) | |
array [ i ] [ j ] =arr [ j ] [ i ]; | p=q +strlen (substr) ; | { | |
第八十九套 | cnt++; | char ch; | |
1 程序填空 | } | int i,j; | |
给定程序中, 函数fun 功效是: 求ss 所知 | for(i=1;i<6;i++) | ||
第九十套
字符串数组中长度最长字符串所在行下标, for(j=i+1;j<6;j++)
1程序填空
作为函数值返回,并把其串长放在形参n {
if(*(s+i)<(s+j)) | 数已在主函数中给予。 | /**found**/ | |
{ | void fun(int tt[M][N],int pp[N]) | *b=*b+1; | |
ch=*(s+j); | { | 3 程序设计 | |
*(s+j)=*(s+i); | int i,j,min,k; | 请编写函数fun, 函数功效是: 使用实型 | |
*(s+i)=ch; | for(i=0;i<N;i++) | 整数保留2 位小数, 并对第三位进行四舍 | |
}}} | { | 五入（要求实型数为正数） | |
第九十一套 | min=tt[0][i];k=0; | float fun(float h) | |
1 程序填空 | for(j=1;j<M;j++) | { | |
给定程序中, 函数fun 功效是: 将形参std | if(min>tt[j][i]) | long w; | |
所指结构体数组中年纪最大者数据作为函 | {min=tt[j][i]; | w=h*100+1.5; | |
数值返回, 并在main 函数中输出。 | k=j; | return (float)w/100; | |
第一处 max=*std; | } | } | |
第二处 if(max.age<std[i].age) | pp[i]=tt[k][i]; | 第九十三套 | |
max=std[i]; | } | 1 程序填空 | |
第三处 | } | 给定程序中, 函数fun 功效是: 找出 | |
printf(“\nName:%s,Age:%d\n”,max.name,m | 第九十二套 | 100—x（x<=999）之间各位上数字之和为 | |
ax.age); | 1 程序填空 | 15 全部整数, 然后输出, 符合条件整数个 | |
2 程序修改 | 给定程序中, 函数fun 功效是: 将a 和b 所 | 数作为函数值返回。 | |
给定程序MODI1.C 中函数fun 功效是: | 指两字符串转达换成面值相同整数, 并进 | 第一处 n=0; | |
实现两个整数交换。 | 比如给a 和b 分别输 | 行相加作为函数值返回, 要求字符串只含 | 第二处 while(t<=x) |
入: 60 和65, 输出为: a=65 b=60 | 9 个以下数字字符。 | 第三处 t++; | |
/**found**/ | 第一处 d=d*10+*s-‘0’; | 2 程序修改 | |
void fun(int *a,int *b) | 第二处 s++; | 给定程序MODI1.C 中函数fun 功效是: | |
/**found**/ | 第三处 return ctod(a)+ctod(b); | 先将s 所指字符串中字符按逆序放到t 所 | |
t=*b;*b=*a;*a=t; | 2 程序修改 | 指字符串中, 然后把s 所指字符串中字符 | |
3 程序编写 | 给定程序MODI1.C 中函数fun 功效是: | 按正序连接到t 所指串后面。 | |
请编写一个函数void fun（int t t[M] [N], | 分别统计字符串大写字母和小写字母个数 | /**found**/ | |
int pp [N]）, tt 指向一个M 行N 列二维数 | 和。 | int i,s1; | |
组, 求出二维数组每列中最小元素, 并依 | /**found**/ | /**found**/ | |
次放入pp 所指唯一数组中。二维数组中 | *a=*a+1; | t[i]=s[s1-i-1]; | |
3 程序设计 | 出……比如, 在主函数中从键盘给n 输入 | /**found**/ | |
请编写函数fun, 函数功效是: 将a、 b 中 | 20 后, 输出为s=534.188884。 | 注意: 要求 | for(i=0;i<s1;i++) |
两个两位整数合并形成一个新整数放在c | n 值大于1 但小于100. | /**found**/ | |
中。合并方法是: 将a 中十位和个位数依 | double fun(int n) | t[2*s1]=0; | |
次放在变量c 百位和个位上, b 中十位和个 | { | 3 程序设计 | |
位依次放在变量c 千位和十位上。 | int i; | 请编写函数fun, 函数功效是: 将两个两 | |
void fun(int a,int b,int *c) | double fac=1.0; | 位数正整数a、 b 合并形成一个整数放在 | |
{ | double sum=1.0; | c 中。合并方法是: 将a 十位和个位数依 | |
*c=(b/10)*1000+(a/10)*100+(b%10)*10+(a | for(i=2;i<=n;i++) | 次放在c 位千位和十位上, b 十位和个位数 | |
%10); | {fac+=sqrt(i); | 依次放在c 百位和个位上。 | |
} | sum+=fac; | void fun(int a,int b,long *c) | |
第九十四套 | } | { | |
1 程序填空 | return sum; | *c=(a/10)*1000+(b/10)*100+(a%10)*10+(b | |
给定程序中, 函数fun 功效是: 从三个形 | } | %10); | |
参a、 b、 c 中找出中间那个数, 作为函 | 第九十五章 | } | |
数值返回。 | 1 程序填空 | 第九十六套 | |
第一处 t=a>b? (b>c? b: (a>c? c:a)):((a<c)? | 给定程序中函数fun 功效是: 调用fun 函数 | 1 程序填空 | |
a:((b>c)? c:b)); | 建立班级通讯录。通讯录中统计每位同 | 程序经过定义学生结构体变量, 存放了学 | |
2 程序修改 | 学编号、姓名和电话号码。班级人数和 | 生学号、姓名和三门课成绩。函数fun | |
给定程序MODI1.C 中函数fun 功效是: | 学生信息从键盘读入, 每个人信息作为一 | 功效是: 对形参b 所指结构体变量中数据 | |
首先将大写字母转换为对应小写字母: 若 | 个数据块写到名为mylife5.dat 二进制文件 | 进行修改, 最终在主函数中输出修改后数 | |
小写字母为a—u, 则将其转换为其后第五 | 中。 | 据。 | |
个字母; 若小写字母为v—z, 使其值减21。 | 第一处 int fun(STYPE *std) | 第一处 b->sno=10004; | |
转换后小写字母作为函数值返回。 | 第二处 FILE *fp;int i; | 第二处 strcpy(b->name,”LiJie”); | |
/**found**/ | 第三处 fwrite(&std{i},sizeof(STYPE),1,fp); | 第三处 fun(&t); | |
c=c+32; | 2 程序修改 | 2 程序修改 | |
/**found**/ | 给定程序MODI1.C 中函数fun 功效是: | 给定程序MODI1.C 中函数fun 功效是: | |
c=c+5; | 先将在字符串s 中字符按正次序放到t 串 | 应用递归算法求形参a 平方根。求平方 | |
3 程序设计 | 中, 然后把s 中字符按逆次序放到她串后 | 根迭代公式以下: 比如: a 为2 时平方根值 | |
请编写函数fun, 函数功效是: 计算并输 | 面。 | 为1.414214 | |
/**found**/ | 2 程序修改 | 给定程序MODI1.C 中函数fun 功效是: 输 |
double fun(double a,double x0) | 给定程序MODI1.C 中函数fun 功效是: | 出M 行N 列整数方阵, 然后求两条对角线 |
/**found**/ | 求s 值。比如: 当K 为10 时, 函数应为 | 上元素之和, 返回此和数。 |
if(fabs(x1-x0)>0.00001) | 1.533852. | /**found**/ |
3 程序设计 | /**found**/ | int fun(int n,int xx[][M]) |
学生统计由学号和成绩组成, N 名学生数 | float fun(int k) | /**found**/ |
据已在主函数中放入结构体数组s 中, 请 | /**found**/ | printf(“%d”,xx[i][j]); |
编写函数fun, 它功效是: 把高于等于平 | return s; | 3 程序设计 |
均分数学生数据放在b 所指数组中, 并把 | 3 程序设计 | 请编写函数fun, 函数fun 功效是: 将a、 |
人数经过形参n 传回。 | 请编写函数fun, 函数fun 功效是: 计算并 | b 中两位正整数合并形成一个新整数放在 |
double fun(STREC *a,STREC *b,int *n) | 输出下列级数和: 比如, 当n=10 时, 函数 | c 中。合并方法为: 将a 中十位和个位数 |
{ | 值为0.909091. | 依次放在变量c 千位和十位上, b 中十位和 |
double t=0; | double fun(int n) | 个位数依次放在变量c 各位和百位上。 |
int i; | { | void fun(int a,int b,long *c) |
*n=0; | double s=0.0; | { |
for(i=0;i<N;i++) | int i; | *c=(a/10)*1000+(b%10)*100+(a%10)*10+ |
t=t+a[i].s; | for(i=1;i<=n;i++) | （b/10）; |
t=t/N; | s=s+1.0/(i*(i+1)); | 第九十九套 |
for(i=0;i<N;i++) | rerurn s; | 1 程序填空 |
if(a[i].s>t)b[(*n)++]=a[i]; | } | 给定程序中函数fun 功效是: 求出形参aa |
return t; | 第九十八套 | 所指字符串数组中最长字符串长度, 其它 |
} | 1 程序填空 | 字符串左边用字符*补齐, 使其和最长字 |
第九十七套 | 给定程序中函数fun 功效是: 将形参n 中 | 符串等长。字符串数组有M 个字符 |
1 程序填空 | 个位上为偶数取出, 并按原来从高位到低 | 串, 且串长<N。 |
给定程序中函数fun 功效是: 找出形参s 所 | 位次序组成一个新数。并作为函数值返 | 第一处 k=i; |
指字符串中出现频率最高字母（不区分大 | 回。 | 第二处 for(j=len;j>=0;j--) |
小写）, 并统计其出现次数。 | 第一处 i=1; | 第三处 ss[i][j]=’*’; |
第一处 ch=tolower(*s); | 第二处 while(s) | 2 程序修改 |
第二处 k[n]+=1; | 第三处 x=x+t*i; i=i*10; | 给定程序MODI1.C 中函数fun 功效是: |
第三处 if（max<k[n]）max=k[n]; | 2 程序修改 | 计算整数n 阶乘。请更正程序中错误或 |
在下划线处填上合适内容, 删掉下划线, 使它能计算出正确结果。 /**found**/ result *=n--; /**found**/ return result; 3 程序设计 请编写函数fun, 函数fun 功效是: 从s 所 指字符串删除给定字符。同一字母大小 写按不一样字符处理。 int fun(char s[],char c) { char *p=s; int i=0; while(*p) { if(*p!=c)s[i++]=*p; p++;} | 给定程序MODI1.C 中函数fun 功效是: 求 K<13>, 所求阶乘值作为函数值返回。 | |
比如, 若 | K=10, 则应输出3628800 | |
/**found**/ if(k>0) /**found**/ else if(k= =0) 3 程序设计 程序定义了N*N 二维数组, 并在主函数 中自动赋值。请编写函数fun（int a[ ] [N], int n）, 函数功效是: 使数组左下三 角元素中值乘以n。 int fun(int a[][N],int n) {int i,j; for(i=0;i<N;i++) for(j=0;j<=i;j++) a[i][j]*=n; } | ||
s[i]=0;
}
第一百套
1程序填空
给定程序经过定义并赋值方法,利用结构
体变量存放了一名学生学号姓名和3门课
成绩。函数fun功效是将该学生各科成绩
全部乘以一个系统a。
第一处voidmodify(STU *ss,float a)
第二处ss->score[i]*=a;
第三处modify(&std,a);
2程序修改