国二上机考试习题库

一、填空题 考试做题要求：

1、在__1__处填写正确的答案，并将下划线和数字删除。 2、将题目做完之后一定要保存。

3、不能删除/**********found**********/，也不能多行或少行。 1、（循环）给定程序中，函数fun的功能是:在形参ss所指字符串数组中，删除所有串长超过k的字符串，函数返回所剩字符串的个数。ss所指字符串数组中共有N个字符串，且串长小于M。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #define N 5 #define M 10

int fun(char (*ss)[M], int k) { int i,j=0,len;

/**********found**********/ for(i=0; i< __1__ ; i++) { len=strlen(ss[i]);

/**********found**********/ if(len<= __2__)

/**********found**********/ strcpy(ss[j++],__3__); }

return j; }

main()

{ char x[N][M]={\ int i,f;

printf(\

for(i=0;i

printf(\ for(i=0; i

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #define N 4

void fun(int (*a)[N], int *b) { int i,j;

for(i=0; i

/**********found**********/ b[i]= __1__;

for(j=1; j

/**********found**********/

if(b[i] __2__ a[j][i]) b[i]=a[j][i]; } }

main()

{ int x[N][N]={ {12,5,8,7},{6,1,9,3},{1,2,3,4},{2,8,4,3} },y[N],i,j; printf(\ for(i=0;i

{ for(j=0;j

/**********found**********/ fun(__3__);

printf(\

for(i=0; i

1

3、（指针后移）给定程序中，函数fun的功能是：将形参s所指字符串中的数字字符转换成对应的数值，计算出这些数值的累加和作为函数值返回。

例如，形参s所指的字符串为：abs5def126jkm8，程序执行后的输出结果为：22。 请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #include int fun(char *s) { int sum=0; while(*s) {

/**********found**********/

if( isdigit(*s) ) sum+= *s- __1__ ; /**********found**********/ __2__; }

/**********found**********/ return __3__ ; }

main()

{ char s[81]; int n;

printf(\ gets(s); n=fun(s);

printf(\ %d\\n\\n\} 4、（循环）给定程序中，函数fun的功能是：找出100～999之间（含100和999）所有整数中各位上数字之和为x（x为一正整数）的整数,然后输出；符合条件的整数个数作为函数值返回。

例如，当x值为5时，100～999之间各位上数字之和为5的整数有：104、113、122、131、140、203、212、221、230、302、311、320、401、410、500。共有15个。当x值为27时，各位数字之和为27的整数是：999。只有1个。 请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include fun(int x)

{ int n, s1, s2, s3, t; n=0; t=100;

/**********found**********/ while(t<=__1__){

/**********found**********/

s1=t; s2=(__2__); s3=t/100; /**********found**********/ if(s1+s2+s3==__3__) { printf(\ n++; } t++; }

return n; }

main() { int x=-1; while(x<0)

{ printf(\ scanf(\ } printf(\} 5、（函数参数：数组指针）给定程序中，函数fun的功能是建立一个N×N的矩阵。 矩阵元素的构成规律是：最外层元素的值全部为1；从外向内第2层元素的值全部为2；第3层元素的值全部为3，…依次类推。例如，若N=5，生成的矩阵为： 1 1 1 1 1 1 2 2 2 1 1 2 3 2 1 1 2 2 2 1 2

1 1 1 1 1

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #define N 7

/**********found**********/ void fun(int (*a) __1__) { int i,j,k,m;

if(N%2==0) m=N/2 ; else m=N/2+1; for(i=0; i

/**********found**********/ for(j= __2__ ; j

a[k][i]=a[k][N-i-1]= __3__; } }

main()

{ int x[N][N]={0},i,j; fun(x);

printf(\ for(i=0; i

{ for(j=0; j

例如，有10个正数：46 30 32 40 6 17 45 15 48 26，平均值为：30.500000 主函数中输出：46 32 40 45 48

请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #define N 10

double fun(double x[],double *y) { int i,j; double av;

/**********found**********/ av=__1__;

/**********found**********/

for(i=0; i

/**********found**********/ if(x[i]>av) y[__3__]= x[i]; y[j]=-1; return av; }

main()

{ int i; double x[N],y[N];

for(i=0; i

printf(\ for(i=0; y[i]>=0; i++) printf(\ printf(\} 7、（函数参数）给定程序中，函数fun的功能是：将a所指4×3矩阵中第k行的元素与第0行元素交换。 例如，有下列矩阵： 1 2 3 4 5 6 7 8 9 10 11 12

3

若k为2，程序执行结果为： 7 8 9 4 5 6 1 2 3 10 11 12

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #define N 3 #define M 4

/**********found**********/ void fun(int (*a)[N], int __1__) { int i,j,temp ;

/**********found**********/ for(i = 0 ; i < __2__ ; i++) { temp=a[0][i] ;

/**********found**********/ a[0][i] = __3__ ; a[k][i] = temp ; } }

main()

{ int x[M][N]={ {1,2,3},{4,5,6},{7,8,9},{10,11,12} },i,j; printf(\ for(i=0; i

{ for(j=0; j

fun(x,2);

printf(\ for(i=0; i

{ for(j=0; j

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include double f1(double x) { return x*x; }

double f2(double x, double y) { return x*y; }

/**********found**********/

__1__ fun(int i, double x, double y) { if (i==1)

/**********found**********/ return __2__(x); else

/**********found**********/ return __3__(x, y); }

main()

{ double x1=5, x2=3, r; r = fun(1, x1, x2); r += fun(2, x1, x2);

printf(\} 9、（指针与数组）给定程序中，函数fun的功能是：将形参s所指字符串中的所有数字字符顺序前移，其他字符顺序后移，处理后新字符串的首地址作为函数值返回。

例如，s所指字符串为：asd123fgh5##43df， 4

处理后新字符串为：123543asdfgh##df。

请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #include #include char *fun(char *s)

{ int i, j, k, n; char *p, *t; n=strlen(s)+1;

t=(char*)malloc(n*sizeof(char)); p=(char*)malloc(n*sizeof(char)); j=0; k=0;

for(i=0; i

/**********found**********/ p[__1__]=s[i]; j++;} else

{ t[k]=s[i]; k++; } }

/**********found**********/

for(i=0; i<__2__; i++) p[j+i]= t[i]; p[j+k]=0;

/**********found**********/ return __3__; }

main()

{ char s[80];

printf(\ scanf(\ printf(\}

10、给定程序中，函数fun的功能是：在3×4的矩阵中找出在行上最大、在列上最小的那个元素，若没有符合条件的元素则输出相应信息。

例如，有下列矩阵： 1 2 13 4 7 8 10 6 3 5 9 7

程序执行结果为：find: a[2][2]=9

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #define M 3 #define N 4 void fun(int (*a)[N])

{ int i=0,j,find=0,rmax,c,k; while( (i/**********found**********/

rmax=a[i][j]; c= __1__ ; } find=1; k=0;

while(k

if (k!=i && a[k][c]<=rmax) find= __2__ ; k++; }

if(find) printf(\/**********found**********/ __3__ ; }

if(!find) printf(\}

5

main()

{ int x[M][N],i,j;

printf(\ for(i=0; i

for(j=0; j

{ for(j=0; j

fun(x); }

11、程序通过定义学生结构体变量，存储了学生的学号、姓名和3门课的成绩。函数fun的功能是将形参a中的数据进行修改,把修改后的数据作为函数值返回主函数进行输出。

例如：传给形参a的数据中，学号、姓名、和三门课的成绩依次是：10001、\、95、80、88，修改后的数据应为：10002、\、96、81、89。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include struct student { long sno;

char name[10]; float score[3]; };

/**********found**********/ __1__ fun(struct student a) { int i;

a.sno = 10002;

/**********found**********/ strcpy(__2__, \

/**********found**********/ for (i=0; i<3; i++) __3__+= 1; return a; }

main()

{ struct student s={10001,\ int i;

printf(\

printf(\ Name: %s\\nScores: \ for (i=0; i<3; i++) printf(\ printf(\ t = fun(s);

printf(\

printf(\ Name: %s\\nScores: \ for (i=0; i<3; i++) printf(\ printf(\}

12、给定程序中, 函数fun的功能是用函数指针指向要调用的函数,并进行调用。规定在__2__处使f指向函数f1，在__3__处使f指向函数f2。当调用正确时，程序输出:

x1=5.000000, x2=3.000000, x1*x1+x1*x2=40.000000

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include double f1(double x) { return x*x; }

double f2(double x, double y) { return x*y; }

double fun(double a, double b) {

/**********found**********/ __1__ (*f)(); 6

double r1, r2;

/**********found**********/

f = __2__ ; /* point fountion f1 */ r1 = f(a);

/**********found**********/

f = __3__ ; /* point fountion f2 */ r2 = (*f)(a, b); return r1 + r2; }

main()

{ double x1=5, x2=3, r; r = fun(x1, x2);

printf(\ x2=%f, x1*x1+x1*x2=%f\\n\}

13、程序通过定义学生结构体数组，存储了若干名学生的学号、姓名和3门课的成绩。函数fun的功能是将存放学生数据的结构体数组，按照姓名的字典序（从小到大）排序。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include struct student { long sno;

char name[10]; float score[3]; };

void fun(struct student a[], int n) {

/**********found**********/ __1__ t; int i, j;

/**********found**********/ for (i=0; i<__2__; i++) for (j=i+1; j

/**********found**********/ if (strcmp(__3__) > 0)

{ t = a[i]; a[i] = a[j]; a[j] = t; } }

main()

{ struct student s[4]={{10001,\

{10002,\{10003,\ {10004,\

int i, j;

printf(\ for (j=0; j<4; j++)

{ printf(\ Name: %-8s Scores: \ for (i=0; i<3; i++) printf(\ printf(\ }

fun(s, 4);

printf(\ for (j=0; j<4; j++)

{ printf(\ Name: %-8s Scores: \ for (i=0; i<3; i++) printf(\ printf(\ } }

14、给定程序中，函数fun的功能是：计算出形参s所指字符串中包含的单词个数,作为函数值返回。为便于统计，规定各单词之间用空格隔开。

例如，形参s所指的字符串为：This is a C language program.，函数的返回值为6。 请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！

7

#include int fun(char *s) { int n=0, flag=0; while(*s!='\\0')

{ if(*s!=' ' && flag==0) { /**********found**********/ __1__ ; flag=1;}

/**********found**********/ if (*s==' ') flag= __2__ ; /**********found**********/ __3__ ; }

return n; }

main()

{ char str[81]; int n;

printf(\ gets(str); n=fun(str);

printf(\}

15、给定程序中，函数fun的功能是：计算下式前n项的和作为函数值返回。

例如，当形参n的值为10时，函数返回：9.612558。

请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include double fun(int n)

{ int i; double s, t;

/**********found**********/ s=__1__;

/**********found**********/ for(i=1; i<=__2__; i++) { t=2.0*i;

/**********found**********/ s=s+(2.0*i-1)*(2.0*i+1)/__3__; }

return s; }

main()

{ int n=-1; while(n<0)

{ printf(\ } printf(\}

16、给定程序中，函数fun的功能是：将形参n中，各位上为偶数的数取出，并按原来从高位到低位的顺序组成一个新的数，并作为函数值返回。

例如，从主函数输入一个整数：27638496，函数返回值为：26846。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include

unsigned long fun(unsigned long n) { unsigned long x=0, s, i; int t; s=n;

/**********found**********/ i=__1__;

/**********found**********/ while(__2__) { t=s; if(t%2==0){

/**********found**********/ 8

x=x+t*i; i=__3__; }

s=s/10; }

return x; }

main()

{ unsigned long n=-1; while(n>99999999||n<0)

{ printf(\ scanf(\ } printf(\}

17、给定程序中，函数fun的功能是：在形参ss所指字符串数组中查找与形参t所指字符串相同的串，找到后返回该串在字符串数组中的位置（下标值），未找到则返回-1。ss所指字符串数组中共有N个内容不同的字符串，且串长小于M。 请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #define N 5 #define M 8

int fun(char (*ss)[M],char *t) { int i;

/**********found**********/ for(i=0; i< __1__ ; i++) /**********found**********/

if(strcmp(ss[i],t)==0 ) return __2__ ; return -1; }

main()

{ char ch[N][M]={\ int n,i;

printf(\

for(i=0;i

printf(\ \ gets(t); n=fun(ch,t);

/**********found**********/

if(n== __3__) printf(\ else printf(\ %d .\\n\}

18、程序通过定义学生结构体变量，存储了学生的学号、姓名和3门课的成绩。函数fun的功能是对形参b所指结构体变量中的数据进行修改,最后在主函数中输出修改后的数据。

例如: b所指变量t中的学号、姓名、和三门课的成绩依次是: 10002、\、93、85、87，修改后输出t中的数据应为：10004、\、93、85、87。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include struct student { long sno;

char name[10]; float score[3]; };

void fun( struct student *b) { int i;

/**********found**********/ b__1__ = 10004;

/**********found**********/ strcpy(b__2__, \}

main()

{ struct student t={10002,\ int i;

9

printf(\

printf(\ Name: %s\\nScores: \ for (i=0; i<3; i++) printf(\ printf(\

/**********found**********/ fun(__3__);

printf(\

printf(\ Name: %s\\nScores: \ for (i=0; i<3; i++) printf(\ printf(\}

19、给定程序中，函数fun的功能是：找出100至x（x≤999）之间各位上的数字之和为15的所有整数，然后输出；符合条件的整数个数作为函数值返回。

例如，当n值为500时，各位数字之和为15的整数有：159、168、177、186、195、249、258、267、276、285、294、339、348、357、366、375、384、393、429、438、447、456、465、474、483、492。共有26个。 请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include fun(int x)

{ int n, s1, s2, s3, t;

/**********found**********/ n=__1__; t=100;

/**********found**********/ while(t<=__2__)

{ s1=t; s2=(t/10); s3=t/100; if(s1+s2+s3==15) { printf(\ n++; }

/**********found**********/ __3__; }

return n; }

main()

{ int x=-1;

while(x>999||x<0)

{ printf(\ scanf(\ } printf(\}

20、给定程序中，函数fun的功能是将a和b所指的两个字符串转换成面值相同的整数，并进行相加作为函数值返回，规定字符串中只含9个以下数字字符。

例如，主函数中输入字符串：32486和12345，在主函数中输出的函数值为：44831。 请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #include #define N 9

long ctod( char *s ) { long d=0; while(*s)

if(isdigit( *s)) {

/**********found**********/ d=d*10+*s-__1__;

/**********found**********/ __2__; } return d; }

long fun( char *a, char *b ) { 10

/**********found**********/ return __3__; }

main()

{ char s1[N],s2[N]; do

{ printf(\ string s1 : \ while( strlen(s1)>N ); do

{ printf(\ string s2 : \ while( strlen(s2)>N );

printf(\ %ld\\n\} 21、给定程序中，函数fun的功能是：将a所指3×5矩阵中第k列的元素左移到第0列，第k列以后的每列元素行依次左移，原来左边的各列依次绕到右边。 例如，有下列矩阵： 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 若k为2，程序执行结果为 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2

请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #define M 3 #define N 5

void fun(int (*a)[N],int k) { int i,j,p,temp;

/**********found**********/ for(p=1; p<= __1__; p++) for(i=0; i

/**********found**********/

for(j=0; j< __2__ ; j++) a[i][j]=a[i][j+1]; /**********found**********/ a[i][N-1]= __3__; } }

main( )

{ int x[M][N]={ {1,2,3,4,5},{1,2,3,4,5},{1,2,3,4,5} },i,j; printf(\ for(i=0; i

{ for(j=0; j

fun(x,2);

printf(\ for(i=0; i

{ for(j=0; j

22、程序通过定义学生结构体变量，存储了学生的学号、姓名和3门课的成绩。函数fun的功能是将形参a所指结构体变量中的数据赋给函数中的结构体变量b，并修改b中的学号和姓名，最后输出修改后的数据。例如：a所指变量中的学号、姓名、和三门课的成绩依次是：10001、\、95、80、88，则修改后输出b中的数据应为：10002、\、95、80、88。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include

11

struct student { long sno;

char name[10]; float score[3]; };

void fun(struct student a) { struct student b; int i; /**********found**********/ b = __1__; b.sno = 10002;

/**********found**********/ strcpy(__2__, \

printf(\

printf(\ Name: %s\\nScores: \/**********found**********/

for (i=0; i<3; i++) printf(\ b.__3__); printf(\}

main()

{ struct student s={10001,\ int i;

printf(\

printf(\ Name: %s\\nScores: \ for (i=0; i<3; i++) printf(\ s.score[i]); printf(\ fun(s); }

23、给定程序中，函数fun的功能是：把形参s所指字符串中最右边的n个字符复制到形参t所指字符数组中，形成一个新串。若s所指字符串的长度小于n，则将整个字符串复制到形参t所指字符数组中。

例如，形参s所指的字符串为:abcdefgh，n的值为5，程序执行后t所指字符数组中的字符串应为：defgh。 请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #define N 80

void fun(char *s, int n, char *t) { int len,i,j=0; len=strlen(s);

/**********found**********/ if(n>=len) strcpy(__1__); else {

/**********found**********/

for(i=len-n; i<=len-1; i++) t[j++]= __2__ ; /**********found**********/ t[j]= __3__ ; } }

main()

{ char s[N],t[N]; int n;

printf(\ \ printf( \ scanf(\ fun(s,n,t);

printf(\ \ puts(t); }

24、给定程序中,函数fun的功能是将带头节点的单向链表结点数据域中的数据从小到大排序。即若原链表结点数据域从头至尾的数据为：10、4、2、8、6，排序后链表结点数据域从头至尾的数据为：2、4、6、8、10。 请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #define N 6 typedef struct node { 12

int data;

struct node *next; } NODE;

void fun(NODE *h)

{ NODE *p, *q; int t; /**********found**********/ p = __1__ ; while (p) {

/**********found**********/ q = __2__ ; while (q) {

/**********found**********/ if (p->data __3__ q->data)

{ t = p->data; p->data = q->data; q->data = t; } q = q->next; }

p = p->next; } }

NODE *creatlist(int a[])

{ NODE *h,*p,*q; int i; h = (NODE *)malloc(sizeof(NODE)); h->next = NULL; for(i=0; i

{ q=(NODE *)malloc(sizeof(NODE)); q->data=a[i]; q->next = NULL;

if (h->next == NULL) h->next = p = q; else { p->next = q; p = q; } }

return h; }

void outlist(NODE *h) { NODE *p; p = h->next;

if (p==NULL) printf(\ else

{ printf(\ \ do

{ printf(\ } while(p!=NULL); printf(\ } }

main()

{ NODE *head;

int a[N]= {0, 10, 4, 2, 8, 6 }; head=creatlist(a);

printf(\ outlist(head); fun(head);

printf(\ outlist(head); }

25、给定程序中，函数fun的功能是：调用随机函数产生20个互不相同的整数放在形参a所指数组中（此数组在主函数中已置0）。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #define N 20 void fun( int *a) { int i, x, n=0; x=rand() ;

/**********found**********/

13

while (n<__1__)

{ for(i=0; i

/**********found**********/ if( x==a[i] ) __2__; /**********found**********/ if( i==__3__){ a[n]=x; n++; } x=rand() ; } }

main()

{ int x[N]={0} ,i; fun( x );

printf(\ \\n\ for( i=0; i

if((i+1)%5==0)printf(\ }

printf(\}

26、给定程序中，函数fun的功能是:在形参ss所指字符串数组中，查找含有形参substr所指子串的所有字符串并输出，若没找到则输出相应信息。ss所指字符串数组中共有N个字符串，且串长小于M。程序中库函数strstr(s1, s2)的功能是在s1串中查找s2子串，若没有，函数值为0，若有，为非0。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #define N 5 #define M 15

void fun(char (*ss)[M], char *substr) { int i,find=0;

/**********found**********/ for(i=0; i< __1__ ; i++)

/**********found**********/

if( strstr(ss[i], __2__) != NULL )

{ find=1; puts(ss[i]); printf(\ } /**********found**********/

if (find==__3__) printf(\}

main()

{ char x[N][M]={\ int i;

printf(\

for(i=0;i

printf(\ \ gets(str); fun(x,str); }

27、程序通过定义学生结构体变量，存储了学生的学号、姓名和3门课的成绩。函数fun的功能是将形参a所指结构体变量s中的数据进行修改,并把a中地址作为函数值返回主函数，在主函数中输出修改后的数据。

例如：a所指变量s中的学号、姓名、和三门课的成绩依次是：10001、\ZhangSan \、95、80、88，修改后输出t中的数据应为：10002、\、96、81、89。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include struct student { long sno;

char name[10]; float score[3]; };

/**********found**********/ __1__ fun(struct student *a) { int i; 14

a->sno = 10002;

strcpy(a->name, \/**********found**********/ for (i=0; i<3; i++) __2__ += 1; /**********found**********/ return __3__ ; }

main()

{ struct student s={10001,\ *t; int i;

printf(\

printf(\ Name: %s\\nScores: \ for (i=0; i<3; i++) printf(\ printf(\ t = fun(&s);

printf(\

printf(\ Name: %s\\nScores: \ for (i=0; i<3; i++) printf(\ printf(\}

28、给定程序中，函数fun的功能是：找出形参s所指字符串中出现频率最高的字母（不区分大小写），并统计出其出现的次数。

例如，形参s所指的字符串为：abcAbsmaxless，程序执行后的输出结果为： letter 'a' : 3 times letter 's' : 3 times

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #include void fun(char *s)

{ int k[26]={0},n,i,max=0; char ch; while(*s)

{ if( isalpha(*s) ) {

/**********found**********/ ch=tolower(__1__); n=ch-'a';

/**********found**********/ k[n]+= __2__ ; } s++;

/**********found**********/ if(max

printf(\ for(i=0; i<26;i++)

if (k[i]==max) printf(\ \\'%c\\' : %d times\\n\}

main()

{ char s[81];

printf(\ gets(s); fun(s); }

29、给定程序中，函数fun的功能是：判断形参s所指字符串是否是\回文\（Palindrome），若是，函数返回值为1；不是，函数返回值为0。\回文\是正读和反读都一样的字符串（不区分大小写字母）。 例如，LEVEL和Level是\回文\，而LEVLEV不是\回文\。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #include int fun(char *s)

15

{ char *lp,*rp;

/**********found**********/ lp= __1__ ;

rp=s+strlen(s)-1;

while((toupper(*lp)==toupper(*rp)) && (lp

/**********found**********/ if(lp

main()

{ char s[81];

printf(\ \ scanf(\

if(fun(s)) printf(\ else printf(\}

30、给定程序中，函数fun的功能是：计算形参x所指数组中N个数的平均值（规定所有数均为正数）,将所指数组中大于平均值的数据移至数组的前部，小于等于平均值的数据移至x所指数组的后部，平均值作为函数值返回，在主函数中输出平均值和移动后的数据。

例如，有10个正数：46 30 32 40 6 17 45 15 48 26，平均值为：30.500000 移动后的输出为：46 32 40 45 48 30 6 17 15 26

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #define N 10 double fun(double *x)

{ int i, j; double s, av, y[N]; s=0;

for(i=0; i

for(i=j=0; iav ){

/**********found**********/ y[__2__]=x[i]; x[i]=-1;} for(i=0; i

/**********found**********/ if( x[i]!= __3__) y[j++]=x[i]; for(i=0; i

main()

{ int i; double x[N];

for(i=0; i

printf(\ printf(\

for(i=0; i

31、给定程序中，函数fun的功能是将不带头结点的单向链表逆置。即若原链表中从头至尾结点数据域依次为:2、4、6、8、10，逆置后，从头至尾结点数据域依次为：10、8、6、4、2。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #define N 5 typedef struct node { int data;

struct node *next; 16

} NODE;

/**********found**********/ __1__ fun(NODE *h) { NODE *p, *q, *r; p = h;

if (p == NULL) return NULL; q = p->next;

p->next = NULL;

/**********found**********/ while (__2__) { r = q->next; q->next = p; p = q;

/**********found**********/ q = __3__ ; }

return p; }

NODE *creatlist(int a[])

{ NODE *h,*p,*q; int i; h=NULL;

for(i=0; i

{ q=(NODE *)malloc(sizeof(NODE)); q->data=a[i]; q->next = NULL;

if (h == NULL) h = p = q;

else { p->next = q; p = q; } }

return h; }

void outlist(NODE *h) { NODE *p; p=h;

if (p==NULL) printf(\ else

{ printf(\ \ do

{ printf(\ } while(p!=NULL); printf(\ } }

main()

{ NODE *head;

int a[N]={2,4,6,8,10}; head=creatlist(a);

printf(\ outlist(head); head=fun(head);

printf(\ outlist(head);

32、给定程序中，函数fun的功能是:在形参ss所指字符串数组中，将所有串长超过k的字符串中右边的字符删除，只保留左边的k个字符。ss所指字符串数组中共有N个字符串，且串长小于M。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #define N 5 #define M 10

/**********found**********/ void fun(char (*ss) __1__, int k) { int i=0 ;

/**********found**********/

17

while(i< __2__) {

/**********found**********/ ss[i][k]=__3__; i++; } }

main()

{ char x[N][M]={\ int i;

printf(\

for(i=0;i

printf(\ for(i=0; i

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #define N 5

typedef struct student { long sno;

char name[10]; float score[3]; } STU;

void fun(char *filename, long sno) { FILE *fp;

STU n; int i; fp = fopen(filename,\/**********found**********/ while (!__1__)

{ fread(&n, sizeof(STU), 1, fp); /**********found**********/ if (n.sno__2__) break; }

if (!feof(fp))

{ for (i=0; i<3; i++) n.score[i] += 3; /**********found**********/

fseek(fp, -1L*__3__, SEEK_CUR); fwrite(&n, sizeof(STU), 1, fp); }

fclose(fp); }

main()

{ STU t[N]={ {10001,\ {10003,\ {10004,\ {10005,\ int i,j; FILE *fp; fp = fopen(\ fwrite(t, sizeof(STU), N, fp); fclose(fp);

printf(\ fp = fopen(\ fread(ss, sizeof(STU), N, fp); fclose(fp);

for (j=0; j

{ printf(\ Name: %-8s Scores: \ for (i=0; i<3; i++) printf(\ printf(\ }

fun(\ fp = fopen(\ fread(ss, sizeof(STU), N, fp); 18

fclose(fp);

printf(\ for (j=0; j

{ printf(\ Name: %-8s Scores: \ for (i=0; i<3; i++) printf(\ printf(\ } } 34、程序通过定义学生结构体变量，存储了学生的学号、姓名和3门课的成绩。所有学生数据均以二进制方式输出到文件中。函数fun的功能是从形参filename所指的文件中读入学生数据，并按照学号从小到大排序后,再用二进制方式把排序后的学生数据输出到filename所指的文件中，覆盖原来的文件内容。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #define N 5 typedef struct student { long sno;

char name[10]; float score[3]; } STU;

void fun(char *filename) { FILE *fp; int i, j; STU s[N], t;

/**********found**********/ fp = fopen(filename, __1__); fread(s, sizeof(STU), N, fp); fclose(fp);

for (i=0; i

/**********found**********/ if (s[i].sno __2__)

{ t = s[i]; s[i] = s[j]; s[j] = t; } fp = fopen(filename, \/**********found**********/ __3__(s, sizeof(STU), N, fp); fclose(fp); }

main()

{ STU t[N]={ {10005,\ {10002,\ {10001,\ int i,j; FILE *fp; fp = fopen(\ fwrite(t, sizeof(STU), 5, fp); fclose(fp);

printf(\ for (j=0; j

{ printf(\ Name: %-8s Scores: \ for (i=0; i<3; i++) printf(\ printf(\ }

fun(\

printf(\ fp = fopen(\ fread(ss, sizeof(STU), 5, fp); fclose(fp);

for (j=0; j

{ printf(\ Name: %-8s Scores: \ for (i=0; i<3; i++) printf(\ printf(\ } }

35、给定程序中，函数fun的功能是：计算x所指数组中N个数的平均值（规定所有数均为正数）,平均值通过形参返回主

19

函数，将小于平均值且最接近平均值的数作为函数值返回，在主函数中输出。

例如，有10个正数：46 30 32 40 6 17 45 15 48 26，平均值为：30.500000 主函数中输出：m=30.0

请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #define N 10

double fun(double x[],double *av) { int i,j; double d,s; s=0;

for(i=0; i

for(i=0; i

if(x[i]<*av && *av - x[i]<=d){ /**********found**********/ d=*av-x[i]; j=__2__;} /**********found**********/ return __3__; }

main()

{ int i; double x[N],av,m;

for(i=0; i

printf(\ printf(\ printf(\}

36、给定程序中，函数fun的功能是：将形参s所指字符串中的所有字母字符顺序前移，其他字符顺序后移，处理后新字符串的首地址作为函数值返回。

例如，s所指字符串为:asd123fgh543df,处理后新字符串为:asdfghdf12543。

请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #include char *fun(char *s)

{ int i, j, k, n; char *p, *t; n=strlen(s)+1;

t=(char*)malloc(n*sizeof(char)); p=(char*)malloc(n*sizeof(char)); j=0; k=0;

for(i=0; i

{ if(((s[i]>='a')&&(s[i]<='z'))||((s[i]>='A')&&(s[i]<='Z'))) { /**********found**********/ t[j]=__1__; j++;} else

{ p[k]=s[i]; k++; } }

/**********found**********/

for(i=0; i<__2__; i++) t[j+i]=p[i]; /**********found**********/ t[j+k]= __3__; return t; }

main()

{ char s[80];

printf(\ scanf(\ printf(\} 20

37、给定程序中,函数fun的功能是将形参给定的字符串、整数、浮点数写到文本文件中，再用字符方式从此文本文件中逐个读入并显示在终端屏幕上。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include

void fun(char *s, int a, double f) {

/**********found**********/ __1__ fp; char ch;

fp = fopen(\

fprintf(fp, \ fclose(fp);

fp = fopen(\ printf(\ ch = fgetc(fp);

/**********found**********/ while (!feof(__2__)) {

/**********found**********/

putchar(__3__); ch = fgetc(fp); } putchar('\\n'); fclose(fp); }

main()

{ char a[10]=\ int b=12345; double c= 98.76; fun(a,b,c); }

38、给定程序中，函数fun的功能是：将形参n中，各位上为偶数的数取出，并按原来从高位到低位相反的顺序组成一个新的数，并作为函数值返回。

例如，输入一个整数：27638496，函数返回值为：64862。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include

unsigned long fun(unsigned long n) { unsigned long x=0; int t; while(n) { t=n;

/**********found**********/ if(t%2==__1__)

/**********found**********/ x=__2__+t;

/**********found**********/ n=__3__; }

return x; }

main()

{ unsigned long n=-1; while(n>99999999||n<0)

{ printf(\ scanf(\ } printf(\}

39、给定程序中，函数fun的功能是计算下式

例如，若形参e的值为1e-3，函数的返回值2.735678。

21

请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include double fun(double e) { int i; double s, x;

/**********found**********/ s=0; i=__1__; x=1.0;

while(x>e){

/**********found**********/ __2__;

/**********found**********/ x=(2.0*i-1)/((__3__)*(2.0*i)); s=s+x; }

return s; }

main()

{ double e=1e-3;

printf(\}

40、给定程序中，函数fun的功能是：将形参n所指变量中，各位上为偶数的数去除,剩余的数按原来从高位到低位的顺序组成一个新的数，并通过形参指针n传回所指变量。 例如，输入一个数：27638496，新的数：为739。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include

void fun(unsigned long *n)

{ unsigned long x=0, i; int t; i=1;

while(*n)

/**********found**********/ { t=*n % __1__;

/**********found**********/ if(t%2!= __2__)

{ x=x+t*i; i=i*10; } *n =*n /10; }

/**********found**********/ *n=__3__; }

main()

{ unsigned long n=-1; while(n>99999999||n<0)

{ printf(\ fun(&n);

printf(\}

41、给定程序中，函数fun的功能是将带头结点的单向链表逆置。即若原链表中从头至尾结点数据域依次为:2、4、6、8、10,逆置后，从头至尾结点数据域依次为:10、8、6、4、2。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #define N 5 typedef struct node { int data;

struct node *next; } NODE;

void fun(NODE *h) { NODE *p, *q, *r; 22

/**********found**********/ p = __1__;

/**********found**********/ if (__2__) return; q = p->next;

p->next = NULL; while (q)

{ r = q->next; q->next = p; /**********found**********/ p = q; q = __3__; }

h->next = p; }

NODE *creatlist(int a[])

{ NODE *h,*p,*q; int i; h = (NODE *)malloc(sizeof(NODE)); h->next = NULL; for(i=0; i

{ q=(NODE *)malloc(sizeof(NODE)); q->data=a[i]; q->next = NULL;

if (h->next == NULL) h->next = p = q; else { p->next = q; p = q; } }

return h; }

void outlist(NODE *h) { NODE *p; p = h->next;

if (p==NULL) printf(\ else

{ printf(\ \ do

{ printf(\ } while(p!=NULL); printf(\ } }

main()

{ NODE *head;

int a[N]={2,4,6,8,10}; head=creatlist(a);

printf(\ outlist(head); fun(head);

printf(\ outlist(head); }

42、给定程序中，函数fun的功能是：计算形参x所指数组中N个数的平均值（规定所有数均为正数）,将所指数组中小于平均值的数据移至数组的前部，大于等于平均值的数据移至x所指数组的后部，平均值作为函数值返回，在主函数中输出平均值和移动后的数据。

例如，有10个正数：46 30 32 40 6 17 45 15 48 26，平均值为：30.500000 移动后的输出为：30 6 17 15 26 46 32 40 45 48

请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #define N 10 double fun(double *x)

{ int i, j; double av, y[N]; av=0;

/**********found**********/ for(i=0; i

23

if( x[i]

/**********found**********/ y[j]=x[i]; x[i]=-1; __2__;} i=0;

while(i

{ if( x[i]!= -1 ) y[j++]=x[i]; /**********found**********/ __3__; }

for(i=0; i

main()

{ int i; double x[N];

for(i=0; i

printf(\ printf(\

for(i=0; i

43、给定程序中，函数fun的功能是：利用指针数组对形参ss所指字符串数组中的字符串按由长到短的顺序排序，并输出排序结果。ss所指字符串数组中共有N个字符串，且串长小于M。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #define N 5 #define M 8

void fun(char (*ss)[M])

{ char *ps[N],*tp; int i,j,k; for(i=0; i

/**********found**********/ k= __1__ ;

for(j=i+1; j

/**********found**********/

if(strlen(ps[k]) < strlen(__2__) ) k=j; /**********found**********/

tp=ps[i]; ps[i]=ps[k]; ps[k]= __3__ ; }

printf(\ for(i=0; i

main()

{ char ch[N][M]={\ int i;

printf(\

for(i=0;i

44、给定程序中，函数fun的功能是：将形参s所指字符串中所有ASCII码值小于97的字符存入形参t所指字符数组中，形成一个新串，并统计出符合条件的字符个数作为函数值返回。

例如，形参s所指的字符串为：Abc@1x56*，程序执行后t所指字符数组中的字符串应为：A@156*。 请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include

int fun(char *s, char *t) { int n=0; while(*s) { if(*s < 97) {

/**********found**********/ 24

*(t+n)= __1__ ; n++; } /**********found**********/ __2__ ; }

*(t+n)=0;

/**********found**********/ return __3__ ; }

main()

{ char s[81],t[81]; int n;

printf(\ gets(s); n=fun(s,t);

printf(\} 45、程序通过定义学生结构体变量，存储了学生的学号、姓名和3门课的成绩。所有学生数据均以二进制方式输出到文件中。函数fun的功能是重写形参filename所指文件中最后一个学生的数据，即用新的学生数据覆盖该学生原来的数据,其它学生的数据不变。

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #define N 5 typedef struct student { long sno;

char name[10]; float score[3]; } STU;

void fun(char *filename, STU n) { FILE *fp;

/**********found**********/ fp = fopen(__1__, \/**********found**********/

fseek(fp, -1L*sizeof(STU), __2__); /**********found**********/ fwrite(__3__, sizeof(STU), 1, fp); fclose(fp); }

main()

{ STU t[N]={ {10001,\ {10003,\ {10004,\ {10005,\ STU n={10006,\ int i,j; FILE *fp; fp = fopen(\ fwrite(t, sizeof(STU), N, fp); fclose(fp);

fp = fopen(\ fread(ss, sizeof(STU), N, fp); fclose(fp);

printf(\ for (j=0; j

{ printf(\ Name: %-8s Scores: \ for (i=0; i<3; i++) printf(\ printf(\ }

fun(\

printf(\ fp = fopen(\ fread(ss, sizeof(STU), N, fp); fclose(fp);

for (j=0; j

{ printf(\ Name: %-8s Scores: \ for (i=0; i<3; i++) printf(\ printf(\ }

25

}

46、给定程序中,函数fun的功能是将参数给定的字符串、整数、浮点数写到文本文件中，再用字符串方式从此文本文件中逐个读入，并调用库函数atoi和atof将字符串转换成相应的整数、浮点数，然后将其显示在屏幕上。 请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include

void fun(char *s, int a, double f) {

/**********found**********/ __1__ fp;

char str[100], str1[100], str2[100]; int a1; double f1; fp = fopen(\

fprintf(fp, \ %d %f\\n\/**********found**********/ __2__ ;

fp = fopen(\/**********found**********/

fscanf(__3__,\ fclose(fp); a1 = atoi(str1); f1 = atof(str2);

printf(\}

main()

{ char a[10]=\ int b=12345; double c= 98.76; fun(a,b,c); } 47、

例如：若形参e的值为1e-3，函数的返回值为0.551690。

请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include double fun(double e)

{ int i, k; double s, t, x; s=0; k=1; i=2;

/**********found**********/ x=__1__/4;

/**********found**********/ while(x __2__ e) { s=s+k*x; k=k* (-1); t=2*i;

/**********found**********/ x=__3__/(t*t); i++; }

return s; }

main()

{ double e=1e-3;

printf(\} 26

48、给定程序中，函数fun的功能是：判定形参a所指的N×N（规定N为奇数）的矩阵是否是\幻方\，若是，函数返回值为1； 不是，函数返回值为0。\幻方\的判定条件是：矩阵每行、每列、主对角线及反对角线上元素之和都相等。 例如，以下3×3的矩阵就是一个\幻方\： 4 9 2 3 5 7 8 1 6

请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #define N 3 int fun(int (*a)[N])

{ int i,j,m1,m2,row,colum; m1=m2=0;

for(i=0; i

{ j=N-i-1; m1+=a[i][i]; m2+=a[i][j]; } if(m1!=m2) return 0; for(i=0; i

/**********found**********/ row=colum= __1__; for(j=0; j

{ row+=a[i][j]; colum+=a[j][i]; } /**********found**********/

if( (row!=colum) __2__ (row!=m1) ) return 0; }

/**********found**********/ return __3__; }

main()

{ int x[N][N],i,j;

printf(\ for(i=0; i

for(j=0; j

{ for(j=0; j

if(fun(x)) printf(\ else printf(\}

49、给定程序中,函数fun的功能是将不带头节点的单向链表结点数据域中的数据从小到大排序。即若原链表结点数据域从头至尾的数据为：10、4、2、8、6，排序后链表结点数据域从头至尾的数据为：2、4、6、8、10。 请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include #include #define N 6 typedef struct node { int data;

struct node *next; } NODE;

void fun(NODE *h)

{ NODE *p, *q; int t; p = h;

while (p) {

/**********found**********/ q = __1__ ;

/**********found**********/ while (__2__)

{ if (p->data > q->data)

{ t = p->data; p->data = q->data; q->data = t; } q = q->next; }

27

/**********found**********/ p = __3__ ; } }

NODE *creatlist(int a[])

{ NODE *h,*p,*q; int i; h=NULL;

for(i=0; i

{ q=(NODE *)malloc(sizeof(NODE)); q->data=a[i]; q->next = NULL;

if (h == NULL) h = p = q;

else { p->next = q; p = q; } }

return h; }

void outlist(NODE *h) { NODE *p; p=h;

if (p==NULL) printf(\ else

{ printf(\ \ do

{ printf(\ } while(p!=NULL); printf(\ } }

main()

{ NODE *head;

int a[N]= {0, 10, 4, 2, 8, 6 }; head=creatlist(a);

printf(\ outlist(head); fun(head);

printf(\ outlist(head); }

50、给定程序中，函数fun的功能是：计算下式前n项的和作为函数值返回。

例如，当形参n的值为10时，函数返回：-0.204491。

请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。 不得增行或删行，也不得更改程序的结构！ #include double fun(int n)

{ int i, k; double s, t; s=0;

/**********found**********/ k=__1__;

for(i=1; i<=n; i++) {

/**********found**********/ t=__2__;

s=s+k*(2*i-1)*(2*i+1)/(t*t); /**********found**********/ k=k*__3__; }

return s; }

main()

{ int n=-1; while(n<0) 28

{ printf(\ scanf(\ } printf(\}

二、改错题 考试做题要求：

1、在/**********found**********/的下一行改正错误。 2、将题目做完之后一定要保存。

3、不能删除/**********found**********/，也不能多行或少行。

1、给定程序MODI1.C中函数fun的功能是：逐个比较p、q所指两个字符串对应位置中的字符，把ASCII值大或相等的字符依次存放到c所指数组中，形成一个新的字符串。 例如，若主函数中a字符串为：aBCDeFgH， 主函数中b字符串为：ABcd， 则c中的字符串应为：aBcdeFgH。 请改正程序中的错误，使它能得出正确结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。 #include #include

void fun(char *p ,char *q, char *c) {

/************found************/ int k = 1;

/************found************/ while( *p != *q )

{ if( *p<*q ) c[k]=*q; else c[k]=*p; if(*p) p++; if(*q) q++; k++; } }

main()

{ char a[10]=\ fun(a,b,c);

printf(\ \ puts(a); printf(\ \ puts(b); printf(\ : \ puts(c); }

2、给定程序MODI1.C中函数fun的功能是: 交换主函数中两个变量的值。例如: 若变量a中的值原为8,b中的值为3。程序运行后a中的值为3, b中的值为8。

请改正程序中的错误, 使它能计算出正确的结果。

注意: 不要改动 main 函数, 不得增行或删行, 也不得更改程序的结构! #include

/*********found**********/ int fun(int x,int y) {

int t;

/*********found**********/ t=x;x=y;y=t; }

main() {

int a,b; a=8;b=3; fun(&a,&b);

printf(\ %d\\n\}

3、给定程序MODI1.C中函数fun的功能是：计算小于形参k的最大的10个能被13或17整除的自然数之和。k的值由主函数传入，若k的值为500，则函数值为4622。

请改正程序中的错误，使程序能输出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include int fun( int k )

{ int m=0, mc=0, j ;

29

while ((k >= 2) && (mc < 10)) {

/************found************/ if ((k = 0) || (k = 0)) { m = m+ k; mc++; } k--; }

return m;

/************found************/ _____

main ( ) {

printf(\}

4、给定程序MODI1.C中函数fun的功能是：从低位开始取出长整型变量s中偶数位上的数，依次构成一个新数放在t中。高位仍在高位,低位仍在低位。

例如，当s中的数为：7654321时，t中的数为：642。 请改正程序中的错误，使它能得出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include

/************found************/ void fun (long s, long t) { long sl=10; s /= 10; *t = s % 10;

/************found************/ while ( s < 0) { s = s/100;

*t = s*sl + *t; sl = sl * 10; } }

main()

{ long s, t;

printf(\ fun(s, &t);

printf(\}

5、给定程序MODI1.C中函数 fun 的功能是: 将十进制正整数m转换成k(2≤k≤9)进制数, 并按高位到低位顺序输出。 例如，若输入8和2,则应输出1000(即十进制数8转换成二进制表示是1000)。 请改正 fun 函数中的错误，使它能得出正确的结果。

注意：不要改动 main 函数。不得增行或删行，也不得更改程序的结构！ #include #include void fun( int m, int k ) {

int aa[20], i;

for( i = 0; m; i++ ) {

/**********found**********/ aa[i] = m/k; m /= k; }

for( ; i; i-- )

/**********found**********/ printf( \}

main() {

int b, n;

printf( \ scanf( \ fun( n, b ); 30

printf(\}

6、给定程序MODI1.C中函数fun的功能是：根据整型形参m，计算如下公式的值。 1 1 1 1 y = ------- + --------- + --------- + …… + ------- 100*100 200*200 300*300 m*m 例如，若m = 2000，则应输出： 0.000160。

请改正程序中的语法错误，使它能计算出正确的结果。

注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！ #include

/************found************/ fun ( int m ) { double y = 0, d ; int i ;

/************found************/ for( i = 100, i <= m, i += 100 ) { d = (double)i * (double)i ; y += 1.0 / d ; }

return( y ) ; }

main( )

{ int n = 2000 ;

printf( \}

7、给定程序MODI1.C中函数 fun 的功能是: 读入一个字符串(长度＜20 ),将该字符串中的所有字符按ASCII码升序排序后输出。

例如, 若输入: edcba, 则应输出: abcde。

请改正程序中的错误，使它能统计出正确的结果。

注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！ #include void fun( char t[] ) {

char c; int i, j;

/**********found***********/ for( i = strlen( t ); i; i-- ) for( j = 0; j < i; j++ )

/**********found***********/ if( t[j] < t[ j + 1 ] ) {

c = t[j];

t[j] = t[ j + 1 ]; t[j + 1 ] = c; } }

main() {

char s[81];

printf( \ gets( s );

printf( \ \\\ fun( s );

printf( \ \\\}

8、给定程序MODI1.C中函数fun的功能是: 比较两个字符串，将长的那个字符串的首地址作为函数值返回。 请改正函数fun中指定部位的错误, 使它能得出正确的结果。

注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构! #include

/**********found**********/ char fun(char *s, char *t)

{ int sl=0,tl=0; char *ss, *tt;

31

ss=s; tt=t; while(*ss) { sl++;

/**********found**********/ (*ss)++; }

while(*tt) { tl++;

/**********found**********/ (*tt)++; }

if(tl>sl) return t; else return s; }

main()

{ char a[80],b[80],*p,*q; int i; printf(\ \

printf(\ \ printf(\}

9、给定程序MODI1.C中函数fun的功能是：首先把b所指字符串中的字符按逆序存放， 然后将a所指字符串中的字符和b所指字符串中的字符，按排列的顺序交叉合并到c所指数组中，过长的剩余字符接在c所指数组的尾部。例如，当a所指字符串中的内容为\，b所指字符串中的内容为\时，c所指数组中的内容应该为\；而当a所指字符串中的内容为\，b所指字符串中的内容

为\时，c所指数组中的内容应该为\。 请改正程序中的错误，使它能得出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include #include

void fun( char *a, char *b, char *c ) {

int i , j; char ch; i = 0; j = strlen(b)-1;

/************found************/ while ( i > j )

{ ch = b[i]; b[i] = b[j]; b[j] = ch; i++; j--; }

while ( *a || *b ) {

/************found************/ If ( *a )

{ *c = *a; c++; a++; } if ( *b )

{ *c = *b; c++; b++; } }

*c = 0; }

main() {

char s1[100],s2[100],t[200];

printf(\ printf(\ fun( s1, s2, t );

printf(\}

10、给定程序MODI1.C中函数fun的功能是：根据整型形参m的值，计算如下公式的值。 1 1 1 t = 1 - ----- - ----- - …… - ----- 2*2 3*3 m*m

例如，若 m 中的值为: 5，则应输出: 0.536389。 请改正程序中的错误，使它能得出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include double fun ( int m ) 32

{ double y = 1.0 ; int i ;

/**************found**************/ for(i = 2 ; i < m ; i++)

/**************found**************/ y -= 1 /(i * i) ; return( y ) ; }

main( )

{ int n = 5 ;

printf( \}

11、假定整数数列中的数不重复，并存放在数组中。给定程序MODI1.C中函数fun的功能是：删除数列中值为x的元素。n中存放的是数列中元素的个数。

请改正程序中的错误，使它能得出正确结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。 #include #define N 20 fun(int *a,int n,int x) { int p=0,i; a[n]=x;

while( x!=a[p] ) p=p+1;

/**********found**********/ if(P==n) return -1; else

{ for(i=p;i

/**********found**********/ a[i+1]=a[i]; return n-1; } }

main()

{ int w[N]={-3,0,1,5,7,99,10,15,30,90},x,n,i; n=10;

printf(\

for(i=0;i

printf(\ printf(\ : %d\\n\ n=fun(w,n,x);

if ( n==-1 ) printf(\ else

{ printf(\

for(i=0;i

注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构! #include #include typedef struct aa

{ int data; struct aa *next; }NODE; int fun(NODE *h) { int sum = 0 ; NODE *p;

/***********found**********/ p=h; while(p)

{ if(p->data%2==0) sum +=p->data;

/***********found**********/ p=h->next;

33

}

return sum; }

NODE *creatlink(int n) { NODE *h, *p, *s, *q; int i, x;

h=p=(NODE *)malloc(sizeof(NODE)); for(i=1; i<=n; i++)

{ s=(NODE *)malloc(sizeof(NODE)); s->data=rand(); s->next=p->next; p->next=s; p=p->next; }

p->next=NULL; return h; }

outlink(NODE *h, FILE *pf) { NODE *p; p = h->next;

fprintf(pf ,\ LIST :\\n\\n HEAD \ while(p)

{ fprintf(pf ,\ fprintf (pf,\}

outresult(int s, FILE *pf)

{ fprintf(pf,\ : %d\\n\main()

{ NODE *head; int even; head=creatlink(12); head->data=9000; outlink(head , stdout); even=fun(head);

printf(\ result :\\n\}

13、给定程序MODI1.C中函数fun的功能是：在p所指字符串中找出ASCII码值最大的字符，将其放在第一个位置上；并将该字符前的原字符向后顺序移动。

例如，调用fun函数之前给字符串输入：ABCDeFGH， 调用后字符串中的内容为：eABCDFGH。 请改正程序中的错误，使它能得出正确结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。 #include fun( char *p )

{ char max,*q; int i=0; max=p[i];

while( p[i]!=0 ) { if( max

/**********found**********/ q=p+i }

i++; }

/**********found**********/ wihle( q>p ) { *q=*(q-1); q--; }

p[0]=max; }

main()

{ char str[80];

printf(\ \

printf(\ \ puts(str); fun(str); 34

printf(\ \ puts(str); printf(\}

14、给定程序MODI1.C中函数 fun 的功能是：从n(形参)个学生的成绩中统计出低于平均分的学生人数，此人数由函数值返回,平均分存放在形参aver所指的存储单元中。

例如，若输入 8 名学生的成绩：80.5 60 72 90.5 98 51.5 88 64则低于平均分的学生人数为： 4 （平均分为：75.5625 ）。

请改正程序中的错误，使它能统计出正确的结果。

注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！ #include #define N 20

int fun ( float *s, int n, float *aver ) { float ave, t = 0.0 ; int count = 0, k, i ; for ( k = 0 ; k < n ; k++ )

/**************found**************/ t = s[k] ; ave = t / n ;

for ( i = 0 ; i < n ; i++ ) if ( s[ i ] < ave ) count++ ;

/**************found**************/ *aver = Ave ; return count ; }

main()

{ float s[30], aver ; int m, i ;

printf ( \ \ printf ( \ for( i = 0 ; i < m ; i++ ) scanf ( \

printf( \ printf( \}

15、给定程序MODI1.C中函数 fun 的功能是：统计substr所指子字符串在str所指字符串中出现的次数。 例如，若字符串为aaas lkaaas，子字符串为as，则应输出2。 请改正程序中的错误，使它能计算出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include

fun (char *str,char *substr) { int i,j,k,num=0;

/************found************/ for(i = 0, str[i], i++)

for(j=i,k=0;substr[k]==str[j];k++,j++) /************found************/ If(substr[k+1]=='\\0') { num++; break; }

return num; }

main() {

char str[80],substr[80]; printf(\ gets(str);

printf(\ gets(substr);

printf(\}

16、给定程序MODI1.C中函数fun的功能是：输出M行M列整数方阵，然后求两条对角线上元素之和，返回此和数。 请改正程序中的错误，使它能得出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include #define M 5

35

/************found************/ int fun(int n, int xx[][]) { int i, j, sum=0;

printf( \ for( i = 0; i < M; i++ ) { for( j = 0; j < M; j++ )

/************found************/ printf( \ printf(\ }

for( i = 0 ; i < n ; i++ )

sum += xx[i][i]+xx[i][ n-i-1 ]; return( sum ); }

main( )

{ int aa[M][M]={{1,2,3,4,5},{4,3,2,1,0}, {6,7,8,9,0},{9,8,7,6,5},{3,4,5,6,7}};

printf ( \}

17、给定程序MODI1.C中函数fun的功能是：从整数1到55之间，选出能被3整除、且有一位上的数是5的那些数,并把这些数放在b所指的数组中，这些数的个数作为函数值返回。规定，函数中a1放个位数，a2放十位数。 请改正程序中的错误，使它能得出正确结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。 #include fun( int *b )

{ int k,a1,a2,i=0;

for(k=10; k<=55; k++) {

/************found************/ a2=k/1O; a1=k-a2*10;

if((k%3==0 && a2==5)||(k%3==0 && a1==5)) { b[i]=k; i++; } }

/************found************/ return k; } main( )

{ int a[100],k,m; m=fun( a );

printf(\

for(k=0; k

18、给定程序MODI1.C中函数fun的功能是：应用递归算法求形参a的平方根。求平方根的迭代公式如下： 1 a x1 = ─ ( x0 + ─ ) 2 x0

例如，a为2时，平方根值为：1.414214。 请改正程序中的错误，使它能得出正确结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。 #include #include

/**********found**********/ double fun(double a, dounle x0) { double x1, y; x1=(x0+ a/x0)/2.0;

/**********found**********/ if( fabs(x1-xo)>0.00001 ) y=fun(a,x1); else y=x1; return y; }

main( )

{ double x; 36

printf(\

printf(\}

19、给定程序MODI1.C中函数fun的功能是：先将s所指字符串中的字符按逆序存放到t所指字符串中，然后把s所指串中的字符按正序连接到t所指串的后面。

例如：当s所指的字符串为：\时，

则t所指的字符串应为：\。 请改正程序中的错误，使它能得出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include #include

void fun (char *s, char *t) {

/************found************/ int i;

sl = strlen(s);

for (i=0; i

/************found************/ t[i] = s[sl-i]; for (i=0; i

main()

{ char s[100], t[100];

printf(\ fun(s, t);

printf(\}

20、给定程序MODI1.C中 fun 函数的功能是：分别统计字符串中大写字母和小写字母的个数。 例如, 给字符串 s 输入：AAaaBBb123CCccccd，则应输出结果：upper = 6, lower = 8。 请改正程序中的错误，使它能计算出正确的结果。

注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！ #include

/**********found**********/ void fun ( char *s, int a, int b ) {

while ( *s )

{ if ( *s >= 'A' && *s <= 'Z' ) /**********found**********/ *a=a+1 ;

if ( *s >= 'a' && *s <= 'z' ) /**********found**********/ *b=b+1; s++; } }

main( )

{ char s[100]; int upper = 0, lower = 0 ; printf( \ \ gets ( s ); fun ( s, & upper, &lower );

printf( \ lower = %d\\n\}

21、给定程序MODI1.C中函数fun的功能是：根据形参m的值（2≤m≤9〕，在m行m列的二维数组中存放如下所示规律的数据，由main函数输出。

例如，若输入 2 | 若输入 4 则输出、 | 则输出：

1 2 | 1 2 3 4 2 4 | 2 4 6 8 | 3 6 9 12 | 4 8 12 16 请改正程序函数中的错误，使它能得出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！

37

#include #define M 10

int a[M][M] = {0} ;

/**************found**************/ fun(int **a, int m) { int j, k ;

for (j = 0 ; j < m ; j++ )

for (k = 0 ; k < m ; k++ )

/**************found**************/ a[j][k] = k * j ; }

main ( )

{ int i, j, n ;

printf ( \ scanf (\ fun ( a, n ) ;

for ( i = 0 ; i < n ; i++)

{ for (j = 0 ; j < n ; j++) printf ( \ printf ( \ } }

22、给定程序MODI1.C中函数fun的功能是：从s所指字符串中删除所有小写字母c。 请改正程序中的错误，使它能计算出正确的结果。

注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！ #include void fun( char *s ) { int i,j;

for(i=j=0; s[i]!='\\0'; i++) if(s[i]!='c')

/************found************/ s[j]=s[i];

/************found************/ s[i]='\\0'; }

main()

{ char s[80];

printf(\ \ printf(\ \ fun(s);

printf(\ \}

23、给定程序MODI1.C中函数fun的功能是：找出一个大于形参m且紧随m的素数，并作为函数值返回。 请改正程序中的错误，使它能得出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include int fun(int m) { int i, k ;

for (i = m + 1 ; ; i++) { for (k = 2 ; k < i ; k++)

/**************found**************/ if (i % k != 0) break ;

/**************found**************/ if (k < i) return(i); } }

void main() {

int n ;

n = fun(20) ;

printf(\} 38

24、给定程序MODI1.C是建立一个带头结点的单向链表, 并用随机函数为各结点数据域赋值。函数fun的作用是求出单向链表结点(不包括头结点)数据域中的最大值,并且作为函数值返回。 请改正函数fun中指定部位的错误, 使它能得出正确的结果。

注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构! #include #include typedef struct aa { int data;

struct aa *next; } NODE;

fun ( NODE *h ) { int max=-1; NODE *p;

/***********found**********/ p=h ; while(p)

{ if(p->data>max )

max=p->data; /***********found**********/ p=h->next ; }

return max; }

outresult(int s, FILE *pf)

{ fprintf(pf,\ : %d\\n\

NODE *creatlink(int n, int m) { NODE *h, *p, *s, *q; int i, x;

h=p=(NODE *)malloc(sizeof(NODE));h->data=9999; for(i=1; i<=n; i++)

{ s=(NODE *)malloc(sizeof(NODE)); s->data=rand()%m; s->next=p->next; p->next=s; p=p->next; }

p->next=NULL; return h; }

outlink(NODE *h, FILE *pf) { NODE *p; p=h->next;

fprintf(pf,\ LIST :\\n\\n HEAD \ while(p)

{ fprintf(pf,\ fprintf(pf,\ } main()

{ NODE *head; int m; head=creatlink(12, 100); outlink(head , stdout); m=fun(head);

printf(\ RESULT :\\n\} 25、给定程序MODI1.C中函数fun的功能是: 先从键盘上输入一个3行3列矩阵的各个元素的值, 然后输出主对角线元素之和。

请改正函数fun中的错误或在横线处填上适当的内容并把横线删除,使它能得出正确的结果。 注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！ #include int fun() {

int a[3][3],sum; int i,j;

/*********found**********/ ______;

for (i=0;i<3;i++)

39

{ for (j=0;j<3;j++)

/*********found**********/ scanf(\ }

for (i=0;i<3;i++) sum=sum+a[i][i];

printf(\}

main() {

fun(); }

26、给定程序MODI1.C中函数fun的功能是：求三个数的最小公倍数。 例如，给主函数中的变量x1、x2、x3分别输入15 11 2， 则输出结果应当是：330。

请改正程序中的错误，使它能得出正确结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。 #include

/************found************/ fun(int x, y, z ) { int j,t ,n ,m; j = 1 ; t=j%x; m=j%y ; n=j%z;

while(t!=0||m!=0||n!=0) { j = j+1; t=j%x; m=j%y; n=j%z; }

/************found************/ return i; }

main( )

{ int x1,x2,x3,j ;

printf(\ x2 x3: \ scanf(\ printf(\ j=fun(x1,x2,x3);

printf(\}

27、给定程序MODI1.C中函数fun的功能是：从N个字符串中找出最长的那个串,并将其地址作为函数值返回。各字符串在主函数中输入,并放入一个字符串数组中。

请改正程序中的错误，使它能得出正确结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。 #include #include #define N 5 #define M 81

/**********found**********/ fun(char (*sq)[M])

{ int i; char *sp; sp=sq[0];

for(i=0;i

if(strlen( sp)

/**********found**********/ return sq; }

main()

{ char str[N][M], *longest; int i; printf(\ for(i=0; i

for(i=0; i

printf(\}

28、给定程序MODI1.C中函数 fun 的功能是：求S的值。

例如，当k为10时，函数值应为：1.533852。 请改正程序中的错误，使程序能输出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include #include

/************found************/ void fun( int k )

{ int n; float s, w, p, q; n = 1; s = 1.0;

while ( n <= k ) { w = 2.0 * n; p = w - 1.0; q = w + 1.0;

s = s * w *w/p/q; n++; }

/************found************/ return s }

main ( ) {

printf(\}

29、给定程序MODI1.C中fun函数的功能是：求出以下分数序列的前n项之和。 2 3 5 8 13 21

┄┄ , ┄┄ , ┄┄ , ┄┄ , ┄┄ , ┄┄ , …… 1 2 3 5 8 13 和值通过函数值返回main函数。

例如，若 n = 5，则应输出： 8.391667。

请改正程序中的错误，使它能得出正确的结果。

注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！ #include

/**************found**************/ fun (int n )

{ int a = 2, b = 1, c, k ; double s=0.0 ;

for ( k = 1; k <= n; k++ ) { s = s + 1.0 * a / b ;

/**************found**************/ c = a; a += b; b += c; }

return(s) ; }

main( )

{ int n = 5 ;

printf( \ function is: %lf\\n\ fun ( n ) ) ; }

30、给定程序MODI1.C的功能是：读入一个英文文本行，将其中每个单词的第一个字母改成大写，然后输出此文本行(这里的“单词”是指由空格隔开的字符串)。

例如，若输入：I am a student to take the examination.,

则应输出：I Am A Student To Take The Examination.。 请改正程序中的错误，使程序能得出正确的结果。

注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！

41

#include #include

/************found************/ include (stdio.a)

/************found************/ upfst ( char p ) { int k=0;

for ( ; *p; p++ ) if ( k )

{ if ( *p == ' ' ) k = 0; } else if ( *p != ' ' )

{ k = 1; *p = toupper( *p ); } }

main( )

{ char chrstr[81];

printf( \ gets( chrstr ); printf( \ %s\ upfst( chrstr );

printf( \ %s\\n\} 31、给定程序MODI1.C中函数fun的功能是: 将s所指字符串中位于奇数位置的字符或ASCII码为偶数的字符放入t所指数组中(规定第一个字符放在第0位中)。

例如, 字符串中的数据为: AABBCCDDEEFF, 则输出应当是：ABBCDDEFF。

请改正函数fun中指定部位的错误, 使它能得出正确的结果。

注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构! #include #include #define N 80 void fun(char *s, char t[]) { int i, j=0;

for(i=0; i

/***********found**********/ if(i%2 && s[i]%2==0) t[j++]=s[i];

/***********found**********/ t[i]='\\0'; }

main()

{ char s[N], t[N];

printf(\ fun(s, t);

printf(\}

32、给定程序MODI1.C中函数fun的功能是：根据以下公式求π值，并作为函数值返回。 例如，给指定精度的变量eps输入0.0005时，应当输出Pi=3.140578。 π 1 1 2 1 2 3 1 2 3 4

─=1+ ─ + ─×─ + ─×─×─ + ─×─×─×─+…… 2 3 3 5 3 5 7 3 5 7 9

请改正程序中的错误，使它能得出正确结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。 #include #include

double fun(double eps)

{ double s,t; int n=1; s=0.0;

/************found************/ t=0;

while( t>eps) { s+=t;

t=t * n/(2*n+1); n++; }

/************found************/ 42

return(s); }

main()

{ double x;

printf(\ printf(\}

33、给定程序MODI1.C中函数fun的功能是：利用插入排序法对字符串中的字符按从小到大的顺序进行排序。插入法的基本算法是：先对字符串中的头两个元素进行排序。然后把第三个字符插入到前两个字符中，插入后前三个字符依然有序；再把第四个字符插入到前三个字符中,……。待排序的字符串已在主函数中赋予。 请改正程序中的错误，使它能得出正确结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。 #include #include #define N 80 void insert(char *aa)

{ int i,j,n; char ch; /**********found**********/ n=strlen[ aa ];

for( i=1; i

/**********found**********/ c=aa[i]; j=i-1;

while ((j>=0) && ( ch

aa[j+1]=ch; } }

main( )

{ char a[N]=\ int i ;

printf (\ %s\\n\ insert(a) ;

printf(\ %s\\n\\n\}

34、给定程序MODI1.C中函数fun的功能是: 在字符串的最前端加入n个*号, 形成新串, 并且覆盖原串。 注意: 字符串的长度最长允许为79。

请改正函数fun中指定部位的错误, 使它能得出正确的结果。

注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构! #include #include

void fun ( char s[], int n ) {

char a[80] , *p; int i;

/**********found***********/ s=p;

for(i=0; i

{ a[i]=*p; i++; }

/**********found***********/ while(*p); a[i]=0; strcpy(s,a); }

main()

{ int n; char s[80];

printf(\ : \ printf(\

printf(\ : \ scanf(\

43

fun(s,n);

printf(\}

35、给定程序MODI1.C中函数fun的功能是：根据整型形参n，计算如下公式的值。

例如，若 n=10，则应输出： 0.617977。

请改正程序中的语法错误，使它能得出正确的结果。

注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！ #include

/************found************/ int fun ( int n ) { float A=1; int i;

/************found************/ for (i=2; i

main( ) { int n ;

printf(\ scanf(\

printf(\}

36、给定程序MODI1.C中函数 fun 的功能是：将s所指字符串中最后一次出现的与t1所指字符串相同的子串替换成t2所指字符串,所形成的新串放在w所指的数组中。在此处，要求t1和t2所指字符串的长度相同。

例如，当s所指字符串中的内容为：\，t1所指子串中的内容为：\，t2所指子串中的内容为：\时， 结果，在w所指的数组中的内容应为：\。 请改正程序中的错误，使它能得出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include #include

int fun (char *s, char *t1, char *t2 , char *w) {

int i; char *p , *r, *a; strcpy( w, s );

/************found************/ while ( w )

{ p = w; r = t1; while ( *r )

/************found************/ IF ( *r == *p ) { r++; p++; } else break;

if ( *r == '\\0' ) a = w; w++; } r = t2;

while ( *r ){ *a = *r; a++; r++; } }

main() {

char s[100], t1[100], t2[100], w[100];

printf(\

printf(\ printf(\ if ( strlen(t1)==strlen(t2) ) { fun( s, t1, t2, w);

printf(\ %s\\n\ }

else printf(\} 44

37、给定程序MODI1.C中函数fun的功能是: 依次取出字符串中所有数字字符, 形成新的字符串, 并取代原字符串。 请改正函数fun中指定部位的错误, 使它能得出正确的结果。

注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构! #include void fun(char *s) { int i,j;

for(i=0,j=0; s[i]!='\\0'; i++) if(s[i]>='0' && s[i]<='9') /**********found**********/ s[j]=s[i];

/**********found**********/ s[j]=\}

main()

{ char item[80];

printf(\ : \

printf(\ string is : \\\ fun(item);

printf(\ : \\\}

38、给定程序MODI1.C中函数fun的功能是：将长整型数中每一位上为奇数的数依次取出，构成一个新数放在t中。高位仍在高位，低位仍在低位。

例如，当s中的数为：87653142时，t中的数为：7531。 请改正程序中的错误，使它能得出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include

void fun (long s, long *t) { int d; long sl=1;

/************found************/ t = 0;

while ( s > 0) { d = s;

/************found************/ if (d%2 == 0)

{ *t = d * sl + *t; sl *= 10; }

s /= 10; } }

main()

{ long s, t; clrscr();

printf(\ fun(s, &t);

printf(\}

39、给定程序MODI1.C中函数 fun 的功能是：将s所指字符串的正序和反序进行连接，形成一个新串放在t所指的数组中。 例如，当s所指字符串为：\时，则t所指字符串中的内容应为：\。 请改正程序中的错误，使它能得出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include #include

/************found************/ void fun (char s, char t) {

int i, d; d = strlen(s);

for (i = 0; i

for (i = 0; i

45

main() {

char s[100], t[100];

printf(\ fun(s, t);

printf(\}

40、给定程序MODI1.C中函数 fun 的功能是：计算n!。 例如，给n输入5，则输出120.000000。

请改正程序中的错误，使程序能输出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include double fun ( int n ) { double result = 1.0 ;

/************found************/ if n = = 0 return 1.0 ;

while( n >1 && n < 170 )

/************found************/ result *= n-- return result ; }

main ( ) { int n ;

printf(\ scanf(\

printf(\}

41、给定程序MODI1.C中函数fun的功能是: 计算s所指字符串中含有t所指字符串的数目, 并作为函数值返回。 请改正函数fun中指定部位的错误, 使它能得出正确的结果。

注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构! #include #include #define N 80

int fun(char *s, char *t) { int n;

char *p , *r; n=0;

while ( *s ) { p=s;

/*********found**********/ r=p;

while(*r)

if(*r==*p) { r++; p++; } else break;

/*********found**********/ if(*r= O) n++; s++; }

return n; }

main()

{ char a[N],b[N]; int m;

printf(\ printf(\ m=fun(a, b);

printf(\ m = %d\\n\}

42、给定程序MODI1.C中函数 fun 的功能是：统计字符串中各元音字母（即：A、E、I、O、U）的个数。注意：字母不分大、小写。

例如：若输入：THIs is a boot，则输出应该是：1、0、2、2、0。 请改正程序中的错误，使它能得出正确的结果。 46

注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！ #include

fun ( char *s, int num[5] ) { int k, i=5;

for ( k = 0; k

/**********found**********/ num[i]=0; for (; *s; s++) { i = -1;

/**********found**********/ switch ( s )

{ case 'a': case 'A': {i=0; break;} case 'e': case 'E': {i=1; break;} case 'i': case 'I': {i=2; break;} case 'o': case 'O': {i=3; break;} case 'u': case 'U': {i=4; break;} }

if (i >= 0) num[i]++; } }

main( )

{ char s1[81]; int num1[5], i;

printf( \ gets( s1 ); fun ( s1, num1 );

for ( i=0; i < 5; i++ ) printf (\}

43、已知一个数列从第0项开始的前三项分别为0，0，1，以后的各项都是其相邻的前三项之和。给定程序MODI1.C中函数fun的功能是:计算并输出该数列前n项的平方根之和。n的值通过形参传入。 例如，当n＝10时，程序的输出结果应为：23.197745。 请改正程序中的错误，使程序能输出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include #include

/************found************/ fun(int n)

{ double sum, s0, s1, s2, s; int k; sum = 1.0;

if (n <= 2) sum = 0.0;

s0 = 0.0; s1 = 0.0; s2 = 1.0; for (k = 4; k <= n; k++) { s = s0 + s1 + s2; sum += sqrt(s);

s0 = s1; s1 = s2; s2 = s; }

/************found************/ return sum }

main ( ) { int n;

printf(\ scanf(\

printf(\}

44、给定程序MODI1.C中函数 fun 的功能是：由形参给定n个实数，输出平均值，并统计在平均值以上(含平均值)的实数个数。

例如,n＝8时,输入：193.199,195.673,195.757,196.051, 196.092,196.596,196.579,196.763

所得平均值为:195.838745，在平均值以上的实数个数应为：5 请改正程序中的错误，使程序能输出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include int fun(float x[], int n) {

47

/************found************/ int j, c=0, float xa=0.0; for (j=0; j

printf(\ for (j=0; j

/************found************/ if (x[j] => xa) c++; return c; }

main ( )

{ float x[100] = {193.199, 195.673, 195.757, 196.051, 196.092, 196.596, 196.579, 196.763}; printf(\}

45、给定程序MODI1.C中的函数Creatlink的功能是创建带头结点的单向链表, 并为各结点数据域赋0到m-1的值。 请改正函数Creatlink中指定部位的错误, 使它能得出正确的结果。 注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构! #include #include typedef struct aa { int data;

struct aa *next; } NODE;

NODE *Creatlink(int n, int m) { NODE *h=NULL, *p, *s; int i;

/**********found***********/

p=(NODE )malloc(sizeof(NODE)); h=p;

p->next=NULL; for(i=1; i<=n; i++)

{ s=(NODE *)malloc(sizeof(NODE));

s->data=rand()%m; s->next=p->next; p->next=s; p=p->next; }

/**********found***********/ return p; }

outlink(NODE *h) { NODE *p; p=h->next;

printf(\ LIST :\\n\\n HEAD \ while(p)

{ printf(\ p=p->next; }

printf(\}

main()

{ NODE *head;

head=Creatlink(8,22); outlink(head); }

46、给定程序MODI1.C中函数fun的功能是: 对N名学生的学习成绩,按从高到低的顺序找出前m(m≤10)名学生来, 并将这些学生数据存放在一个动态分配的连续存储区中, 此存储区的首地址作为函数值返回。 请改正函数fun中指定部位的错误, 使它能得出正确的结果。

注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构! #include #include #include #define N 10 typedef struct ss { char num[10]; 48

int s; } STU;

STU *fun(STU a[], int m) { STU b[N], *t; int i,j,k;

/**********found**********/ t=(STU *)calloc(sizeof(STU),m) for(i=0; i b[j].s) j=i; /**********found**********/ t(k)=b(j); b[j].s=0; }

return t; }

outresult(STU a[], FILE *pf) { int i;

for(i=0; i

fprintf(pf,\ Mark = %d\\n\ fprintf(pf,\}

main()

{ STU a[N]={ {\ {\ STU *pOrder; int i, m;

printf(\ outresult(a, stdout);

printf(\ \ scanf(\ while( m>10 )

{ printf(\ \ scanf(\ }

pOrder=fun(a,m);

printf(\ RESULT *****\\n\ printf(\ :\\n\ for(i=0; i

printf(\ %s %d\\n\ free(pOrder); }

47、给定程序MODI1.C中函数 fun 的功能是：求出以下分数序列的前n项之和。和值通过函数值返回到main函数。 2 3 5 8 13 21

┄┄ , ┄┄ , ┄┄ , ┄┄ , ┄┄ , ┄┄ , …… 1 2 3 5 8 13 例如，若n = 5，则应输出：8.391667。

请改正程序中的错误，使它能计算出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！ #include

/************found************/ fun ( int n )

{ int a, b, c, k; double s; s = 0.0; a = 2; b = 1; for ( k = 1; k <= n; k++ ) {

/************found************/ s = s + (Double)a / b; c = a; a = a + b; b = c; }

return s; }

main( )

{ int n = 5;

printf( \ function is: %lf\\n\ fun ( n ) );

49

}

48、给定程序MODI1.C中fun函数的功能是: 根据整型形参m，计算如下公式的值。 1 1 1 t = 1 - ----- - ----- - …… - ----- 2 3 m

例如，若主函数中输入5，则应输出 -0.283333。

请改正函数fun中的错误或在横线处填上适当的内容并把横线删除, 使它能计算出正确的结果。 注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！ #include double fun( int m ) {

double t = 1.0; int i;

for( i = 2; i <= m; i++ )

/**********found**********/ t = 1.0-1 /i;

/**********found**********/ _______; }

main() {

int m ;

printf( \ scanf( \

printf( \}

49、给定程序MODI1.C中函数fun的功能是: 将s所指字符串中的字母转换为按字母序列的后续字母(但Z转换为A, z转换为a),其它字符不变。

请改正函数fun中指定部位的错误, 使它能得出正确的结果。

注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构! #include #include void fun (char *s) {

/**********found***********/ while(*s!='@')

{ if(*s>='A' & *s<='Z' || *s>='a' && *s<='z') { if(*s=='Z') *s='A'; else if(*s=='z') *s='a';

else *s += 1; }

/**********found***********/ (*s)++; } }

main()

{ char s[80];

printf(\ Enter a string with length < 80. :\\n\\n \ printf(\ The string : \\n\\n \ puts(s); fun ( s );

printf (\ The Cords :\\n\\n \ puts(s); }

50、给定程序MODI1.C中函数 fun 的功能是：判断一个整数是否是素数，若是返回1，否则返回0。 在main()函数中，若fun返回1输出YES，若fun返回0输出NO!。 请改正程序中的错误，使它能得出正确的结果。

注意：不要改动main函数。不得增行或删行，也不得更改程序的结构！ #include int fun ( int m ) { int k = 2;

while ( k <= m && (m%k))

/************found************/ k++

/************found************/ 50

本文来源：https://www.bwwdw.com/article/0cww.html