第1套
给定程序的功能是调用fun函数建立班级通讯录。通讯录中记录每位学生的编号、姓名和电话号码。班级的人数和学生的信息从键盘读入,每个人的信息作为一个数据块写到名为myfile5.dat的二进制文件中。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef struct
{ int num;
char name[10];
char tel[10];
}STYPE;
void check();
/**********found**********/
int fun(___1___ *std)
{
/**********found**********/
___2___ *fp; int i;
if((fp=fopen("myfile5.dat","wb"))==NULL)
return(0);
printf("\nOutput data to file !\n");
for(i=0; i<N; i++)
/**********found**********/
fwrite(&std, sizeof(STYPE), 1, ___3___);
fclose(fp);
return (1);
}
main()
{ STYPE s[10]={ {1,"aaaaa","111111"},{1,"bbbbb","222222"},{1,"ccccc","333333"},{1,"ddddd","444444"},{1,"eeeee","555555"}};
int k;
k=fun(s);
if (k==1)
{ printf("Succeed!"); check(); }
else
printf("Fail!");
}
给定程序MODI1.C中函数fun的功能是：先将在字符串s中的字符按正序存放到t串中，然后把s中的字符按逆序连接到t串的后面。
例如：当s中的字符串为："ABCDE"时，
则t中的字符串应为："ABCDEEDCBA"。
请改正程序中的错误，使它能得出正确的结果。
#include <stdio.h>
#include <string.h>
void fun (char *s, char *t)
{ int i, sl;
sl = strlen(s);
/************found************/
for( i=0; i<=s1; i ++)
t = s;
for (i=0; i<sl; i++)
t[sl+i] = s[sl-i-1];
/************found************/
t[sl] = '\0';
}
main()
{ char s[100], t[100];
printf("\nPlease enter string s:"); scanf("%s", s);
fun(s, t);
printf("The result is: %s\n", t);
}
函数fun的功能是：将两个两位数的正整数a、b合并形成一个整数放在c中。合并的方式是：将a数的十位和个位数依次放在c数的千位和十位上， b数的十位和个位数依次放在c数的百位和个位上。
例如，当a＝45，b=12时，调用该函数后，c=4152。
注意: 部分源程序存在文件PROG1.C中。数据文件IN.DAT中的数据不得修改。
#include <stdio.h>
void fun(int a, int b, long *c)
{
}
main()
{ int a,b; long c;
void NONO ( );
printf("Input a, b:"); scanf("%d,%d", &a, &b);
fun(a, b, &c);
printf("The result is: %d\n", c);
NONO();
}
填空题参考答案：
1) int fun(STYPE *std)
2) FILE *fp; int i;
3) fwrite(&std, sizeof(STYPE), 1, fp);
修改题参考答案：
1) for(i = 0 ; i < sl ; i++)
2) t[2*sl] = 0;
程序题参考答案：
void fun(int a, int b, long *c)
{
*c=(a/10)*1000+(b/10)*100+(a%10)*10+(b%10);
}
第2套
给定程序的功能是：从键盘输入若干行文本（每行不超过80个字符），写到文件myfile4.txt中,用-1作为字符串输入结束的标志。然后将文件的内容读出显示在屏幕上。文件的读写分别由自定义函数ReadText和WriteText实现。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void WriteText(FILE *);
void ReadText(FILE *);
main()
{ FILE *fp;
if((fp=fopen("myfile4.txt","w"))==NULL)
{ printf(" open fail!!\n"); exit(0); }
WriteText(fp);
fclose(fp);
if((fp=fopen("myfile4.txt","r"))==NULL)
{ printf(" open fail!!\n"); exit(0); }
ReadText(fp);
fclose(fp);
}
/**********found**********/
void WriteText(FILE ___1___)
{ char str[81];
printf("\nEnter string with -1 to end :\n");
gets(str);
while(strcmp(str,"-1")!=0) {
/**********found**********/
fputs(___2___,fw); fputs("\n",fw);
gets(str);
}
}
void ReadText(FILE *fr)
{ char str[81];
printf("\nRead file and output to screen :\n");
fgets(str,81,fr);
while( !feof(fr) ) {
/**********found**********/
printf("%s",___3___);
fgets(str,81,fr);
}
}
给定程序MODI1.C中函数fun的功能是:从低位开始取出长整型变量s中奇数位上的数，依次构成一个新数放在t中。高位仍在高位,低位仍在低位。
例如，当s中的数为：7654321时，t中的数为：7531。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
/************found************/
void fun (long s, long t)
{ long sl=10;
*t = s % 10;
while ( s > 0)
{ s = s/100;
*t = s%10 * sl + *t;
/************found************/
sl = sl*100;
}
}
main()
{ long s, t;
printf("\nPlease enter s:"); scanf("%ld", &s);
fun(s, &t);
printf("The result is: %ld\n", t);
}
函数fun的功能是：将两个两位数的正整数a、b合并形成一个整数放在c中。合并的方式是：将a数的十位和个位数依次放在c数的个位和百位上， b数的十位和个位数依次放在c数的千位和十位上。
例如，当a＝45，b=12时，调用该函数后，c=1524。
注意: 部分源程序存在文件PROG1.C中。数据文件IN.DAT中的数据不得修改。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun(int a, int b, long *c)
{
}
main()
{ int a,b; long c;
void NONO ( );
printf("Input a, b:");
scanf("%d,%d", &a, &b);
fun(a, b, &c);
printf("The result is: %ld\n", c);
NONO();
}
填空题参考答案：
1) void WriteText(FILE *fw)
2) fputs(str,fw); fputs("\n",fw);
3) printf("%s",str);
修改题参考答案：
1) void fun (long s, long *t)
2) sl = sl*10;
程序题参考答案：
void fun(int a, int b, long *c)
{
*c=(b/10)*1000+(a%10)*100+(b%10)*10+(a/10);
}
第3套
给定程序中，函数fun的功能是：将自然数1～10以及它们的平方根写到名为myfile3.txt的文本文件中，然后再顺序读出显示在屏幕上。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <math.h>
#include <stdio.h>
int fun(char *fname )
{ FILE *fp; int i,n; float x;
if((fp=fopen(fname, "w"))==NULL) return 0;
for(i=1;i<=10;i++)
/**********found**********/
fprintf(___1___,"%d %f\n",i,sqrt((double)i));
printf("\nSucceed!！\n");
/**********found**********/
___2___;
printf("\nThe data in file :\n");
/**********found**********/
if((fp=fopen(___3___,"r"))==NULL)
return 0;
fscanf(fp,"%d%f",&n,&x);
while(!feof(fp))
{ printf("%d %f\n",n,x); fscanf(fp,"%d%f",&n,&x); }
fclose(fp);
return 1;
}
main()
{ char fname[]="myfile3.txt";
fun(fname);
}
给定程序MODI1.C中fun函数的功能是：将n个无序整数从小到大排序。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <stdlib.h>
fun ( int n, int *a )
{ int i, j, p, t;
for ( j = 0; j<n-1 ; j++ )
{ p = j;
/************found************/
for ( i=j+1; i<n-1 ; i++ )
if ( a
>a )
/************found************/
t=i;
if ( p!=j )
{ t = a[j]; a[j] = a
; a
= t; }
}
}
putarr( int n, int *z )
{ int i;
for ( i = 1; i <= n; i++, z++ )
{ printf( "%4d", *z );
if ( !( i%10 ) ) printf( "\n" );
} printf("\n");
}
main()
{ int aa[20]={9,3,0,4,1,2,5,6,8,10,7}, n=11;
printf( "\n\nBefore sorting %d numbers:\n", n ); putarr( n, aa );
fun( n, aa );
printf( "\nAfter sorting %d numbers:\n", n ); putarr( n, aa );
}
函数fun的功能是: 将两个两位数的正整数a、b合并形成一个整数放在c中。合并的方式是: 将a数的十位和个位数依次放在c数的个位和百位上, b数的十位和个位数依次放在c数的十位和千位上。
例如, 当a=45, b=12时, 调用该函数后, c=2514。
注意: 部分源程序存在文件PROG1.C中。数据文件IN.DAT中的数据不得修改。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun(int a, int b, long *c)
{
}
main()
{ int a,b; long c;
void NONO ( );
printf("Input a, b:");
scanf("%d,%d", &a, &b);
fun(a, b, &c);
printf("The result is: %ld\n", c);
NONO();
}
填空题参考答案：
1) fprintf(fp,"%d %f\n",i,sqrt((double)i));
2) fclose(fp);
3) if((fp=fopen(fname,"r"))==NULL)
修改题参考答案：
1) for ( i=j+1; i<n ; i++ )
2) p=i;
程序题参考答案：
void fun(int a, int b, long *c)
{
*c=(b%10)*1000+(a%10)*100+(b/10)*10+(a/10);
}
第4套
给定程序的功能是：调用函数fun将指定源文件中的内容复制到指定的目标文件中，复制成功时函数返回值为1，失败时返回值为0。在复制的过程中，把复制的内容输出到终端屏幕。主函数中源文件名放在变量sfname中，目标文件名放在变量tfname中。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <stdlib.h>
int fun(char *source, char *target)
{ FILE *fs,*ft; char ch;
/**********found**********/
if((fs=fopen(source, ___1___))==NULL)
return 0;
if((ft=fopen(target, "w"))==NULL)
return 0;
printf("\nThe data in file :\n");
ch=fgetc(fs);
/**********found**********/
while(!feof(___2___))
{ putchar( ch );
/**********found**********/
fputc(ch,___3___);
ch=fgetc(fs);
}
fclose(fs); fclose(ft);
printf("\n\n");
return 1;
}
main()
{ char sfname[20] ="myfile1",tfname[20]="myfile2";
FILE *myf; int i; char c;
myf=fopen(sfname,"w");
printf("\nThe original data :\n");
for(i=1; i<30; i++){ c='A'+rand()%25;fprintf(myf,"%c",c); printf("%c",c); }
fclose(myf);printf("\n\n");
if (fun(sfname, tfname)) printf("Succeed!");
else printf("Fail!");
}
给定程序MODI1.C中函数fun的功能是：将长整型数中每一位上为偶数的数依次取出，构成一个新数放在t中。高位仍在高位，低位仍在低位。
例如，当s中的数为：87653142时，t中的数为：8642。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
void fun (long s, long *t)
{ int d;
long sl=1;
*t = 0;
while ( s > 0)
{ d = s%10;
/************found************/
if (d%2=0)
{ *t=d* sl+ *t;
sl *= 10;
}
/************found************/
s \= 10;
}
}
main()
{ long s, t;
printf("\nPlease enter s:"); scanf("%ld", &s);
fun(s, &t);
printf("The result is: %ld\n", t);
}
函数fun的功能是：将两个两位数的正整数a、b合并形成一个整数放在c中。合并的方式是：将a数的十位和个位数依次放在c数的十位和千位上， b数的十位和个位数依次放在c数的百位和个位上。
例如，当a＝45，b=12时，调用该函数后，c=5142。
注意: 部分源程序存在文件PROG1.C中。数据文件IN.DAT中的数据不得修改。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun(int a, int b, long *c)
{
}
main()
{ int a,b; long c;
void NONO ( );
printf("Input a, b:");
scanf("%d,%d", &a, &b);
fun(a, b, &c);
printf("The result is: %ld\n", c);
NONO();
}
填空题参考答案：
1) if((fs=fopen(source, "r"))==NULL)
2) while(!feof(fs))
3) fputc(ch,ft);
修改题参考答案：
1) if (d%2==0)
2) s /= 10;
程序题参考答案：
void fun(int a, int b, long *c)
{
*c=(a%10)*1000+(b/10)*100+(a/10)*10+(b%10);
}
第5套
给定程序中已建立一个带有头结点的单向链表，链表中的各结点按结点数据域中的数据递增有序链接。函数fun的功能是：把形参x的值放入一个新结点并插入到链表中，插入后各结点数据域的值仍保持递增有序。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{ int data;
struct list *next;
} SLIST;
void fun( SLIST *h, int x)
{ SLIST *p, *q, *s;
s=(SLIST *)malloc(sizeof(SLIST));
/**********found**********/
s->data=___1___;
q=h;
p=h->next;
while(p!=NULL && x>p->data) {
/**********found**********/
q=___2___;
p=p->next;
}
s->next=p;
/**********found**********/
q->next=___3___;
}
SLIST *creatlist(int *a)
{ SLIST *h,*p,*q; int i;
h=p=(SLIST *)malloc(sizeof(SLIST));
for(i=0; i<N; i++)
{ q=(SLIST *)malloc(sizeof(SLIST));
q->data=a; p->next=q; p=q;
}
p->next=0;
return h;
}
void outlist(SLIST *h)
{ SLIST *p;
p=h->next;
if (p==NULL) printf("\nThe list is NULL!\n");
else
{ printf("\nHead");
do { printf("->%d",p->data); p=p->next; } while(p!=NULL);
printf("->End\n");
}
}
main()
{ SLIST *head; int x;
int a[N]={11,12,15,18,19,22,25,29};
head=creatlist(a);
printf("\nThe list before inserting:\n"); outlist(head);
printf("\nEnter a number : "); scanf("%d",&x);
fun(head,x);
printf("\nThe list after inserting:\n"); outlist(head);
}
给定程序MODI1.C中函数fun的功能是：计算正整数num的各位上的数字之积。例如，若输入：252，则输出应该是：20。若输入：202，则输出应该是：0。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
long fun (long num)
{
/************found************/
long k;
do
{ k*=num%10 ;
/************found************/
num\=10 ;
} while(num) ;
return (k) ;
}
main( )
{ long n ;
printf("\nPlease enter a number:") ; scanf("%ld",&n) ;
printf("\n%ld\n",fun(n)) ;
}
请编写一个函数fun，它的功能是：计算n门课程的平均分，计算结果作为函数值返回。
例如：若有5门课程的成绩是：90.5, 72, 80, 61.5, 55
则函数的值为：71.80。
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容,仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
float fun ( float *a , int n )
{
}
main()
{ float score[30]={90.5, 72, 80, 61.5, 55}, aver;
void NONO ( );
aver = fun( score, 5 );
printf( "\nAverage score is: %5.2f\n", aver);
NONO ( );
}
填空题参考答案：
1) s->data=x;
2) q=p;
3) q->next=s;
修改题参考答案：
1) long k=1;
2) num/=10 ;
程序题参考答案：
float fun ( float *a , int n )
{
int i;
float ave=0.0;
for(i=0; i<n; i++) ave=ave+a ;
ave=ave/n;
return ave;
}
第6套
给定程序中已建立一个带有头结点的单向链表,在main函数中将多次调用fun函数,每调用一次fun函数，输出链表尾部结点中的数据，并释放该结点，使链表缩短。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{ int data;
struct list *next;
} SLIST;
void fun( SLIST *p)
{ SLIST *t, *s;
t=p->next; s=p;
while(t->next != NULL)
{ s=t;
/**********found**********/
t=t->___1___;
}
/**********found**********/
printf(" %d ",___2___);
s->next=NULL;
/**********found**********/
free(___3___);
}
SLIST *creatlist(int *a)
{ SLIST *h,*p,*q; int i;
h=p=(SLIST *)malloc(sizeof(SLIST));
for(i=0; i<N; i++)
{ q=(SLIST *)malloc(sizeof(SLIST));
q->data=a; p->next=q; p=q;
}
p->next=0;
return h;
}
void outlist(SLIST *h)
{ SLIST *p;
p=h->next;
if (p==NULL) printf("\nThe list is NULL!\n");
else
{ printf("\nHead");
do { printf("->%d",p->data); p=p->next; } while(p!=NULL);
printf("->End\n");
}
}
main()
{ SLIST *head;
int a[N]={11,12,15,18,19,22,25,29};
head=creatlist(a);
printf("\nOutput from head:\n"); outlist(head);
printf("\nOutput from tail: \n");
while (head->next != NULL){
fun(head);
printf("\n\n");
printf("\nOutput from head again :\n"); outlist(head);
}
}
给定程序MODI1.C中函数fun的功能是:将字符串中的字符按逆序输出,但不改变字符串中的内容。
例如，若字符串为abcd，则应输出：dcba。
请改正程序中的错误，使它能计算出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
/************found************/
fun (char a)
{ if ( *a )
{ fun(a+1) ;
/************found************/
printf("%c" *a) ;
}
}
main( )
{ char s[10]="abcd";
printf("处理前字符串=%s\n处理后字符串=", s);
fun(s); printf("\n") ;
}
请编写一个函数fun，它的功能是：比较两个字符串的长度,(不得调用C语言提供的求字符串长度的函数)，函数返回较长的字符串。若两个字符串长度相同，则返回第一个字符串。
例如，输入beijing <CR> shanghai <CR>（<CR>为回车键）,
函数将返回shanghai。
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容,仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
char *fun ( char *s, char *t)
{
}
main( )
{ char a[20],b[20];
void NONO ( );
printf("Input 1th string:") ;
gets( a);
printf("Input 2th string:") ;
gets( b);
printf("%s\n",fun (a, b ));
NONO ();
}
填空题参考答案：
1) t=t->next;
2) printf(" %d ",t->data);
3) free(t);
修改题参考答案：
1) fun (char *a)
2) printf("%c", *a) ;
程序题参考答案：
char *fun ( char *s, char *t)
{
int sl=0,tl=0,i;
for(i=0 ; s ; i++)
sl++;
for(i=0 ; t ; i++)
tl++;
if(sl>=tl)
return s;
else
return t;
}
第7套
给定程序中已建立一个带有头结点的单向链表，链表中的各结点按数据域递增有序链接。函数fun的功能是：删除链表中数据域值相同的结点,使之只保留一个。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{ int data;
struct list *next;
} SLIST;
void fun( SLIST *h)
{ SLIST *p, *q;
p=h->next;
if (p!=NULL)
{ q=p->next;
while(q!=NULL)
{ if (p->data==q->data)
{ p->next=q->next;
/**********found**********/
free(___1___);
/**********found**********/
q=p->___2___;
}
else
{ p=q;
/**********found**********/
q=q->___3___;
}
}
}
}
SLIST *creatlist(int *a)
{ SLIST *h,*p,*q; int i;
h=p=(SLIST *)malloc(sizeof(SLIST));
for(i=0; i<N; i++)
{ q=(SLIST *)malloc(sizeof(SLIST));
q->data=a; p->next=q; p=q;
}
p->next=0;
return h;
}
void outlist(SLIST *h)
{ SLIST *p;
p=h->next;
if (p==NULL) printf("\nThe list is NULL!\n");
else
{ printf("\nHead");
do { printf("->%d",p->data); p=p->next; } while(p!=NULL);
printf("->End\n");
}
}
main( )
{ SLIST *head; int a[N]={1,2,2,3,4,4,4,5};
head=creatlist(a);
printf("\nThe list before deleting :\n"); outlist(head);
fun(head);
printf("\nThe list after deleting :\n"); outlist(head);
}
给定程序MODI1.C中函数fun的功能是:用选择法对数组中的n个元素按从小到大的顺序进行排序。
请修改程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行和删行，也不得更改程序的结构！
#include <stdio.h>
#define N 20
void fun(int a[], int n)
{ int i, j, t, p;
for (j = 0 ;j < n-1 ;j++) {
/************found************/
p = j
for (i = j;i < n; i++)
if(a < a
)
/************found************/
p = j;
t = a
; a
= a[j] ; a[j] = t;
}
}
main()
{
int a[N]={9,6,8,3,-1},i, m = 5;
printf("排序前的数据:") ;
for(i = 0;i < m;i++) printf("%d ",a); printf("\n");
fun(a,m);
printf("排序后的数据:") ;
for(i = 0;i < m;i++) printf("%d ",a); printf("\n");
}
请编写一个函数fun，它的功能是：求出1到m之间(含m)能被7或11整除的所有整数放在数组a中，通过n返回这些数的个数。例如，若传送给m的值为50，则程序输出：
7 11 14 21 22 28 33 35 42 44 49
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#define M 100
void fun ( int m, int *a , int *n )
{
}
main( )
{ int aa[M], n, k;
void NONO ( );
fun ( 50, aa, &n );
for ( k = 0; k < n; k++ )
if((k+1)%20==0) printf("\n");
else printf( "%4d", aa[k] );
printf("\n") ;
NONO( );
}
填空题参考答案：
1) free(q);
2) q=p->next;
3) q=q->next;
修改题参考答案：
1) p = j;
2) p = i;
程序题参考答案：
void fun ( int m, int *a , int *n )
{
int i,cnt=0 ;
for(i=7 ; i<=m; i++)
if((i % 7 == 0) || (i % 11 == 0)) a[cnt++]=i ;
*n=cnt;
}
第8套
给定程序中，函数fun的功能是:在带有头结点的单向链表中，查找数据域中值为ch的结点。找到后通过函数值返回该结点在链表中所处的顺序号；若不存在值为ch的结点，函数返回0值。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{ int data;
struct list *next;
} SLIST;
SLIST *creatlist(char *);
void outlist(SLIST *);
int fun( SLIST *h, char ch)
{ SLIST *p; int n=0;
p=h->next;
/**********found**********/
while(p!=___1___)
{ n++;
/**********found**********/
if (p->data==ch) return ___2___;
else p=p->next;
}
return 0;
}
main()
{ SLIST *head; int k; char ch;
char a[N]={'m','p','g','a','w','x','r','d'};
head=creatlist(a);
outlist(head);
printf("Enter a letter:");
scanf("%c",&ch);
/**********found**********/
k=fun(___3___);
if (k==0) printf("\nNot found!\n");
else printf("The sequence number is : %d\n",k);
}
SLIST *creatlist(char *a)
{ SLIST *h,*p,*q; int i;
h=p=(SLIST *)malloc(sizeof(SLIST));
for(i=0; i<N; i++)
{ q=(SLIST *)malloc(sizeof(SLIST));
q->data=a; p->next=q; p=q;
}
p->next=0;
return h;
}
void outlist(SLIST *h)
{ SLIST *p;
p=h->next;
if (p==NULL) printf("\nThe list is NULL!\n");
else
{ printf("\nHead");
do
{ printf("->%c",p->data); p=p->next; }
while(p!=NULL);
printf("->End\n");
}
}
给定程序MODI1.C中函数fun的功能是:删除p所指字符串中的所有空白字符(包括制表符、回车符及换行符)。
输入字符串时用'#'结束输入。
请改正程序中的错误，使它能输出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <string.h>
#include <stdio.h>
#include <ctype.h>
fun ( char *p)
{ int i,t; char c[80];
/************found************/
For (i = 0,t = 0; p ; i++)
if(!isspace(*(p+i))) c[t++]=p;
/************found************/
c[t]="\0";
strcpy(p,c);
}
main( )
{ char c,s[80];
int i=0;
printf("Input a string:");
c=getchar();
while(c!='#')
{ s=c;i++;c=getchar(); }
s='\0';
fun(s);
puts(s);
}
请编写一个函数fun，它的功能是：将ss所指字符串中所有下标为奇数位置上的字母转换为大写(若该位置上不是字母，则不转换)。
例如, 若输入"abc4EFg"，则应输出"aBc4EFg"。
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
void fun ( char *ss )
{
}
main( )
{ char tt[81] ;
void NONO ( );
printf( "\nPlease enter an string within 80 characters:\n" ); gets( tt );
printf( "\n\nAfter changing, the string\n \"%s\"", tt );
fun( tt );
printf( "\nbecomes\n \"%s\"\n", tt );
NONO ( );
}
填空题参考答案：
1) while(p!=0)
2) if (p->data==ch) return n;
3) k=fun(head,ch);
修改题参考答案：
1) for (i = 0,t = 0; p ; i++)
2) c[t]='\0';
程序题参考答案：
void fun ( char *ss )
{
int i ;
for(i = 0 ; ss ; i++) {
if(i%2==1 && ss >= 'a' && ss <= 'z') ss -= 32 ;
}
}
第9套
给定程序中,函数fun的功能是:统计出带有头结点的单向链表中结点的个数,存放在形参n所指的存储单元中。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{ int data;
struct list *next;
} SLIST;
SLIST *creatlist(int *a);
void outlist(SLIST *);
void fun( SLIST *h, int *n)
{ SLIST *p;
/**********found**********/
___1___=0;
p=h->next;
while(p)
{ (*n)++;
/**********found**********/
p=p->___2___;
}
}
main()
{ SLIST *head;
int a[N]={12,87,45,32,91,16,20,48}, num;
head=creatlist(a); outlist(head);
/**********found**********/
fun(___3___, &num);
printf("\nnumber=%d\n",num);
}
SLIST *creatlist(int a[])
{ SLIST *h,*p,*q; int i;
h=p=(SLIST *)malloc(sizeof(SLIST));
for(i=0; i<N; i++)
{ q=(SLIST *)malloc(sizeof(SLIST));
q->data=a; p->next=q; p=q;
}
p->next=0;
return h;
}
void outlist(SLIST *h)
{ SLIST *p;
p=h->next;
if (p==NULL) printf("The list is NULL!\n");
else
{ printf("\nHead ");
do
{ printf("->%d",p->data); p=p->next; }
while(p!=NULL);
printf("->End\n");
}
}
给定程序MODI1.C中函数fun的功能是：求出s所指字符串中最后一次出现的t所指子字符串的地址，通过函数值返回，在主函数中输出从此地址开始的字符串;若未找到，则函数值为NULL。
例如，当字符串中的内容为："abcdabfabcdx"，t中的内容为："ab"时，输出结果应是：abcdx。
当字符串中的内容为："abcdabfabcdx"，t中的内容为："abd"时，则程序输出未找到信息：not be found!。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
char * fun (char *s, char *t )
{
char *p , *r, *a;
/************found************/
a = Null;
while ( *s )
{ p = s; r = t;
while ( *r )
/************found************/
if ( r == p )
{ r++; p++; }
else break;
if ( *r == '\0' ) a = s;
s++;
}
return a ;
}
main()
{
char s[100], t[100], *p;
printf("\nPlease enter string S :"); scanf("%s", s );
printf("\nPlease enter substring t :"); scanf("%s", t );
p = fun( s, t );
if ( p ) printf("\nThe result is : %s\n", p);
else printf("\nNot found !\n" );
}
函数fun的功能是： 将s所指字符串中除了下标为偶数、同时ASCII值也为偶数的字符外,其余的全都删除；串中剩余字符所形成的一个新串放在t所指的数组中。
例如，若s所指字符串中的内容为："ABCDEFG123456"，其中字符A的ASCII码值为奇数，因此应当删除；其中字符B的ASCII码值为偶数，但在数组中的下标为奇数，因此也应当删除；而字符2的ASCII码值为偶数，所在数组中的下标也为偶数，因此不应当删除，其它依此类推。最后t所指的数组中的内容应是："246"。
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容,仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
void fun(char *s, char t[])
{
}
main()
{
char s[100], t[100];
void NONO ( );
printf("\nPlease enter string S:"); scanf("%s", s);
fun(s, t);
printf("\nThe result is: %s\n", t);
NONO();
}
填空题参考答案：
1) *n=0;
2) p=p->next;
3) fun(head, &num);
修改题参考答案：
1) a = NULL;
2) if ( *r == *p )
程序题参考答案：
void fun(char *s, char t[])
{
int i, j = 0 ;
for(i = 0 ; s ; i++)
if(i%2==0 && s % 2 == 0) t[j++] = s ;
t[j] = 0 ;
}
第10套
给定程序中，函数fun的功能是:计算出带有头结点的单向链表中各结点数据域中值之和作为函数值返回。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{ int data;
struct list *next;
} SLIST;
SLIST *creatlist(int *);
void outlist(SLIST *);
int fun( SLIST *h)
{ SLIST *p; int s=0;
p=h->next;
while(p)
{
/**********found**********/
s+= p->___1___;
/**********found**********/
p=p->___2___;
}
return s;
}
main()
{ SLIST *head;
int a[N]={12,87,45,32,91,16,20,48};
head=creatlist(a); outlist(head);
/**********found**********/
printf("\nsum=%d\n", fun(___3___));
}
SLIST *creatlist(int a[])
{ SLIST *h,*p,*q; int i;
h=p=(SLIST *)malloc(sizeof(SLIST));
for(i=0; i<N; i++)
{ q=(SLIST *)malloc(sizeof(SLIST));
q->data=a; p->next=q; p=q;
}
p->next=0;
return h;
}
void outlist(SLIST *h)
{ SLIST *p;
p=h->next;
if (p==NULL) printf("The list is NULL!\n");
else
{ printf("\nHead ");
do
{ printf("->%d", p->data); p=p->next; }
while(p!=NULL);
printf("->End\n");
}
}
给定程序MODI1.C中函数fun的功能是:将s所指字符串中出现的与t1所指字符串相同的子串全部替换成t2所指字符串,所形成的新串放在w所指的数组中。在此处，要求t1和t2所指字符串的长度相同。
例如，当s所指字符串中的内容为："abcdabfab"，t1所指子串中的内容为："ab"，t2所指子串中的内容为："99"时， 结果在w所指的数组中的内容应：
"99cd99f99"。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
void fun (char *s, char *t1, char *t2 , char *w)
{
char *p , *r, *a;
strcpy( w, s );
while ( *w )
{ p = w; r = t1;
/************found************/
while ( r )
if ( *r == *p ) { r++; p++; }
else break;
if ( *r == '\0' )
{ a = w; r = t2;
while ( *r ){
/************found************/
*a = *r; a++; r++
}
w += strlen(t2) ;
}
else w++;
}
}
main()
{
char s[100], t1[100], t2[100], w[100];
printf("\nPlease enter string S:"); scanf("%s", s);
printf("\nPlease enter substring t1:"); scanf("%s", t1);
printf("\nPlease enter substring t2:"); scanf("%s", t2);
if ( strlen(t1)==strlen(t2) ) {
fun( s, t1, t2, w);
printf("\nThe result is : %s\n", w);
}
else printf("Error : strlen(t1) != strlen(t2)\n");
}
函数fun的功能是：将s所指字符串中下标为偶数的字符删除，串中剩余字符形成的新串放在t所指数组中。
例如，当s所指字符串中的内容为："ABCDEFGHIJK"，
在t所指数组中的内容应是："BDFHJ"。
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容,仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
void fun(char *s, char t[])
{
}
main()
{
char s[100], t[100];
void NONO ( );
printf("\nPlease enter string S:"); scanf("%s", s);
fun(s, t);
printf("\nThe result is: %s\n", t);
NONO();
}
填空题参考答案：
1) s+= p->data;
2) p=p->next;
3) printf("\nsum=%d\n", fun(head));
修改题参考答案：
1) while ( *r )
2) *a = *r; a++; r++;
程序题参考答案：
void fun(char *s, char t[])
{
int i, j = 0 ;
for(i = 0 ; s; i++)
if(i%2==1)
t[j++] = s ;
t[j] = 0 ;
}
第11套
人员的记录由编号和出生年、月、日组成,N名人员的数据已在主函数中存入结构体数组std中，且编号唯一。函数fun的功能是：找出指定编号人员的数据，作为函数值返回,由主函数输出,若指定编号不存在，返回数据中的编号为空串。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结
果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#define N 8
typedef struct
{ char num[10];
int year,month,day ;
}STU;
/**********found**********/
___1___ fun(STU *std, char *num)
{ int i; STU a={"",9999,99,99};
for (i=0; i<N; i++)
/**********found**********/
if( strcmp(___2___,num)==0 )
/**********found**********/
return (___3___);
return a;
}
main()
{ STU std[N]={ {"111111",1984,2,15},{"222222",1983,9,21},{"333333",1984,9,1},
{"444444",1983,7,15},{"555555",1984,9,28},{"666666",1983,11,15},
{"777777",1983,6,22},{"888888",1984,8,19}};
STU p; char n[10]="666666";
p=fun(std,n);
if(p.num[0]==0)
printf("\nNot found !\n");
else
{ printf("\nSucceed !\n ");
printf("%s %d-%d-%d\n",p.num,p.year,p.month,p.day);
}
}
给定程序MODI1.C中函数fun的功能是：从s所指字符串中，找出与t所指字符串相同的子串的个数作为函数值返回。
例如，当s所指字符串中的内容为："abcdabfab"，t所指字符串的内容为："ab"，则函数返回整数3。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
int fun (char *s, char *t)
{
int n; char *p , *r;
n = 0;
while ( *s )
{ p = s; r = t;
while ( *r )
if ( *r == *p ) {
/************found************/
r++; p++
}
else break;
/************found************/
if ( r == '\0' )
n++;
s++;
}
return n;
}
main()
{
char s[100], t[100]; int m;
printf("\nPlease enter string S:"); scanf("%s", s);
printf("\nPlease enter substring t:"); scanf("%s", t);
m = fun( s, t);
printf("\nThe result is: m = %d\n", m);
}
函数fun的功能是：将s所指字符串中ASCII值为偶数的字符删除，串中剩余字符形成一个新串放在t所指的数组中。
例如，若s所指字符串中的内容为："ABCDEFG12345"，其中字符B的ASCII码值为偶数、…、字符2的ASCII码值为偶数、… 都应当删除,其它依此类推。最后t所指的数组中的内容应是："ACEG135"。
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
void fun(char *s, char t[])
{
}
main()
{
char s[100], t[100];
printf("\nPlease enter string S:"); scanf("%s", s);
fun(s, t);
printf("\nThe result is: %s\n", t);
NONO();
}
填空题参考答案：
1) STU fun(STU *std, char *num)
2) if( strcmp(std.num,num)==0 )
3) return (std);
修改题参考答案：
1) r++; p++;
2) if ( *r == 0 )
程序题参考答案：
void fun(char *s, char t[])
{
int i, j = 0 ;
for(i = 0 ; s; i++)
if(s % 2==1)
t[j++] = s ;
t[j] = 0 ;
}
第12套
人员的记录由编号和出生年、月、日组成,N名人员的数据已在主函数中存入结构体数组std中。函数fun的功能是：找出指定出生年份的人员，将其数据放在形参k所指的数组中，由主函数输出，同时由函数值返回满足指定条件的人数。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define N 8
typedef struct
{ int num;
int year,month,day ;
}STU;
int fun(STU *std, STU *k, int year)
{ int i,n=0;
for (i=0; i<N; i++)
/**********found**********/
if( ___1___==year)
/**********found**********/
k[n++]= ___2___;
/**********found**********/
return (___3___);
}
main()
{ STU std[N]={ {1,1984,2,15},{2,1983,9,21},{3,1984,9,1},{4,1983,7,15},
{5,1985,9,28},{6,1982,11,15},{7,1982,6,22},{8,1984,8,19}};
STU k[N]; int i,n,year;
printf("Enter a year : "); scanf("%d",&year);
n=fun(std,k,year);
if(n==0)
printf("\nNo person was born in %d \n",year);
else
{ printf("\nThese persons were born in %d \n",year);
for(i=0; i<n; i++)
printf("%d %d-%d-%d\n",k.num,k.year,k.month,k.day);
}
}
给定程序MODI1.C的功能是:读入一个整数k(2≤k≤10000)，打印它的所有质因子（即所有为素数的因子）。
例如，若输入整数：2310，则应输出：2、3、5、7、11。
请改正程序中的语法错误，使程序能得出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
/************found************/
IsPrime ( int n );
{ int i, m;
m = 1;
for ( i = 2; i < n; i++ )
/************found************/
if !( n%i )
{ m = 0; break ; }
return ( m );
}
main( )
{ int j, k;
printf( "\nPlease enter an integer number between 2 and 10000: " ); scanf( "%d", &k );
printf( "\n\nThe prime factor(s) of %d is( are ):", k );
for( j = 2; j <= k; j++ )
if( ( !( k%j ) )&&( IsPrime( j ) ) ) printf( "\n %4d", j );
printf("\n");
}
已知学生的记录由学号和学习成绩构成，N名学生的数据已存入结构体数组a中。请编写函数 fun，函数的功能是：找出成绩最高的学生记录，通过形参指针传回主函数(规定只有一个最高分)。已给出函数的首部，请完成该函数。
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容,仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
#define N 10
typedef struct ss
{ char num[10]; int s; } STU;
fun( STU a[], STU *s )
{
}
main ( )
{ STU a[N]={ {"A01",81},{"A02",89},{"A03",66},{"A04",87},{"A05",77},
{"A06",90},{"A07",79},{"A08",61},{"A09",80},{"A10",71} }, m ;
int i;
printf("***** The original data *****\n");
for ( i=0; i< N; i++ )printf("No = %s Mark = %d\n", a.num,a.s);
fun ( a, &m );
printf ("***** THE RESULT *****\n");
printf ("The top : %s , %d\n",m.num, m.s);
NONO( );
}
填空题参考答案：
1) if(std.year==year)
2) k[n++]= std;
3) return (n);
修改题参考答案：
1) IsPrime ( int n )
2) if (!( n%i ))
程序题参考答案：
fun( STU a[], STU *s )
{
int i;
STU max = a[0] ;
for(i = 1 ; i < N ; i++)
if(max.s < a.s) {
max = a;
}
*s = max ;
}
第13套
给定程序通过定义并赋初值的方式，利用结构体变量存储了一名学生的学号、姓名和3门课的成绩。函数fun的功能是将该学生的各科成绩都乘以一个系数a。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
typedef struct
{ int num;
char name[9];
float score[3];
}STU;
void show(STU tt)
{ int i;
printf("%d %s : ",tt.num,tt.name);
for(i=0; i<3; i++)
printf("%5.1f",tt.score);
printf("\n");
}
/**********found**********/
void modify(___1___ *ss,float a)
{ int i;
for(i=0; i<3; i++)
/**********found**********/
ss->___2___ *=a;
}
main( )
{ STU std={ 1,"Zhanghua",76.5,78.0,82.0 };
float a;
printf("\nThe original number and name and scores :\n");
show(std);
printf("\nInput a number : "); scanf("%f",&a);
/**********found**********/
modify(___3___,a);
printf("\nA result of modifying :\n");
show(std);
}
给定程序MODI1.C中函数fun的功能是：求k!（k<13），所求阶乘的值作为函数值返回。例如：若k = 10，则应输出：3628800。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
long fun ( int k)
{
/************found************/
if k > 0
return (k*fun(k-1));
/************found************/
else if ( k=0 )
return 1L;
}
main()
{ int k = 10 ;
printf("%d!=%ld\n", k, fun ( k )) ;
}
程序定义了N×N的二维数组，并在主函数中自动赋值。请编写函数fun(int a[][N], int n)，函数的功能是：使数组左下三角元素中的值乘以n 。
例如：若n的值为3，a 数组中的值为
| 1 9 7 | | 3 9 7 |
a= | 2 3 8 | 则返回主程序后a数组中的值应为 | 6 9 8 |
| 4 5 6 | | 12 15 18|
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <stdlib.h>
#define N 5
int fun ( int a[][N], int n )
{
}
main ( )
{ int a[N][N], n, i, j;
printf("***** The array *****\n");
for ( i =0; i<N; i++ )
{ for ( j =0; j<N; j++ )
{ a[j] = rand()%10; printf( "%4d", a[j] ); }
printf("\n");
}
do n = rand()%10 ; while ( n >=3 );
printf("n = %4d\n",n);
fun ( a, n );
printf ("***** THE RESULT *****\n");
for ( i =0; i<N; i++ )
{ for ( j =0; j<N; j++ ) printf( "%4d", a[j] );
printf("\n");
}
NONO( );
}
填空题参考答案：
1) void modify(STU *ss,float a)
2) ss->score *=a;
3) modify(&std,a);
修改题参考答案：
1) if (k > 0)
2) else if ( k==0 )程序题参考答案：
int fun ( int a[][N], int n )
{
int i, j;
for(i = 0 ; i < N ; i++)
for(j = 0 ; j <= i; j++)
a[j] *= n ;
}
第14套
#include <stdio.h>
typedef struct
{ int num;
char name[10];
}PERSON;
/**********found**********/
void fun(PERSON ___1___)
{
/**********found**********/
___2___ temp;
if(std[0].num>std[1].num)
{ temp=std[0]; std[0]=std[1]; std[1]=temp; }
if(std[0].num>std[2].num)
{ temp=std[0]; std[0]=std[2]; std[2]=temp; }
if(std[1].num>std[2].num)
{ temp=std[1]; std[1]=std[2]; std[2]=temp; }
}
main()
{ PERSON std[ ]={ 5,"Zhanghu",2,"WangLi",6,"LinMin" };
int i;
/**********found**********/
fun(___3___);
printf("\nThe result is :\n");
for(i=0; i<3; i++)
printf("%d,%s\n",std.num,std.name);
}
给定程序MODI1.C中函数fun的功能是:将 m（1≤m≤10）个字符串连接起来，组成一个新串，放入pt所指存储区中。
例如：把3个串："abc","CD","EF"连接起来，结果是 "abcCDEF"。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
int fun ( char str[][10], int m, char *pt )
{
/************found************/
Int k, q, i ;
for ( k = 0; k < m; k++ )
{ q = strlen ( str [k] );
for (i=0; i<q; i++)
/************found************/
pt = str[k,i] ;
pt += q ;
pt[0] = 0 ;
}
}
main( )
{ int m, h ;
char s[10][10], p[120] ;
printf( "\nPlease enter m:" ) ;
scanf("%d", &m) ; gets(s[0]) ;
printf( "\nPlease enter %d string:\n", m ) ;
for ( h = 0; h < m; h++ ) gets( s[h]) ;
fun(s, m, p) ;
printf( "\nThe result is : %s\n", p) ;
}
程序定义了N×N的二维数组，并在主函数中自动赋值。请编写函数fun( int a[][N])，函数的功能是：使数组左下三角元素中的值全部置成0 。
例如：a 数组中的值为
| 1 9 7 | | 0 9 7 |
a = | 2 3 8 | 则返回主程序后a数组中的值应为 | 0 0 8 |
| 4 5 6 | | 0 0 0 |
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <stdlib.h>
#define N 5
int fun ( int a[][N] )
{
}
main ( )
{ int a[N][N], i, j;
printf("***** The array *****\n");
for ( i =0; i<N; i++ )
{ for ( j =0; j<N; j++ )
{ a[j] = rand()%10; printf( "%4d", a[j] ); }
printf("\n");
}
fun ( a );
printf ("THE RESULT\n");
for ( i =0; i<N; i++ )
{ for ( j =0; j<N; j++ ) printf( "%4d", a[j] );
printf("\n");
}
NONO( );
}
填空题参考答案：
1) void fun(PERSON *std)
2) PERSON temp;
3) fun(std);
修改题参考答案：
1) int k, q, i ;
2) pt = str[k] ;
程序题参考答案：
int fun ( int a[][N] )
{
int i, j;
for(i = 0 ; i < N ; i++)
for(j = 0 ; j <= i; j++)
a[j] = 0 ;
}
第15套
给定程序中，函数fun的功能是：将形参std所指结构体数组中年龄最大者的数据作为函数值返回，并在main函数中输出。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
typedef struct
{ char name[10];
int age;
}STD;
STD fun(STD std[], int n)
{ STD max; int i;
/**********found**********/
max= ___1___;
for(i=1; i<n; i++)
/**********found**********/
if(max.age<___2___) max=std;
return max;
}
main( )
{ STD std[5]={"aaa",17,"bbb",16,"ccc",18,"ddd",17,"eee",15 };
STD max;
max=fun(std,5);
printf("\nThe result: \n");
/**********found**********/
printf("\nName : %s, Age : %d\n", ___3___,max.age);
}
给定程序MODI1.C中函数 fun 的功能是：实现两个整数的交换。
例如给a和b分别输入：60 和 65，输出为：a = 65 b = 60
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
/**********found**********/
void fun ( int a, b )
{ int t;
/**********found**********/
t = b; b = a ; a = t;
}
main ( )
{ int a, b;
printf ( "Enter a , b : "); scanf ( "%d,%d", &a, &b );
fun ( &a , &b ) ;
printf (" a = %d b = %d\n ", a, b );
}
请编一个函数void fun(int tt[M][N ], int pp[N])，tt指向一个M行N列的二维数组，求出二维数组每列中最小元素，并依次放入pp所指一维数组中。二维数组中的数已在主函数中赋予。
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容,仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#define M 3
#define N 4
void fun ( int tt[M][N], int pp[N] )
{
}
main( )
{ int t [ M ][ N ]={{22,45, 56,30},
{19,33, 45,38},
{20,22, 66,40}};
int p [ N ], i, j, k;
printf ( "The original data is : \n" );
for( i=0; i<M; i++ ){
for( j=0; j<N; j++ )
printf ( "%6d", t[j] );
printf("\n");
}
fun ( t, p );
printf( "\nThe result is:\n" );
for ( k = 0; k < N; k++ ) printf ( " %4d ", p[ k ] );
printf("\n");
NONO( );
}
阅
填空题参考答案：
1) max= *std;
2) if(max.age<std.age) max=std;
3) printf("\nName : %s, Age : %d\n", max.name,max.age);
修改题参考答案：
1) void fun ( int *a, int *b )
2) t = *b; *b = *a ; *a = t;
程序题参考答案：
void fun ( int tt[M][N], int pp[N] )
{
int i,j, min, k ;
for(i = 0 ; i < N ; i++)
{
min = tt[0] ;
k = 0 ;
for(j = 1 ; j < M ; j++)
if(min > tt[j])
{
min=tt[j] ;
k = j ;
}
pp = tt[k] ;
}
}
第16套
程序通过定义并赋初值的方式，利用结构体变量存储了一名学生的信息。函数fun的功能是输出这位学生的信息。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
typedef struct
{ int num;
char name[9];
char sex;
struct { int year,month,day ;} birthday;
float score[3];
}STU;
/**********found**********/
void show(STU ___1___)
{ int i;
printf("\n%d %s %c %d-%d-%d", tt.num, tt.name, tt.sex,
tt.birthday.year, tt.birthday.month, tt.birthday.day);
for(i=0; i<3; i++)
/**********found**********/
printf("%5.1f", ___2___);
printf("\n");
}
main( )
{ STU std={ 1,"Zhanghua",'M',1961,10,8,76.5,78.0,82.0 };
printf("\nA student data:\n");
/**********found**********/
show(___3___);
}
给定程序MODI1.C中函数 fun 的功能是：求出数组中最大数和次最大数，并把最大数和a[0]中的数对调、次最大数和a[1]中的数对调。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define N 20
int fun ( int * a, int n )
{ int i, m, t, k ;
for(i=0;i<2;i++) {
/**********found**********/
m=0;
for(k=i+1;k<n;k++)
/**********found**********/
if(a[k]>a[m]) k=m;
t=a;a=a[m];a[m]=t;
}
}
main( )
{ int x, b[N]={11,5,12,0,3,6,9,7,10,8}, n=10, i;
for ( i=0; i<n; i++ ) printf("%d ", b);
printf("\n");
fun ( b, n );
for ( i=0; i<n; i++ ) printf("%d ", b);
printf("\n");
}
请编写一个函数 unsigned fun ( unsigned w )，w 是一个大于10的无符号整数，若 w 是 n (n ≥ 2)位的整数，函数求出w的低 n-1位的数作为函数值返回。
例如：w 值为 5923，则函数返回 923； w 值为 923 则函数返回 23。
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
unsigned fun ( unsigned w )
{
}
main( )
{ unsigned x;
printf ( "Enter a unsigned integer number : " ); scanf ( "%u", &x );
printf ( "The original data is : %u\n", x );
if ( x < 10 ) printf ("Data error !");
else printf ( "The result : %u\n", fun ( x ) );
NONO( );
}
填空题参考答案：
1) void show(STU tt)
2) printf("%5.1f", tt.score);
3) show(std);
修改题参考答案：
1) m=i;
2) if(a[k]>a[m]) m=k;
程序题参考答案：
unsigned fun ( unsigned w )
{
if(w>10000) w %= 10000 ;
else if(w>1000) w %= 1000 ;
else if(w>100) w %= 100 ;
else if(w>10) w %=10 ;
return w ;
}
第17套
给定程序中，函数fun的功能是：对形参ss所指字符串数组中的M个字符串按长度由短到长进行排序。ss所指字符串数组中共有M个字符串，且串长<N。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#define M 5
#define N 20
void fun(char (*ss)[N])
{ int i, j, k, n[M]; char t[N];
for(i=0; i<M; i++) n=strlen(ss);
for(i=0; i<M-1; i++)
{ k=i;
/**********found**********/
for(j=___1___; j<M; j++)
/**********found**********/
if(n[k]>n[j]) ___2___;
if(k!=i)
{ strcpy(t,ss);
strcpy(ss,ss[k]);
/**********found**********/
strcpy(ss[k],___3___);
n[k]=n;
}
}
}
main()
{ char ss[M][N]={"shanghai","guangzhou","beijing","tianjing","cchongqing"};
int i;
printf("\nThe original strings are :\n");
for(i=0; i<M; i++) printf("%s\n",ss);
printf("\n");
fun(ss);
printf("\nThe result :\n");
for(i=0; i<M; i++) printf("%s\n",ss);
}
给定程序MODI1.C中函数 fun 的功能是:判断ch中的字符是否与str所指串中的某个字符相同； 若相同，什么也不做，若不同，则将其插在串的最后。
请改正程序中的错误，使它能进行正确的操作。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
/**********found**********/
void fun(char str, char ch )
{ while ( *str && *str != ch ) str++;
/**********found**********/
if ( *str == ch )
{ str [ 0 ] = ch;
/**********found**********/
str[1] = '0';
}
}
main( )
{ char s[81], c ;
printf( "\nPlease enter a string:\n" ); gets ( s );
printf ("\n Please enter the character to search : " );
c = getchar();
fun(s, c) ;
printf( "\nThe result is %s\n", s);
}
请编一个函数fun(char *s)，函数的功能是把s所指字符串中的内容逆置。
例如：字符串中原有的字符串为：abcdefg，
则调用该函数后, 串中的内容为：gfedcba。
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <string.h>
#include <stdio.h>
#define N 81
fun ( char *s )
{
}
main( )
{ char a[N];
printf ( "Enter a string : " ); gets ( a );
printf ( "The original string is : " ); puts( a );
fun ( a );
printf("\n");
printf ( "The string after modified : ");
puts ( a );
NONO( );
}
填空题参考答案：
1) for(j=i+1; j<M; j++)
2) if(n[k]>n[j]) k=j;
3) strcpy(ss[k],t);
修改题参考答案：
1) void fun(char *str, char ch )
2) if ( *str != ch )
3) str[1] = 0;
程序题参考答案：
fun ( char *s )
{
int i,j;
char t;
for(i=0,j=strlen(s)-1 ; i<j ; i++,j--)
{ t=s; s=s[j] ; s[j]=t ;}
}
第18套
给定程序中，函数fun的功能是:求出形参ss所指字符串数组中最长字符串的长度，其余字符串左边用字符*补齐,使其与最长的字符串等长。字符串数组中共有M个字符串，且串长<N。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#define M 5
#define N 20
void fun(char (*ss)[N])
{ int i, j, k=0, n, m, len;
for(i=0; i<M; i++)
{ len=strlen(ss);
if(i==0) n=len;
if(len>n) {
/**********found**********/
n=len; ___1___=i;
}
}
for(i=0; i<M; i++)
if (i!=k)
{ m=n;
len=strlen(ss);
/**********found**********/
for(j=___2___; j>=0; j--)
ss[m--]=ss[j];
for(j=0; j<n-len; j++)
/**********found**********/
___3___='*';
}
}
main()
{ char ss[M][N]={"shanghai","guangzhou","beijing","tianjing","cchongqing"};
int i;
printf("\nThe original strings are :\n");
for(i=0; i<M; i++) printf("%s\n",ss);
printf("\n");
fun(ss);
printf("\nThe result:\n");
for(i=0; i<M; i++) printf("%s\n",ss);
}
给定程序MODI1.C中函数fun的功能是: 计算整数n的阶乘。请改正程序中的错误或在下划线处填上适当的内容并把下划线删除,使它能计算出正确的结果。
注意: 不要改动 main 函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
double fun(int n)
{
double result=1.0;
while (n>1 && n<170)
/*********found*********/
result*=--n;
/*********found*********/
return _____;
}
main()
{
int n;
printf("Enter an integer: ");
scanf("%d",&n);
printf("\n\n%d!=%lg\n\n",n,fun(n));
}
编写函数fun，函数的功能是: 从s所指的字符串中删除给定的字符。同一字母的大、小写按不同字符处理。
若程序执行时输入字符串为: turbo c and borland c++
从键盘上输入字符:n, 则输出后变为: turbo c ad borlad c++
如果输入的字符在字符串中不存在, 则字符串照原样输出。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
int fun(char s[],char c)
{
}
main()
{
static char str[]="turbo c and borland c++";
char ch;
printf("原始字符串:%s\n", str);
printf("输入一个字符:");
scanf("%c",&ch);
fun(str,ch);
printf("str[]=%s\n",str);
NONO();
}
填空题参考答案：
1) n=len; k=i;
2) for(j=len; j>=0; j--)
3) ss[j]='*';
修改题参考答案：
1) result*=n--;
2) return result;
程序题参考答案：
int fun(char s[],char c)
{
int i,j=0;
for(i=0 ; s ; i++)
if(s!=c)
s[j++]=s;
s[j]=0;
}
第19套
给定程序中，函数fun的功能是:求出形参ss所指字符串数组中最长字符串的长度，将其余字符串右边用字符*补齐,使其与最长的字符串等长。ss所指字符串数组中共有M个字符串，且串长<N。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#define M 5
#define N 20
void fun(char (*ss)[N])
{ int i, j, n, len=0;
for(i=0; i<M; i++)
{ len=strlen(ss);
if(i==0) n=len;
if(len>n)n=len;
}
for(i=0; i<M; i++) {
/**********found**********/
n=strlen(___1___);
for(j=0; j<len-n; j++)
/**********found**********/
ss[ ___2___]='*';
/**********found**********/
ss[n+j+ ___3___]='\0';
}
}
main()
{ char ss[M][N]={"shanghai","guangzhou","beijing","tianjing","cchongqing"};
int i;
printf("The original strings are :\n");
for(i=0; i<M; i++) printf("%s\n",ss);
printf("\n");
fun(ss);
printf("The result is :\n");
for(i=0; i<M; i++) printf("%s\n",ss);
}
给定程序MODI1.C中 fun 函数的功能是:将p所指字符串中每个单词的最后一个字母改成大写。(这里的“单词”是指由空格隔开的字符串)。
例如, 若输入
"I am a student to take the examination."，
则应输出 "I aM A studenT tO takE thE examination."。
请修改程序中的错误之处, 使它能得出正确的结果。
注意: 不要改动 main 函数, 不得删行, 也不得更改程序的结构!
#include <ctype.h>
#include <stdio.h>
void fun( char *p )
{
int k = 0;
for( ; *p; p++ )
if( k )
{
/**********found***********/
if( p == ' ' )
{
k = 0;
/**********found***********/
* (p-1) = toupper( *( p - 1 ) )
}
}
else
k = 1;
}
main()
{
char chrstr[64];
int d ;
printf( "\nPlease enter an English sentence within 63 letters: ");
gets(chrstr);
d=strlen(chrstr) ;
chrstr[d] = ' ' ;
chrstr[d+1] = 0 ;
printf("\n\nBefore changing:\n %s", chrstr);
fun(chrstr);
printf("\nAfter changing:\n %s", chrstr);
}
请编写函数fun, 对长度为7个字符的字符串, 除首、尾字符外,将其余5个字符按ASCII码降序排列。
例如，原来的字符串为 CEAedca，排序后输出为 CedcEAa 。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <ctype.h>
#include <string.h>
int fun(char *s,int num)
{
}
main()
{
char s[10];
printf("输入7个字符的字符串:");
gets(s);
fun(s,7);
printf("\n%s",s);
NONO();
}
填空题参考答案：
1) n=strlen(ss);
2) ss[n+j]='*';
3) ss[n+j+1]='\0';
修改题参考答案：
1) if( *p == ' ' )
2) * (p-1) = toupper( *( p - 1 ) );
程序题参考答案：
int fun(char *s,int num)
{
char ch ;
int i, j ;
for(i = 1 ; i < 6 ; i++)
for(j = i + 1 ; j < 6 ; j++)
if(s < s[j])
{
ch = s[j] ; s[j]= s; s= ch ;
}
}
第20套
给定程序中，函数fun的功能是:求ss所指字符串数组中长度最长的字符串所在的行下标,作为函数值返回，并把其串长放在形参n所指变量中。ss所指字符串数组中共有M个字符串，且串长<N。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define M 5
#define N 20
/**********found**********/
int fun(char (*ss) ___1___, int *n)
{ int i, k=0, len=0;
for(i=0; i<M; i++)
{ len=strlen(ss);
/**********found**********/
if(i==0) *n=___2___;
if(len>*n) {
/**********found**********/
___3___;
k=i;
}
}
return(k);
}
main()
{ char ss[M][N]={"shanghai","guangzhou","beijing","tianjing","cchongqing"};
int n,k,i;
printf("\nThe original strings are :\n");
for(i=0;i<M;i++)puts(ss);
k=fun(ss,&n);
printf("\nThe length of longest string is : %d\n",n);
printf("\nThe longest string is : %s\n",ss[k]);
}
给定程序MODI1.C中 fun 函数的功能是: 根据形参m，计算如下公式的值。
1 1 1 1
t = 1 + ----- +----- + ----- + ……+ -----
2 3 4 m
例如，若输入 5，则应输出 2.283333。
请改正程序中的错误或在下划线处填上适当的内容并把下划线删除, 使它能计算出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
double fun( int m )
{
double t = 1.0;
int i;
for( i = 2; i <= m; i++ )
/**********found**********/
t += 1.0/k;
/**********found**********/
________
}
main()
{
int m;
printf( "\nPlease enter 1 integer number:" );
scanf( "%d", &m );
printf( "\nThe result is %lf\n", fun( m ) );
}
编写一个函数，该函数可以统计一个长度为2的字符串在另一个字符串中出现的次数。例如，假定输入的字符串为: asd asasdfg asd as zx67 asd mklo,子字符串为:as，则应输出6。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
int fun(char *str,char *substr)
{
}
main()
{
char str[81],substr[3];
int n;
printf("输入主字符串: ");
gets(str);
printf("输入子字符串: ");
gets(substr);
puts(str);
puts(substr);
n=fun(str,substr);
printf("n=%d\n",n);
NONO();
}
填空题参考答案：
1) int fun(char (*ss) [N], int *n)
2) if(i==0) *n=len;
3) *n=len;
修改题参考答案：
1) t += 1.0/i;
2) return t;
程序题参考答案：
int fun(char *str,char *substr)
{
int i,cnt = 0 ;
for(i=0 ; str ; i++)
if(str==substr[0] && str[i+1]==substr[1])
cnt++;
return cnt ;
}
第21套
给定程序中，函数fun的功能是:求ss所指字符串数组中长度最短的字符串所在的行下标,作为函数值返回，并把其串长放在形参n所指变量中。ss所指字符串数组中共有M个字符串，且串长<N。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#define M 5
#define N 20
int fun(char (*ss)[N], int *n)
{ int i, k=0, len= N;
/**********found**********/
for(i=0; i<___1___; i++)
{ len=strlen(ss);
if(i==0) *n=len;
/**********found**********/
if(len ___2___ *n)
{ *n=len;
k=i;
}
}
/**********found**********/
return(___3___);
}
main()
{ char ss[M][N]={"shanghai","guangzhou","beijing","tianjing","chongqing"};
int n,k,i;
printf("\nThe original strings are :\n");
for(i=0;i<M;i++)puts(ss);
k=fun(ss,&n);
printf("\nThe length of shortest string is : %d\n",n);
printf("\nThe shortest string is : %s\n",ss[k]);
}
给定程序MODI1.C中函数 fun 的功能是：将tt所指字符串中的小写字母都改为对应的大写字母，其它字符不变。
例如，若输入"Ab, cD"，则输出"AB, CD"。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
char* fun( char tt[] )
{
int i;
for( i = 0; tt; i++ )
/**********found***********/
if(( 'a' <= tt )||( tt <= 'z' ) )
/**********found***********/
tt += 32;
return( tt );
}
main( )
{
char tt[81];
printf( "\nPlease enter a string: " );
gets( tt );
printf( "\nThe result string is:\n%s", fun( tt ) );
}
请编写函数fun，其功能是: 将所有大于1小于整数m的非素数存入xx所指数组中, 非素数的个数通过k传回。
例如，若输入:17，则应输出:4 6 8 9 10 12 14 15 16。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容， 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun( int m, int *k, int xx[] )
{
}
main()
{
int m, n, zz[100];
void NONO ( );
printf( "\nPlease enter an integer number between 10 and 100: " );
scanf( "%d", &n );
fun( n, &m, zz );
printf( "\n\nThere are %d non-prime numbers less than %d:", m, n );
for( n = 0; n < m; n++ )
printf( "\n %4d", zz[n] );
NONO();
}
填空题参考答案：
1) for(i=0; i<M; i++)
2) if(len < *n)
3) return(k);
修改题参考答案：
1) if(( 'a' <= tt )&&( tt <= 'z' ) )
2) tt -= 32;
程序题参考答案：
void fun( int m, int *k, int xx[] )
{
int i,j, cnt = 0 ;
for(i = 2 ; i < m ; i++)
for(j=2 ; j<i ; j++)
if(i%j==0)
{ xx[cnt++] = i ; break; }
*k = cnt ;
}
第22套
给定程序中，函数fun的功能是: 将s所指字符串中的所有数字字符移到所有非数字字符之后，并保持数字字符串和非数字字符串原有的先后次序。例如，形参s所指的字符串为：def35adh3kjsdf7。执行结果为：defadhkjsdf3537。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
void fun(char *s)
{ int i, j=0, k=0; char t1[80], t2[80];
for(i=0; s!='\0'; i++)
if(s>='0' && s<='9')
{
/**********found**********/
t2[j]=s; ___1___;
}
else t1[k++]=s;
t2[j]=0; t1[k]=0;
/**********found**********/
for(i=0; i<k; i++) ___2___;
/**********found**********/
for(i=0; i<___3___; i++) s[k+i]=t2;
}
main()
{ char s[80]="ba3a54j7sd567sdffs";
printf("\nThe original string is : %s\n",s);
fun(s);
printf("\nThe result is : %s\n",s);
}
给定程序MODI1.C中函数 fun 的功能是：用冒泡法对6个字符串按由小到大的顺序进行排序。
请改正程序中的错误，使它能得出正确的结果。
注意： 不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#define MAXLINE 20
fun ( char *pstr[6])
{ int i, j ;
char *p ;
for (i = 0 ; i < 5 ; i++ ) {
/**************found**************/
for (j = i + 1, j < 6, j++)
{
if(strcmp(*(pstr + i), *(pstr + j)) > 0)
{
p = *(pstr + i) ;
/**************found**************/
*(pstr + i) = pstr + j ;
*(pstr + j) = p ;
}
}
}
}
main( )
{ int i ;
char *pstr[6], str[6][MAXLINE] ;
for(i = 0; i < 6 ; i++) pstr = str ;
printf( "\nEnter 6 string(1 string at each line): \n" ) ;
for(i = 0 ; i < 6 ; i++) scanf("%s", pstr) ;
fun(pstr) ;
printf("The strings after sorting:\n") ;
for(i = 0 ; i < 6 ; i++) printf("%s\n", pstr) ;
}
请编写函数fun，它的功能是：求出ss所指字符串中指定字符的个数，并返回此值。
例如,若输入字符串: 123412132,输入字符为: 1,则输出:3。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
#define M 81
int fun(char *ss, char c)
{
}
main()
{ char a[M], ch;
void NONO ( );
printf("\nPlease enter a string:"); gets(a);
printf("\nPlease enter a char:"); ch = getchar();
printf("\nThe number of the char is: %d\n", fun(a, ch));
NONO ( );
}
填空题参考答案：
1) t2[j]=s; j++;
2) for(i=0; i<k; i++) s=t1;
3) for(i=0; i<j; i++) s[k+i]=t2;
修改题参考答案：
1) for (j = i + 1; j < 6; j++)
2) *(pstr + i) = *(pstr + j) ;
程序题参考答案：
int fun(char *ss, char c)
{
int i,cnt = 0 ;
for(i=0 ; ss ; i++)
if(ss==c)
cnt++;
return cnt ;
}
第23套
给定程序中，函数fun的功能是：在形参s所指字符串中的每个数字字符之后插入一个*号。例如，形参s所指的字符串为：def35adh3kjsdf7。执行结果为：def3*5*adh3*kjsdf7*。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
void fun(char *s)
{ int i, j, n;
for(i=0; s!='\0'; i++)
/**********found**********/
if(s>='0' ___1___ s<='9')
{ n=0;
/**********found**********/
while(s[i+1+n]!= ___2___) n++;
for(j=i+n+1; j>i; j--)
/**********found**********/
s[j+1]= ___3___;
s[j+1]='*';
i=i+1;
}
}
main()
{ char s[80]="ba3a54cd23a";
printf("\nThe original string is : %s\n",s);
fun(s);
printf("\nThe result is : %s\n",s);
}
给定程序MODI1.C中函数fun的功能是：根据整型形参m，计算如下公式的值。
1 1 1 1
y = 1 + ----- + ----- + ----- + …… + -----
2*2 3*3 4*4 m*m
例如，若 m 中的值为: 5，则应输出：1.463611。
请改正程序中的错误，使它能得出正确的结果。
注意： 不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
double fun ( int m )
{ 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( "\nThe result is %lf\n", fun ( n ) ) ;
}
请编写函数fun, 函数的功能是：实现B=A+A', 即把矩阵A加上A的转置, 存放在矩阵B中。计算结果在 main 函数中输出。
例如，输入下面的矩阵： 其转置矩阵为：
1 2 3 1 4 7
4 5 6 2 5 8
7 8 9 3 6 9
程序输出：
2 6 10
6 10 14
10 14 18
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun ( int a[3][3], int b[3][3])
{
}
main( ) /* 主程序 */
{ int a[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, t[3][3] ;
int i, j ;
void NONO ( );
fun(a, t) ;
for (i = 0 ; i < 3 ; i++) {
for (j = 0 ; j < 3 ; j++)
printf("%7d", t[j]) ;
printf("\n") ;
}
NONO () ;
}
填空题参考答案：
1) if(s>='0' && s<='9')
2) while(s[i+1+n]!= 0) n++;
3) s[j+1]= s[j];
修改题参考答案：
1) for(i = 2 ; i <= m ; i++)
2) y += 1.0 / (i * i) ;
程序题参考答案：
void fun ( int a[3][3], int b[3][3])
{
int i, j ;
for(i = 0 ; i < 3 ; i++)
for(j = 0 ; j < 3 ; j++)
b[j] = a[j] + a[j] ;
}
第24套
给定程序中，函数fun的功能是：统计形参s所指字符串中数字字符出现的次数，并存放在形参t所指的变量中，最后在主函数中输出。例如，形参s所指的字符串为：abcdef35adgh3kjsdf7。输出结果为：4。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
void fun(char *s, int *t)
{ int i, n;
n=0;
/**********found**********/
for(i=0; ___1___ !=0; i++)
/**********found**********/
if(s>='0'&&s<= ___2___ ) n++;
/**********found**********/
___3___ ;
}
main()
{ char s[80]="abcdef35adgh3kjsdf7";
int t;
printf("\nThe original string is : %s\n",s);
fun(s,&t);
printf("\nThe result is : %d\n",t);
}
给定程序MODI1.C中函数fun的功能是：通过某种方式实现两个变量值的交换,规定不允许增加语句和表达式。例如变量a 中的值原为8，b中的值原为3, 程序运行后 a 中的值为 3，b中的值为8。
请改正程序中的错误，使它能得出正确的结果。
注意： 不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
int fun(int *x,int y)
{
int t ;
/**************found**************/
t = x ; x = y ;
/**************found**************/
return(y) ;
}
main()
{
int a = 3, b = 8 ;
printf("%d %d\n", a, b) ;
b = fun(&a, b) ;
printf("%d %d\n", a, b) ;
}
请编写函数fun，它的功能是: 求出 1 到 1000 之间能被 7 或11整除、但不能同时被 7 和 11 整除的所有整数并将它们放在a所指的数组中，通过 n 返回这些数的个数。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun (int *a, int *n)
{
}
main( )
{ int aa[1000], n, k ;
void NONO ( );
fun ( aa, &n ) ;
for ( k = 0 ; k < n ; k++ )
if((k + 1) % 10 == 0) printf("\n") ;
else printf("%5d", aa[k]) ;
NONO( );
}
填空题参考答案：
1) for(i=0; s !=NULL; i++)
2) if(s>='0'&&s<= '9') n++;
3) *t=n;
修改题参考答案：
1) t = *x ; *x = y ;
2) return(t) ;
程序题参考答案：
void fun (int *a, int *n)
{
int i,cnt=0;
for(i=1; i<=1000 ; i++)
if(i%7==0 && i%11!=0 || i%11==0 && i%7!=0)
a[cnt++]=i;
*n=cnt;
}
第25套
给定程序中，函数fun的功能是：把形参s所指字符串中下标为奇数的字符右移到下一个奇数位置，最右边被移出字符串的字符绕回放到第一个奇数位置，下标为偶数的字符不动（注：字符串的长度大于等于2）。例如，形参s所指的字符串为：abcdefgh，执行结果为：ahcbedgf。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
void fun(char *s)
{ int i, n, k; char c;
n=0;
for(i=0; s!='\0'; i++) n++;
/**********found**********/
if(n%2==0) k=n-___1___ ;
else k=n-2;
/**********found**********/
c=___2___ ;
for(i=k-2; i>=1; i=i-2) s[i+2]=s;
/**********found**********/
s[1]=___3___ ;
}
main()
{ char s[80]="abcdefgh";
printf("\nThe original string is : %s\n",s);
fun(s);
printf("\nThe result is : %s\n",s);
}
给定程序MODI1.C中 fun 函数的功能是：求
s = aa… aa - ... - aaa - aa - a
(此处 aa… aa 表示 n 个 a, a 和 n 的值在 1 至 9 之间)
例如 a = 3， n = 6， 则以上表达式为：
s = 333333 - 33333 - 3333 - 333 - 33 - 3
其值是：296298
a 和 n 是 fun 函数的形参，表达式的值作为函数值传回 main函数。
请改正程序中的错误，使它能计算出正确的结果。
注意： 不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
long fun (int a, int n)
{ int j ;
/**************found**************/
long s = 0, t = 1 ;
for ( j = 0 ; j < n ; j++)
t = t * 10 + a ;
s = t ;
for ( j = 1 ; j < n ; j++) {
/**************found**************/
t = t % 10 ;
s = s - t ;
}
return(s) ;
}
main( )
{ int a, n ;
printf( "\nPlease enter a and n:") ;
scanf( "%d%d", &a, &n ) ;
printf( "The value of function is: %ld\n", fun ( a, n ) );
}
请编写一个函数 void fun(char *tt, int pp[])，统计在tt所指字符串中'a' 到 'z' 26个小写字母各自出现的次数，并依次放在pp所指数组中。
例如，当输入字符串：abcdefgabcdeabc 后，程序的输出结果应该是：
3 3 3 2 2 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
void fun(char *tt, int pp[])
{
}
main( )
{ char aa[1000] ;
int bb[26], k ;
void NONO ( );
printf( "\nPlease enter a char string:" ) ; scanf("%s", aa) ;
fun(aa, bb ) ;
for ( k = 0 ; k < 26 ; k++ ) printf ("%d ", bb[k]) ;
printf( "\n" ) ;
NONO ( ) ;
}
填空题参考答案：
1) if(n%2==0) k=n-1;
2) c=s[k];
3) s[1]=c;
修改题参考答案：
1) long s = 0, t = 0 ;
2) t = t / 10 ;
程序题参考答案：
void fun(char *tt, int pp[])
{
int i ;
for(i = 0 ; i < 26 ; i++) pp = 0 ;
for(i=0 ; tt ; i++)
if(tt >= 'a' && tt <= 'z') pp[tt - 'a'] += 1 ;
}
第26套
给定程序中，函数fun的功能是：对形参s所指字符串中下标为奇数的字符按ASCII码大小递增排序，并将排序后下标为奇数的字符取出，存入形参p所指字符数组中，形成一个新串。
例如，形参s所指的字符串为：baawrskjghzlicda，执行后p所指字符数组中的字符串应为：aachjlsw。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
void fun(char *s, char *p)
{ int i, j, n, x, t;
n=0;
for(i=0; s!='\0'; i++) n++;
for(i=1; i<n-2; i=i+2) {
/**********found**********/
___1___;
/**********found**********/
for(j=___2___+2 ; j<n; j=j+2)
if(s[t]>s[j]) t=j;
if(t!=i)
{ x=s; s=s[t]; s[t]=x; }
}
for(i=1,j=0; i<n; i=i+2, j++) p[j]=s;
/**********found**********/
p[j]=___3___;
}
main()
{ char s[80]="baawrskjghzlicda", p[50];
printf("\nThe original string is : %s\n",s);
fun(s,p);
printf("\nThe result is : %s\n",p);
}
给定程序MODI1.C中函数 fun 的功能是：用下面的公式求π的近似值，直到最后一项的绝对值小于指定的数（参数num ）为止：
π 1 1 1
┄┄≈1 - ┄┄ + ┄┄ - ┄┄ + ...
4 3 5 7
例如, 程序运行后, 输入0.0001, 则程序输出3.1414。
请改正程序中的错误，使它能输出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <math.h>
#include <stdio.h>
float fun ( float num )
{ int s ;
float n, t, pi ;
t = 1 ; pi = 0 ; n = 1 ; s = 1 ;
/**************found**************/
while(t >= num)
{
pi = pi + t ;
n = n + 2 ;
s = -s ;
/**************found**************/
t = s % n ;
}
pi = pi * 4 ;
return pi ;
}
main( )
{ float n1, n2 ;
printf("Enter a float number: ") ;
scanf("%f", &n1) ;
n2 = fun(n1) ;
printf("%6.4f\n", n2) ;
}
请编写一个函数void fun (char a[],char b[],int n)，其功能是：删除一个字符串中指定下标的字符。其中, a指向原字符串, 删除指定字符后的字符串存放在b所指的数组中,n中存放指定的下标。
例如,输入一个字符串: World,然后输入3,则调用该函数后的结果为: Word。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容,仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
#define LEN 20
void fun (char a[], char b[], int n)
{
}
main( )
{ char str1[LEN], str2[LEN] ;
int n ;
void NONO ( );
printf("Enter the string:\n") ;
gets(str1) ;
printf("Enter the position of the string deleted:") ;
scanf("%d", &n) ;
fun(str1, str2, n) ;
printf("The new string is: %s\n", str2) ;
NONO() ;
}
填空题参考答案：
1) t=i;
2) for(j=i+2 ; j<n; j=j+2)
3) p[j]=0;
修改题参考答案：
1) while((fabs(t))>=num)
2) t = s / n ;
程序题参考答案：
void fun (char a[], char b[], int n)
{
int i,j=0;
for(i=0 ; a ; i++)
if(i!=n)
b[j++]=a;
b[j]=0;
}
第27套
给定程序中，函数fun的功能是:在形参s所指字符串中寻找与参数c相同的字符，并在其后插入一个与之相同的字符，若找不到相同的字符则函数不做任何处理。
例如，s所指字符串为：baacda，c中的字符为：a，
执行后s所指字符串为：baaaacdaa。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
void fun(char *s, char c)
{ int i, j, n;
/**********found**********/
for(i=0; s!=___1___ ; i++)
if(s==c)
{
/**********found**********/
n=___2___ ;
while(s[i+1+n]!='\0') n++;
for(j=i+n+1; j>i; j--) s[j+1]=s[j];
/**********found**********/
s[j+1]=___3___ ;
i=i+1;
}
}
main()
{ char s[80]="baacda", c;
printf("\nThe string: %s\n",s);
printf("\nInput a character: "); scanf("%c",&c);
fun(s,c);
printf("\nThe result is: %s\n",s);
}
在主函数中从键盘输入若干个数放入数组中, 用0结束输入并放在最后一个元素中。给定程序MODI1.C中函数fun的功能是:计算数组元素中值为正数的平均值(不包括0)。
例如：数组中元素中的值依次为：39,-47,21,2,-8,15,0，
则程序的运行结果为：19.250000。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
double fun ( int x[])
{
/************found************/
int sum = 0.0;
int c=0, i=0;
while (x != 0)
{ if (x > 0) {
sum += x; c++; }
i++;
}
/************found************/
sum \= c;
return sum;
}
main( )
{ int x[1000]; int i=0;
printf( "\nPlease enter some data (end with 0): " );
do
{ scanf("%d", &x); }
while (x[i++] != 0);
printf("%f\n", fun ( x ));
}
编写函数fun，函数的功能是：根据以下公式计算s，计算结果作为函数值返回；n通过形参传入。
1 1 1
S=1 + ── + ─── + ... + ──────
1+2 1+2+3 1+2+3+...+n
例如：若n的值为11时，函数的值为：1.833333
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
double fun(int n)
{
}
main()
{ int n; double s;
void NONO ( );
printf("\nPlease enter N:"); scanf("%d", &n);
s = fun(n);
printf("the result is: %f\n", s);
NONO();
}
填空题参考答案：
1) for(i=0; s!=0; i++)
2) n=0;
3) s[j+1]=c;
修改题参考答案：
1) double sum = 0.0;
2) sum /= c;
程序题参考答案：
float fun(int n)
{
int i;
float s=0,t=0;
for(i=1;i<=n;i++) {
t+=i;
s=s+1.0/t;
}
return s;
}
第28套
给定程序中，函数fun的功能是：有N×N矩阵，根据给定的m（m<=N）值，将每行元素中的值均右移m个位置，左边置为0。例如，N=3，m=2，有下列矩阵
1 2 3
4 5 6
7 8 9
程序执行结果为
0 0 1
0 0 4
0 0 7
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define N 4
void fun(int (*t)[N], int m)
{ int i, j;
/**********found**********/
for(i=0; i<N; ___1___ )
{ for(j=N-1-m; j>=0; j--)
/**********found**********/
t[j+___2___ ]=t[j];
/**********found**********/
for(j=0; j<___3___; j++)
t[j]=0;
}
}
main()
{ int t[][N]={21,12,13,24,25,16,47,38,29,11,32,54,42,21,33,10}, i, j, m;
printf("\nThe original array:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++)
printf("%2d ",t[j]);
printf("\n");
}
printf("Input m (m<=%d): ",N);scanf("%d",&m);
fun(t,m);
printf("\nThe result is:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++)
printf("%2d ",t[j]);
printf("\n");
}
}
给定程序MODI1.C中函数 fun 的功能是：计算并输出high以内最大的10个素数之和。high的值由主函数传给fun函数。
若high的值为: 100, 则函数的值为: 732。
请改正程序中的错误，使程序能输出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <math.h>
int fun( int high )
{ int sum = 0, n=0, j, yes;
/************found************/
while ((high >= 2) && (n < 10)
{ yes = 1;
for (j=2; j<=high/2; j++ )
if (high % j ==0 ){
/************found************/
yes=0; break
}
if (yes) { sum +=high; n++; }
high--;
}
return sum ;
}
main ( )
{
printf("%d\n", fun (100));
}
编写函数fun，它的功能是：利用以下所示的简单迭代方法求方程：cos(x)-x=0 的一个实根。
x(n+1)=cos(xn)
迭代步骤如下：
（1）取 x1 初值为0.0；
（2）x0 = x1，把x1的值赋给 x0；
（3）x1 = cos(x0)，求出一个新的x1；
（4）若x0 - x1的绝对值小于 0.000001，执行步骤（5），否则执
行步骤（2）；
（5）所求x1就是方程 cos(x)-x=0 的一个实根，作为函数值返回。
程序将输出结果Root=0.739086。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <math.h>
#include <stdio.h>
double fun()
{
}
main()
{
void NONO ( );
printf("Root =%f\n", fun());
NONO();
}
阅读题参考答案：4234
填空题参考答案：
1) for(i=0; i<N; i++)
2) t[j+m]=t[j];
3) for(j=0; j<m; j++)
修改题参考答案：
1) while((2<=high) && (n<10))
2) yes=0; break;
程序题参考答案：
float fun()
{
float x0, x1=0.0;
do {
x0=x1;
x1=cos(x0);
} while(fabs(x0-x1)>0.000001);
return x1;
}
第29套
给定程序中，函数fun的功能是：将N×N矩阵中元素的值按列右移1个位置，右边被移出矩阵的元素绕回左边。例如，N=3，有下列矩阵
1 2 3
4 5 6
7 8 9
计算结果为
3 1 2
6 4 5
9 7 8
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define N 4
void fun(int (*t)[N])
{ int i, j, x;
/**********found**********/
for(i=0; i<___1___; i++)
{
/**********found**********/
x=t[___2___] ;
for(j=N-1; j>=1; j--)
t[j]=t[j-1];
/**********found**********/
t[___3___]=x;
}
}
main()
{ int t[][N]={21,12,13,24,25,16,47,38,29,11,32,54,42,21,33,10}, i, j;
printf("The original array:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++) printf("%2d ",t[j]);
printf("\n");
}
fun(t);
printf("\nThe result is:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++) printf("%2d ",t[j]);
printf("\n");
}
}
给定程序modi1.c中函数fun的功能是：计算并输出下列级数的前N项之和Sn，直到Sn+1大于q为止，q的值通过形参传入。
Sn=2/1+3/2+4/3+...+(n+1)/n
例如，若q的值为: 50.0，则函数值为: 49.394948。
请改正程序中的错误，使程序能输出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
double fun( double q )
{ int n; double s,t;
n = 2;
s = 2.0;
while (s<=q)
{
t=s;
/************found************/
s=s+(n+1)/n;
n++;
}
printf("n=%d\n",n);
/************found************/
return s;
}
main ( )
{
printf("%f\n", fun(50));
}
编写函数fun，它的功能是：求Fibonacci数列中大于t的最小的一个数，结果由函数返回。其中Fibonacci数列F(n)的定义为：
F(0)＝0，F(1)＝1
F(n)＝F(n－1)＋F(n－2)
例如：当t = 1000时，函数值为：1597。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <math.h>
#include <stdio.h>
int fun( int t)
{
}
main() /* 主函数 */
{ int n;
void NONO ( );
n=1000;
printf("n = %d, f = %d\n",n, fun(n));
NONO();
}
填空题参考答案：
1) for(i=0; i<N; i++)
2) x=t[N-1] ;
3) t[0]=x;
修改题参考答案：
1) s=s+(n+1.)/n;
2) return t;
程序题参考答案：
int fun( int t)
{
int i,a[1000]={0,1};
for(i=2 ; ; i++)
{ a=a[i-1]+a[i-2];
if(a>t)
return a;
}
}
第30套
给定程序中,函数fun的功能是:有N×N矩阵,将矩阵的外围元素顺时针旋转。操作顺序是：首先将第一行元素的值存入临时数组r，然后使第一列成为第一行，最后一行成为第一列,最后一列成为最后一行,临时数组中的元素成为最后一列。例如，若N=3，有下列矩阵：
1 2 3
4 5 6
7 8 9
计算结果为
7 4 1
8 5 2
9 6 3
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define N 4
void fun(int (*t)[N])
{ int j ,r[N];
for(j=0; j<N; j++) r[j]=t[0][j];
for(j=0; j<N; j++)
/**********found**********/
t[0][N-j-1]=t[j][___1___ ];
for(j=0; j<N; j++)
t[j][0]=t[N-1][j];
/**********found**********/
for(j=N-1; j>=0;___2___ )
t[N-1][N-1-j]=t[j][N-1];
for(j=N-1; j>=0; j--)
/**********found**********/
t[j][N-1]=r[___3___];
}
main()
{ int t[][N]={21,12,13,24,25,16,47,38,29,11,32,54,42,21,33,10}, i, j;
printf("\nThe original array:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++) printf("%2d ",t[j]);
printf("\n");
}
fun(t);
printf("\nThe result is:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++) printf("%2d ",t[j]);
printf("\n");
}
}
给定程序MODI1.C中函数 fun 的功能是：计算
S = f(-n) + f(-n+1) +…+ f(0) + f(1) + f(2) +…+ f(n)的值。例如，当n为5时，函数值应为：10.407143。f(x)函数定义如下：
┌(x+1)/(x-2) x>0 且 x≠2
f(x) = ┤0 x=0 或 x=2
└(x-1)/(x-2) x<0
请改正程序中的错误，使程序能输出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <math.h>
/************found************/
f( double x)
{
if (x == 0.0 || x == 2.0)
return 0.0;
else if (x < 0.0)
return (x -1)/(x-2);
else
return (x +1)/(x-2);
}
double fun( int n )
{ int i; double s=0.0, y;
for (i= -n; i<=n; i++)
{y=f(1.0*i); s += y;}
/************found************/
return s
}
main ( )
{
printf("%f\n", fun(5) );
}
编写函数fun，它的功能是计算：
s=sqrt(ln(1)+ln(2)+...+ln(m))
s作为函数值返回。
在C语言中可调用log ( n )函数求ln (n)。log函数的引用说明是:
double log(double x)。
例如，若m的值为: 20，fun函数值为: 6.506583。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <math.h>
#include <stdio.h>
double fun( int m )
{
}
main()
{
void NONO ( );
printf("%f\n", fun(20));
NONO();
}
填空题参考答案：
1) t[0][N-j-1]=t[j][0];
2) for(j=N-1; j>=0;j--)
3) t[j][N-1]=r[j];
修改题参考答案：
1) double f( double x)
2) return s;
程序题参考答案：
double fun( int m )
{
double s = 0.0 ;
int i ;
for(i = 1 ; i <= m ; i++) s += log(i) ;
s = sqrt(s) ;
return s ;
}
第31套
给定程序中，函数fun的功能是:有N×N矩阵，以主对角线为对称线，对称元素相加并将结果存放在左下三角元素中，右上三角元素置为0。例如，若N=3，有下列矩阵：
1 2 3
4 5 6
7 8 9
计算结果为
1 0 0
6 5 0
10 14 9
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define N 4
/**********found**********/
void fun(int (*t)___1___ )
{ int i, j;
for(i=1; i<N; i++)
{ for(j=0; j<i; j++)
{
/**********found**********/
___2___ =t[j]+t[j];
/**********found**********/
___3___ =0;
}
}
}
main()
{ int t[][N]={21,12,13,24,25,16,47,38,29,11,32,54,42,21,33,10}, i, j;
printf("\nThe original array:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++) printf("%2d ",t[j]);
printf("\n");
}
fun(t);
printf("\nThe result is:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++) printf("%2d ",t[j]);
printf("\n");
}
}
给定程序MODI1.C中函数fun的功能是：计算函数
F(x,y,z)=(x+y)/(x-y)+(z+y)/(z-y)的值。其中x和y的值不等，z和y的值不等。
例如，当x的值为9、y的值为11、z的值为15时，函数值为 -3.50。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
/************found************/
#define FU(m,n) (m/n)
float fun(float a,float b,float c)
{ float value;
value=FU(a+b,a-b)+FU(c+b,c-b);
/************found************/
Return(Value);
}
main()
{ float x,y,z,sum;
printf("Input x y z: ");
scanf("%f%f%f",&x,&y,&z);
printf("x=%f,y=%f,z=%f\n",x,y,z);
if (x==y||y==z){printf("Data error!\n");exit(0);}
sum=fun(x,y,z);
printf("The result is : %5.2f\n",sum);
}
规定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是：将字符串中的前导*号全部删除，中间和尾部的*号不删除。
例如，字符串中的内容为：*******A*BC*DEF*G****，删除后,字符串中的内容应当是：A*BC*DEF*G****。在编写函数时，不得使用C语言提供的字符串函数。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun( char *a )
{
}
main()
{ char s[81];
void NONO ( );
printf("Enter a string:\n");gets(s);
fun( s );
printf("The string after deleted:\n");puts(s);
NONO();
}
阅读题参考答案：4212
填空题参考答案：
1) void fun(int (*t)[N])
2) t[j] =t[j]+t[j];
3) t[j]=0;
修改题参考答案：
1) #define FU(m,n) ((m)/(n))
2) return (value);
程序题参考答案：
void fun( char *a )
{
int i,j=0;
for(i=0 ; a=='*' ; i++)
;
for( ; a ; i++)
a[j++]=a;
a[j]=0;
}
第32套
给定程序中，函数fun的功能是:将N×N矩阵主对角线元素中的值与反向对角线对应位置上元素中的值进行交换。例如，若N=3，有下列矩阵：
1 2 3
4 5 6
7 8 9
交换后为：
3 2 1
4 5 6
9 8 7
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define N 4
/**********found**********/
void fun(int ___1___ , int n)
{ int i,s;
/**********found**********/
for(___2___; i++)
{ s=t;
t=t[n-i-1];
/**********found**********/
t[n-1-i]=___3___;
}
}
main()
{ int t[][N]={21,12,13,24,25,16,47,38,29,11,32,54,42,21,33,10}, i, j;
printf("\nThe original array:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++) printf("%d ",t[j]);
printf("\n");
}
fun(t,N);
printf("\nThe result is:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++) printf("%d ",t[j]);
printf("\n");
}
}
由N个有序整数组成的数列已放在一维数组中，给定程序MODI1.C中函数fun的功能是：利用折半查找算法查找整数m在数组中的位置。若找到，返回其下标值；反之，返回-1。
折半查找的基本算法是:每次查找前先确定数组中待查的范围:low和high（low<high）,然后把m与中间位置（mid）中元素的值进行比较。如果m的值大于中间位置元素中的值， 则下一次的查找范围落在中间位置之后的元素中；反之，下一次的查找范围落在中间位置之前的元素中。直到low>high，查找结束。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
#define N 10
/************found************/
void fun(int a[], int m )
{ int low=0,high=N-1,mid;
while(low<=high)
{ mid=(low+high)/2;
if(m<a[mid])
high=mid-1;
/************found************/
else If(m > a[mid])
low=mid+1;
else return(mid);
}
return(-1);
}
main()
{ int i,a[N]={-3,4,7,9,13,45,67,89,100,180 },k,m;
printf("a数组中的数据如下:");
for(i=0;i<N;i++) printf("%d ", a);
printf("Enter m: "); scanf("%d",&m);
k=fun(a,m);
if(k>=0) printf("m=%d,index=%d\n",m,k);
else printf("Not be found!\n");
}
假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是：除了尾部的*号之外,将字符串中其它*号全部删除。形参p已指向字符串中最后的一个字母。在编写函数时，不得使用C语言提供的字符串函数。
例如，字符串中的内容为：****A*BC*DEF*G*******，删除后,字符串中的内容应当是： ABCDEFG*******。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun( char *a, char *p )
{
}
main()
{ char s[81],*t;
void NONO ( );
printf("Enter a string:\n");gets(s);
t=s;
while(*t)t++;
t--;
while(*t=='*')t--;
fun( s , t );
printf("The string after deleted:\n");puts(s);
NONO();
}
阅读题参考答案：3434
填空题参考答案：
1) void fun(int t[][N] , int n)
2) for(i=0;i<n; i++)
3) t[n-1-i]=s;
修改题参考答案：
1) fun(int a[],int m)
2) else if(m>a[mid])
程序题参考答案：
void fun( char *a, char *p )
{
char *q;
int j=0;
for(q=a ; q<=p ; q++)
if(*q!='*')
a[j++]=*q;
for(q=p+1 ; *q ; q++)
a[j++]=*q;
a[j]=0;
}
第33套
给定程序中，函数fun的功能是:计算N×N矩阵的主对角线元素和反向对角线元素之和，并作为函数值返回。注意：要求先累加主对角线元素中的值，然后累加反向对角线元素中的值。例如，若N=3，有下列矩阵：
1 2 3
4 5 6
7 8 9
fun函数首先累加1、5、9，然后累加3、5、7，函数的返回值为30。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define N 4
fun(int t[][N], int n)
{ int i, sum;
/**********found**********/
___1___;
for(i=0; i<n; i++)
/**********found**********/
sum+=___2___ ;
for(i=0; i<n; i++)
/**********found**********/
sum+= t[n-i-___3___] ;
return sum;
}
main()
{ int t[][N]={21,2,13,24,25,16,47,38,29,11,32,54,42,21,3,10},i,j;
printf("\nThe original data:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++) printf("%4d",t[j]);
printf("\n");
}
printf("The result is: %d",fun(t,N));
}
给定程序modi1.c中函数fun和funx的功能是：用二分法求方程
2x^3-4x^2+3x-6=0的一个根，并要求绝对误差不超过0.001。
例如，若给m输入 -100，给n输入90，则函数求得的一个根值为2.000。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
#include <math.h>
double funx(double x)
{ return(2*x*x*x-4*x*x+3*x-6); }
double fun( double m, double n)
{
/************found************/
int r;
r=(m+n)/2;
/************found************/
while(fabs(n-m)<0.001)
{ if(funx(r)*funx(n)<0) m=r;
else n=r;
r=(m+n)/2;
}
return r;
}
main( )
{ double m,n, root;
printf("Enter m n : \n"); scanf("%lf%lf",&m,&n);
root=fun( m,n );
printf("root = %6.3f\n",root);
}
假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是: 除了字符串前导和尾部的*号之外,将串中其它*号全部删除。形参h已指向字符串中第一个字母，形参p已指向字符串中最后一个字母。在编写函数时，不得使用C语言提供的字符串函数。
例如，字符串中的内容为：****A*BC*DEF*G********，删除后,字符串中的内容应当是：****ABCDEFG********。在编写函数时，不得使用C语言提供的字符串函数。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun( char *a, char *h,char *p )
{
}
main()
{ char s[81],*t, *f;
void NONO ( );
printf("Enter a string:\n");gets(s);
t=f=s;
while(*t)t++;
t--;
while(*t=='*')t--;
while(*f=='*')f++;
fun( s , f,t );
printf("The string after deleted:\n");puts(s);
NONO();
}
阅读题参考答案：1341
填空题参考答案：
1) sum=0;
2) sum+=t ;
3) sum+= t[n-i-1] ;
修改题参考答案：
1) double r;
2) while(fabs(n-m)>0.001)
程序题参考答案：
void fun( char *a, char *h,char *p )
{
int j=0;
char *q;
for(q=a ; q<h ; q++)
a[j++]=*q;
for(q=h ; q<=p; q++)
if(*q!='*')
a[j++]=*q;
for(q=p+1 ; *q ; q++)
a[j++]=*q;
a[j]=0;
}
第34套
函数fun的功能是：把形参a所指数组中的奇数按原顺序依次存放到a[0]、a[1]、a[2]、……中，把偶数从数组中删除，奇数个数通过函数值返回。例如：若a所指数组中的数据最初排列为：9、1、4、2、3、6、5、8、7，删除偶数后a所指数组中的数据为：9、1、3、5、7，返回值为5。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define N 9
int fun(int a[], int n)
{ int i,j;
j = 0;
for (i=0; i<n; i++)
/**********found**********/
if (a%2==___1___)
{
/**********found**********/
a[j] = a; ___2___;
}
/**********found**********/
return ___3___;
}
main()
{ int b[N]={9,1,4,2,3,6,5,8,7}, i, n;
printf("\nThe original data :\n");
for (i=0; i<N; i++) printf("%4d ", b);
printf("\n");
n = fun(b, N);
printf("\nThe number of odd : %d \n", n);
printf("\nThe odd number :\n");
for (i=0; i<n; i++) printf("%4d ", b);
printf("\n");
}
给定程序MODI1.C中函数fun的功能是：求出两个非零正整数的最大公约数，并作为函数值返回。
例如，若给num1和num2分别输入49和21，则输出的最大公约数为7；若给num1和num2分别输入27和81，则输出的最大公约数为27。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
int fun(int a,int b)
{ int r,t;
if(a<b) {
/************found************/
t=a; b=a; a=t;
}
r=a%b;
while(r!=0)
{ a=b; b=r; r=a%b; }
/************found************/
return(a);
}
main()
{ int num1, num2,a;
printf("Input num1 num2: "); scanf("%d%d",&num1,&num2);
printf("num1= %d num2= %d\n\n",num1,num2);
a=fun(num1,num2);
printf("The maximun common divisor is %d\n\n",a);
}
假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是：删除字符串中所有的*号。在编写函数时，不得使用C语言提供的字符串函数。
例如，字符串中的内容为：****A*BC*DEF*G*******，删除后,字符串中的内容应当是：ABCDEFG。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun( char *a )
{
}
main()
{ char s[81];
void NONO ( );
printf("Enter a string:\n");gets(s);
fun( s );
printf("The string after deleted:\n");puts(s);
NONO();
}
填空题参考答案：
1) if (a%2==1)
2) a[j] = a; j++;
3) return j;
修改题参考答案：
1) t=a;a=b;b=t;
2) return(b);
程序题参考答案：
void fun( char *a )
{
int i,j =0 ;
for(i=0 ; a ; i++)
if(a!='*')
a[j++]=a;
a[j]=0;
}
第35套
函数fun的功能是：把形参a所指数组中的偶数按原顺序依次存放到a[0]、a[1]、a[2]、……中，把奇数从数组中删除，偶数个数通过函数值返回。例如：若a所指数组中的数据最初排列为：9、1、4、2、3、6、5、8、7，删除奇数后a所指数组中的数据为：4、2、6、8，返回值为4。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define N 9
int fun(int a[], int n)
{ int i,j;
j = 0;
for (i=0; i<n; i++)
/**********found**********/
if (___1___== 0) {
/**********found**********/
___2___ = a; j++;
}
/**********found**********/
return ___3___;
}
main()
{ int b[N]={9,1,4,2,3,6,5,8,7}, i, n;
printf("\nThe original data :\n");
for (i=0; i<N; i++) printf("%4d ", b);
printf("\n");
n = fun(b, N);
printf("\nThe number of even ：%d\n", n);
printf("\nThe even :\n");
for (i=0; i<n; i++) printf("%4d ", b);
printf("\n");
}
给定程序MODI1.C中函数fun的功能是：按以下递归公式求函数值。
┌ 10 (n=1)
fun(n)=┥
└ fun(n-1)+2 (n>1)
例如，当给n输入5时，函数值为18；当给n输入3时，函数值为14。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
/************found************/
fun ( n )
{ int c;
/************found************/
if(n=1)
c = 10 ;
else
c= fun(n-1)+2;
return(c);
}
main()
{ int n;
printf("Enter n : "); scanf("%d",&n);
printf("The result : %d\n\n", fun(n));
}
假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是：使字符串中尾部的*号不得多于n个;若多于n个，则删除多余的*号;若少于或等于n个，则什么也不做, 字符串中间和前面的*号不删除。
例如，字符串中的内容为：****A*BC*DEF*G*******，若n的值为4，删除后，字符串中的内容应当是：****A*BC*DEF*G****；若n的值为7,则字符串中的内容仍为：****A*BC*DEF*G*******。n的值在主函数中输入。在编写函数时，不得使用C语言提供的字符串函数。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun( char *a,int n )
{
}
main()
{ char s[81]; int n;
void NONO ( );
printf("Enter a string:\n");gets(s);
printf("Enter n : ");scanf("%d",&n);
fun( s,n );
printf("The string after deleted:\n");puts(s);
NONO();
}
填空题参考答案：
1) if (a%2== 0) {
2) a[j] = a; j++;
3) return j;
修改题参考答案：
1) fun (int n)
2) if(n==1)
程序题参考答案：
void fun( char *a,int n )
{
int i,cnt=0;
for(i=0 ; a ; i++)
;
for(i-- ; a=='*' ; i--)
cnt++;
if(cnt>n)
a[i+n+1]=0;
}
第36套
函数fun的功能是：把形参a所指数组中的最小值放在元素a[0]中，接着把形参a所指数组中的最大值放在a[1]元素中；再把a所指数组元素中的次小值放在a[2]中，把a所指数组元素中的次大值放在a[3]；其余以此类推。例如：若a所指数组中的数据最初排列为：9、1、4、2、3、6、5、8、7；则按规则移动后，数据排列为：1、9、2、8、3、7、4、6、5。形参n中存放a所指数组中数据的个数。
注意：规定fun函数中的max存放当前所找的最大值，px存放当前所找最大值的下标。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
# include <stdio.h>
#define N 9
void fun(int a[], int n)
{ int i,j, max, min, px, pn, t;
for (i=0; i<n-1; i+=2)
{
/**********found**********/
max = min = ___1___;
px = pn = i;
for (j=i+1; j<n; j++) {
/**********found**********/
if (max<___2___)
{ max = a[j]; px = j; }
/**********found**********/
if (min>___3___)
{ min = a[j]; pn = j; }
}
if (pn != i)
{ t = a; a = min; a[pn] = t;
if (px == i) px =pn;
}
if (px != i+1)
{ t = a[i+1]; a[i+1] = max; a[px] = t; }
}
}
main()
{ int b[N]={9,1,4,2,3,6,5,8,7}, i;
printf("\nThe original data :\n");
for (i=0; i<N; i++) printf("%4d ", b);
printf("\n");
fun(b, N);
printf("\nThe data after moving :\n");
for (i=0; i<N; i++) printf("%4d ", b);
printf("\n");
}
给定程序MODI1.C中函数fun的功能是：用递归算法计算斐波拉契数列中第n项的值。从第1项起，斐波拉契数列为：1、1、2、3、5、8、13、21、……
例如，若给n输入7，该项的斐波拉契数值为：13。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
long fun(int g)
{
/**********found**********/
switch(g);
{ case 0: return 0;
/**********found**********/
case 1 ;case 2 : return 1 ;
}
return( fun(g-1)+fun(g-2) );
}
main()
{ long fib; int n;
printf("Input n: "); scanf("%d",&n); printf("n = %d\n",n);
fib=fun(n);
printf("fib = %d\n\n",fib);
}
某学生的记录由学号、8门课程成绩和平均分组成，学号和8门课程的成绩已在主函数中给出。请编写函数fun,它的功能是：求出该学生的平均分放在记录的ave成员中。
例如，学生的成绩是：85.5,76,69.5,85,91,72,64.5,87.5,他的平均分应当是：78.875。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun部位中填入你编写的若干语句。
#include <stdio.h>
#define N 8
typedef struct
{ char num[10];
double s[N];
double ave;
} STREC;
void fun(STREC *a)
{
}
main()
{ STREC s={"GA005",85.5,76,69.5,85,91,72,64.5,87.5};
int i;
void NONO ( );
fun( &s );
printf("The %s's student data:\n", s.num);
for(i=0;i<N; i++)
printf("%4.1f\n",s.s);
printf("\nave=%7.3f\n",s.ave);
NONO();
}
填空题参考答案：
1) max = min = a;
2) if (max<a[j])
3) if (min>a[j])
修改题参考答案：
1) switch(g)
2) case 1: return 1; case 2:return 1;
程序题参考答案：
void fun(STREC *a)
{
int i ;
double av=0;
for(i = 0 ; i < N ; i++)
av = av + a->s ;
av /= N ;
a->ave=av;
}
第37套
函数fun的功能是：把形参a所指数组中的最大值放在a[0]中，接着求出a所指数组中的最小值放在a[1]中；再把a所指数组元素中的次大值放在a[2]中，把a数组元素中的次小值放在a[3]中；其余以此类推。例如:若a所指数组中的数据最初排列为：1、4、2、3、9、6、5、8、7，则按规则移动后，数据排列为：9、1、8、2、7、3、6、4、5。形参n中存放a所指数组中数据的个数。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define N 9
/**********found**********/
void fun(int ___1___, int n)
{ int i, j, max, min, px, pn, t;
/**********found**********/
for (i=0; i<n-1; i+=___2___)
{ max = min = a;
px = pn = i;
/**********found**********/
for (j=___3___; j<n; j++)
{ if (max < a[j])
{ max = a[j]; px = j; }
if (min > a[j])
{ min = a[j]; pn = j; }
}
if (px != i)
{ t = a; a = max; a[px] = t;
if (pn == i) pn= px;
}
if (pn != i+1)
{ t = a[i+1]; a[i+1] = min; a[pn] = t; }
}
}
main()
{ int b[N]={1,4,2,3,9,6,5,8,7}, i;
printf("\nThe original data :\n");
for (i=0; i<N; i++) printf("%4d ", b);
printf("\n");
fun(b, N);
printf("\nThe data after moving :\n");
for (i=0; i<N; i++) printf("%4d ", b);
printf("\n");
}
给定程序MODI1.C中函数fun的功能是：按顺序给s所指数组中的元素赋予从2开始的偶数，然后再按顺序对每五个元素求一个平均值，并将这些值依次存放在w所指的数组中。若s所指数组中元素的个数不是5的倍数，多余部分忽略不计。
例如，s所指数组有14个元素，则只对前10个元素进行处理，不对最后的4个元素求平均值。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
#define SIZE 20
fun(double *s, double *w)
{ int k,i; double sum;
for(k=2,i=0;i<SIZE;i++)
{ s=k; k+=2; }
/**********found**********/
sun=0.0;
for(k=0,i=0;i<SIZE;i++)
{ sum+=s;
/**********found**********/
if(i+1%5==0)
{ w[k]=sum/5; sum=0; k++; }
}
return k;
}
main( )
{ double a[SIZE],b[SIZE/5];
int i, k;
k = fun(a,b);
printf("The original data:\n");
for(i=0; i<SIZE; i++)
{ if(i%5==0) printf("\n");
printf("%4.0f", a);
}
printf("\n\nThe result :\n");
for(i=0; i<k; i++) printf("%6.2f ",b);
printf("\n\n");
}
学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中,请编写函数fun，它的功能是：把低于平均分的学生数据放在b所指的数组中,低于平均分的学生人数通过形参n传回，平均分通过函数值返回。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#define N 8
typedef struct
{ char num[10];
double s;
} STREC;
double fun( STREC *a, STREC *b, int *n )
{
}
main()
{ STREC s[N]={{"GA05",85},{"GA03",76},{"GA02",69},{"GA04",85},
{"GA01",91},{"GA07",72},{"GA08",64},{"GA06",87}};
STREC h[N],t;FILE *out ;
int i,j,n; double ave;
ave=fun( s,h,&n );
printf("The %d student data which is lower than %7.3f:\n",n,ave);
for(i=0;i<n; i++)
printf("%s %4.1f\n",h.num,h.s);
printf("\n");
out = fopen("out.dat","w") ;
fprintf(out, "%d\n%7.3f\n", n, ave);
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(h.s>h[j].s) {t=h ;h=h[j]; h[j]=t;}
for(i=0;i<n; i++)
fprintf(out,"%4.1f\n",h.s);
fclose(out);
}
填空题参考答案：
1) void fun(int *a, int n)
2) for (i=0; i<n-1; i+=2)
3) for (j=i+1; j<n; j++)
修改题参考答案：
1) sum=0.0;
2) if((i+1)%5==0)
程序题参考答案：
double fun( STREC *a, STREC *b, int *n )
{
int i,j=0;
double ave = 0.0 ;
for(i = 0 ; i < N ; i++) ave = ave + a.s ;
ave /= N ; /* 计算平均值 */
for(i = 0 ; i < N ; i++)
if(a.s < ave)
b[j++]=a ;
*n=j;
return ave ; /* 返回平均值 */
}
第38套
函数fun的功能是：将形参a所指数组中的前半部分元素中的值和后半部分元素中的值对换。形参n中存放数组中数据的个数，若n为奇数，则中间的元素不动。
例如：若a所指数组中的数据依次为：1、2、3、4、5、6、7、8、9，则调换后为：6、7、8、9、5、1、2、3、4。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define N 9
void fun(int a[], int n)
{ int i, t, p;
/**********found**********/
p = (n%2==0)?n/2:n/2+___1___;
for (i=0; i<n/2; i++)
{
t=a;
/**********found**********/
a = a[p+___2___];
/**********found**********/
___3___ = t;
}
}
main()
{ int b[N]={1,2,3,4,5,6,7,8,9}, i;
printf("\nThe original data :\n");
for (i=0; i<N; i++) printf("%4d ", b);
printf("\n");
fun(b, N);
printf("\nThe data after moving :\n");
for (i=0; i<N; i++) printf("%4d ", b);
printf("\n");
}
给定程序MODI1.C中函数fun的功能是：把主函数中输入的3个数，最大的放在a中，最小的放在c中，中间的放在b中。
例如，输入的数为：55 12 34，
输出结果应当是：a=55.0 , b=34.0 , c=12.0。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
void fun(float *a,float *b,float *c)
{
/**********found**********/
float *k;
if( *a<*b )
{ k=*a; *a=*b; *b=k; }
/**********found**********/
if( *a>*c )
{ k=*c; *c=*a; *a=k; }
if( *b<*c )
{ k=*b; *b=*c; *c=k; }
}
main()
{ float a,b,c;
printf("Input a b c: "); scanf("%f%f%f",&a,&b,&c);
printf("a = %4.1f, b = %4.1f, c = %4.1f\n\n",a,b,c);
fun(&a,&b,&c);
printf("a = %4.1f, b = %4.1f, c = %4.1f\n\n",a,b,c);
}
学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中,请编写函数fun，它的功能是：把分数最高的学生数据放在b所指的数组中,注意：分数最高的学生可能不止一个，函数返回分数最高的学生的人数。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#define N 16
typedef struct
{ char num[10];
int s;
} STREC;
int fun( STREC *a, STREC *b )
{
}
main()
{ STREC s[N]={{"GA05",85},{"GA03",76},{"GA02",69},{"GA04",85},
{"GA01",91},{"GA07",72},{"GA08",64},{"GA06",87},
{"GA015",85},{"GA013",91},{"GA012",64},{"GA014",91},
{"GA011",77},{"GA017",64},{"GA018",64},{"GA016",72}};
STREC h[N];
int i,n;FILE *out ;
n=fun( s,h );
printf("The %d highest score :\n",n);
for(i=0;i<n; i++)
printf("%s %4d\n",h.num,h.s);
printf("\n");
out = fopen("out.dat","w") ;
fprintf(out, "%d\n",n);
for(i=0;i<n; i++)
fprintf(out, "%4d\n",h.s);
fclose(out);
}
填空题参考答案：
1) p = (n%2==0)?n/2:n/2+1;
2) a = a[p+i];
3) a[p+i] = t;
修改题参考答案：
1) float k;
2) if( *a<*c )
程序题参考答案：
int fun( STREC *a, STREC *b )
{
int i, max = a[0].s, n=0;
for(i = 1; i < N; i++)
if(max < a.s) max = a.s ; /* 找出最高成绩 */
for(i = 0; i < N; i++)
if(max==a.s) b[n++] = a ; /* 找相等的最高成绩并存入数组b中 */
return n; /* 返回符合条件的人数 */
}
第39套
函数fun的功能是：逆置数组元素中的值。例如：若a所指数组中的数据依次为：1、2、3、4、5、6、7、8、9，则逆置后依次为：9、8、7、6、5、4、3、2、1。形参n给出数组中数据的个数。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
void fun(int a[], int n)
{ int i,t;
/**********found**********/
for (i=0; i<___1___; i++)
{
t=a;
/**********found**********/
a = a[n-1-___2___];
/**********found**********/
___3___ = t;
}
}
main()
{ int b[9]={1,2,3,4,5,6,7,8,9}, i;
printf("\nThe original data :\n");
for (i=0; i<9; i++)
printf("%4d ", b);
printf("\n");
fun(b, 9);
printf("\nThe data after invert :\n");
for (i=0; i<9; i++)
printf("%4d ", b);
printf("\n");
}
给定程序MODI1.C中函数fun的功能是：将一个由八进制数字字符组成的字符串转换为与其面值相等的十进制整数。规定输入的字符串最多只能包含5位八进制数字字符。
例如，若输入：77777，则输出将是：32767。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
int fun( char *p )
{ int n;
/**********found**********/
n= *P-'o';
p++;
while( *p!=0 ) {
/**********found**********/
n=n*8+*P-'o';
p++;
}
return n;
}
main()
{ char s[6]; int i; int n;
printf("Enter a string (Ocatal digits): "); gets(s);
if(strlen(s)>5){ printf("Error: String too longer !\n\n");exit(0); }
for(i=0; s; i++)
if(s<'0'||s>'7')
{ printf("Error: %c not is ocatal digits!\n\n",s);exit(0); }
printf("The original string: "); puts(s);
n=fun(s);
printf("\n%s is convered to integer number: %d\n\n",s,n);
}
学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中,请编写函数fun,它的功能是：函数返回指定学号的学生数据,指定的学号在主函数中输入。若没找到指定学号,在结构体变量中给学号置空串，给成绩置-1，作为函数值返回。（用于字符串比较的函数是strcmp）。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
#define N 16
typedef struct
{ char num[10];
int s;
} STREC;
STREC fun( STREC *a, char *b )
{
}
main()
{ STREC s[N]={{"GA005",85},{"GA003",76},{"GA002",69},{"GA004",85},
{"GA001",91},{"GA007",72},{"GA008",64},{"GA006",87},
{"GA015",85},{"GA013",91},{"GA012",64},{"GA014",91},
{"GA011",77},{"GA017",64},{"GA018",64},{"GA016",72}};
STREC h;
char m[10];
int i;FILE *out ;
printf("The original data:\n");
for(i=0; i<N; i++)
{ if(i%4==0) printf("\n");
printf("%s %3d ",s.num,s.s);
}
printf("\n\nEnter the number: ");gets(m);
h=fun( s,m );
printf("The data : ");
printf("\n%s %4d\n",h.num,h.s);
printf("\n");
out = fopen("out.dat","w") ;
h=fun(s,"GA013");
fprintf(out,"%s %4d\n",h.num,h.s);
fclose(out);
}
填空题参考答案：
1) for (i=0; i<n/2; i++)
2) a = a[n-1-i];
3) a[n-i-1] = t;
修改题参考答案：
1) n= *p-'0';
2) n=n*8+*p-'0';
程序题参考答案：
STREC fun( STREC *a, char *b )
{
STREC c={"",-1} ;
int i ;
for(i = 0 ; i < N ; i++)
if(strcmp(a.num, b)==0) { /* 判断学号是否相等 */
c=a ;
break ; /* 退出循环体 */
}
return c ; /* 返回结构体变量 */
}
第40套
函数fun的功能是进行数字字符转换。若形参ch中是数字字符'0'～'9', 则'0'转换成'9','1'转换成'8'，'2'转换成'7'，……，'9'转换成'0'；若是其它字符则保持不变；并将转换后的结果作为函数值返回。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
/**********found**********/
___1___ fun(char ch)
{
/**********found**********/
if (ch>='0' && ___2___)
/**********found**********/
return '9'- (ch-___3___);
return ch ;
}
main()
{ char c1, c2;
printf("\nThe result :\n");
c1='2'; c2 = fun(c1);
printf("c1=%c c2=%c\n", c1, c2);
c1='8'; c2 = fun(c1);
printf("c1=%c c2=%c\n", c1, c2);
c1='a'; c2 = fun(c1);
printf("c1=%c c2=%c\n", c1, c2);
}
给定程序MODI1.C中函数fun的功能是：将p所指字符串中的所有字符复制到b中，要求每复制三个字符之后插入一个空格。
例如，在调用fun函数之前给a输入字符串：ABCDEFGHIJK，
调用函数之后，字符数组b中的内容则为：ABC DEF GHI JK。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
void fun(char *p, char *b)
{ int i, k=0;
while(*p)
{ i=1;
while( i<=3 && *p ) {
/**********found**********/
b[k]=p;
k++; p++; i++;
}
if(*p)
{
/**********found**********/
b[k++]=" ";
}
}
b[k]='\0';
}
main()
{ char a[80],b[80];
printf("Enter a string: "); gets(a);
printf("The original string: "); puts(a);
fun(a,b);
printf("\nThe string after insert space: "); puts(b); printf("\n\n");
}
N名学生的成绩已在主函数中放入一个带头节点的链表结构中,h指向链表的头节点。请编写函数fun，它的功能是：求出平均分，由函数值返回。
例如，若学生的成绩是：85，76，69，85，91，72，64，87, 则平均分应当是：78.625。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <stdlib.h>
#define N 8
struct slist
{ double s;
struct slist *next;
};
typedef struct slist STREC;
double fun( STREC *h )
{
}
STREC * creat( double *s)
{ STREC *h,*p,*q; int i=0;
h=p=(STREC*)malloc(sizeof(STREC));p->s=0;
while(i<N)
{ q=(STREC*)malloc(sizeof(STREC));
q->s=s; i++; p->next=q; p=q;
}
p->next=0;
return h;
}
outlist( STREC *h)
{ STREC *p;
p=h->next; printf("head");
do
{ printf("->%4.1f",p->s);p=p->next;}
while(p!=0);
printf("\n\n");
}
main()
{ double s[N]={85,76,69,85,91,72,64,87},ave;
void NONO ( );
STREC *h;
h=creat( s ); outlist(h);
ave=fun( h );
printf("ave= %6.3f\n",ave);
NONO();
}
填空题参考答案：
1) char fun(char ch)
2) if (ch>='0' && ch<='9')
3) return '9'- (ch-'0');
修改题参考答案：
1) b[k]=*p;
2) b[k++]=' ';
程序题参考答案：
double fun( STREC *h )
{
STREC *p=h->next; /* 由于头结点中没有存放数据 */
double av=0.0; /* 对计算成绩平均值的变量进行初始化 */
int n = 0 ;
while(p!=NULL) { /* 判断链表是否结束 */
av = av + p->s ; /* 对成绩进行累加 */
p=p->next; /* 到下一个结点位置 */
n++; /* 人数加1 */
}
av /= n ; /* 计算成绩平均值 */
return av ; /* 返回成绩平均值 */
}
第41套
函数fun的功能是进行字母转换。若形参ch中是小写英文字母,则转换成对应的大写英文字母；若ch中是大写英文字母，则转换成对应的小写英文字母；若是其它字符则保持不变；并将转换后的结果作为函数值返回。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <ctype.h>
char fun(char ch)
{
/**********found**********/
if ((ch>='a')___1___(ch<='z'))
return ch -'a' + 'A';
if ( isupper(ch) )
/**********found**********/
return ch +'a'-___2___ ;
/**********found**********/
return ___3___;
}
main()
{ char c1, c2;
printf("\nThe result :\n");
c1='w'; c2 = fun(c1);
printf("c1=%c c2=%c\n", c1, c2);
c1='W'; c2 = fun(c1);
printf("c1=%c c2=%c\n", c1, c2);
c1='8'; c2 = fun(c1);
printf("c1=%c c2=%c\n", c1, c2);
}
给定程序MODI1.C中函数fun的功能是: 给一维数组a输入任意4个整数, 并按下例的规律输出。例如输入1、2、3、4, 程序运行后将输出以下方阵。
4 1 2 3
3 4 1 2
2 3 4 1
1 2 3 4
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
#define M 4
/**************found**************/
void fun(int a)
{ int i,j,k,m;
printf("Enter 4 number : ");
for(i=0; i<M; i++) scanf("%d",&a);
printf("\n\nThe result :\n\n");
for(i=M;i>0;i--)
{ k=a[M-1];
for(j=M-1;j>0;j--)
/**************found**************/
aa[j]=a[j-1];
a[0]=k;
for(m=0; m<M; m++) printf("%d ",a[m]);
printf("\n");
}
}
main()
{ int a[M];
fun(a); printf("\n\n");
}
请编写一个函数fun, 它的功能是: 计算并输出给定整数n的所有因子(不包括1与n自身)之和。规定n的值不大于1000。
例如,在主函数中从键盘给n输入的值为856, 则输出为:sum=763。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其他函数中的任何内容,仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
int fun(int n)
{
}
main()
{ int n,sum;
printf("Input n: "); scanf("%d",&n);
sum=fun(n);
printf("sum=%d\n",sum);
NONO();
}
填空题参考答案：
1) if ((ch>='a')&&(ch<='z'))
2) return ch +'a'-'A' ;
3) return ch;
修改题参考答案：
1) void fun(int *a)
2) a[j]=a[j-1];
程序题参考答案：
int fun(int n)
{
int s = 0, i ;
for(i = 2 ; i < n ; i++) if(n % i == 0) s +=i ;
return s ;
}
第42套
函数fun的功能是：计算
f(x)=1+x-x^2/2!+x^3/3!-x^4/4!+...
的前n项之和。若x=2.5，n=15时，函数值为：1.917914。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <math.h>
double fun(double x, int n)
{ double f, t; int i;
/**********found**********/
f = ___1___;
t = -1;
for (i=1; i<n; i++)
{
/**********found**********/
t *= (___2___)*x/i;
/**********found**********/
f += ___3___;
}
return f;
}
main()
{ double x, y;
x=2.5;
y = fun(x, 15);
printf("\nThe result is :\n");
printf("x=%-12.6f y=%-12.6f\n", x, y);
}
给定程序MODI1.C中函数fun的功能是: 从3个红球,5个白球, 6个黑球中任意取出8个作为一组,进行输出。在每组中,可以没有黑球,但必须要有红球和白球。组合数作为函数值返回。正确的组合数应该是15。程序中i的值代表红球数, j的值代表白球数,k的值代表黑球数。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
int fun()
{ int i,j,k,sum=0;
printf("\nThe result :\n\n");
/**************found**************/
for(i=0; i<=3; i++)
{ for(j=1; j<=5; j++)
{ k=8-i-j;
/**************found**************/
if(K>=0 && K<=6)
{ sum=sum+1;
printf("red:%4d white:%4d black:%4d\n",i,j,k);
}
}
}
return sum;
}
main()
{ int sum;
sum=fun();
printf("sum =%4d\n\n",sum);
}
请编写函数fun, 其功能是: 计算并输出下列多项式的值:
Sn=1+1/1!+1/2!+1/3!+1/4!+...+1/n!
例如, 在主函数中从键盘给n输入15, 则输出为:s=2.718282。
注意: 要求n的值大于1但不大于100。
部分源程序在文件PROG1.C中。
请勿改动主函数main和其他函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
double fun(int n)
{
}
main()
{ int n; double s;
printf("Input n: "); scanf("%d",&n);
s=fun(n);
printf("s=%f\n",s);
NONO();
}
阅读题参考答案：2222
填空题参考答案：
1) f = 1;
2) t *= (-1)*x/n;
3) f += t;
修改题参考答案：
1) for(i=1; i<=3; i++)
2) if(k>=0 && k<=6)
程序题参考答案：
double fun(int n)
{
double s=1 ;
long t=1;
int i;
for(i=1; i<=n; i++) {
t=t*i; /* 计算阶乘 */
s+=1.0/t; /* 计算每项的值并累加至变量s中 */
}
return s; /* 返回多项式的值 */
}
第43套
函数fun的功能是：计算
f(x)=1+x-x^2/2!+x^3/3!-x^4/4!+...
直到|x^n/n!|<10^-6。若x=2.5，函数值为：1.917915。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <math.h>
double fun(double x)
{ double f, t; int n;
f = 1.0 + x;
/**********found**********/
t = ___1___;
n = 1;
do {
n++;
/**********found**********/
t *= (-1.0)*x/___2___;
f += t;
}
/**********found**********/
while (___3___ >= 1e-6);
return f;
}
main()
{ double x, y;
x=2.5;
y = fun(x);
printf("\nThe result is :\n");
printf("x=%-12.6f y=%-12.6f\n", x, y);
}
给定程序MODI1.C中函数fun的功能是: 求整数x的y次方的低3位值。例如,整数5的6次方为15625, 此值的低3位值为625。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
long fun(int x,int y,long *p )
{ int i;
long t=1;
/**************found**************/
for(i=1; i<y; i++)
t=t*x;
*p=t;
/**************found**************/
t=t/1000;
return t;
}
main()
{ long t,r; int x,y;
printf("\nInput x and y: "); scanf("%ld%ld",&x,&y);
t=fun(x,y,&r);
printf("\n\nx=%d, y=%d, r=%ld, last=%ld\n\n",x, y,r,t );
}
请编写函数fun，其功能是：计算并输出当x<0.97时下列多项式的值，直到|Sn-Sn-1|<0.000001为止。
Sn=1+0.5x+0.5(0.5-1)x^2/2!+0.5(0.5-1)(0.5-2)x^3/3!+....
例如, 在主函数中从键盘给x输入0.21后,输出为:s=1.100000。
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其他函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <math.h>
double fun(double x)
{
}
main()
{ double x,s;
printf("Input x: "); scanf("%lf",&x);
s=fun(x);
printf("s=%f\n",s);
NONO();
}
阅读题参考答案：2413
填空题参考答案：
1) t = x;
2) t *= (-1.0)*x/n;
3) while (fabs(t) >= 1e-6);
修改题参考答案：
1) for(i=1; i<=y; i++)
2) t=t%1000;
程序题参考答案：
double fun(double x)
{
int n=1; /* 循环计数*/
double sn=1; /* 累计数*/
double xn=1,xn1=0; /*x的n值,以及x的n-1值;*/
while(fabs(xn-xn1)>=0.000001)/*绝对值是否满足条件*/
{
xn=xn*x*(0.5-n+1)/n; /*表达式分解以后xn=(xn-1)*x*(0.5-n+1)/n*/
n+=1;
sn+=xn; /*sn累加上xn*/
}
return(sn);
}
第44套
函数fun的功能是：计算
f(x)=1+x+x^2/2!+...+x^n/n!
的前n项。若x=2.5，函数值为：12.182340。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
double fun(double x, int n)
{ double f, t; int i;
f = 1.0;
/**********found**********/
t = ___1___;
/**********found**********/
for (i=___2___; i<n; i++)
{
/**********found**********/
t *= x/___3___;
f += t;
}
return f;
}
main()
{ double x, y;
x=2.5;
y = fun(x, 12);
printf("\nThe result is :\n");
printf("x=%-12.6f y=%-12.6f\n", x, y);
}
给定程序MODI1.C中函数fun的功能是: 找出100至n(不大于1000)之间三位数字相等的所有整数, 把这些整数放在s所指数组中, 个数作为函数值返回。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
#define N 100
int fun(int *s, int n)
{ int i,j,k,a,b,c;
j=0;
for(i=100; i<n; i++) {
/**************found**************/
k=n;
a=k%10; k/=10;
b=k%10; k/=10;
/**************found**************/
c=k%10
if( a==b && a==c ) s[j++]=i;
}
return j;
}
main()
{ int a[N], n, num=0, i;
do
{ printf("\nEnter n( <=1000 ) : "); scanf("%d",&n); }
while(n > 1000);
num = fun( a,n );
printf("\n\nThe result :\n");
for(i=0; i<num; i++)printf("%5d",a);
printf("\n\n");
}
请编写函数fun, 其功能是: 计算并输出给定10个数的方差:
公式略
例如,给定的10个数为95.0、89.0、76.0、65.0、88.0、72.0、85.0、81.0、90.0、56.0，输出为s=11.730729。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其他函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <math.h>
double fun(double x[10])
{
}
main()
{ double s, x[10]={95.0,89.0,76.0,65.0,88.0,72.0,85.0,81.0,90.0,56.0};
int i;
printf("\nThe original data is :\n");
for(i=0;i<10;i++)printf("%6.1f",x); printf("\n\n");
s=fun(x);
printf("s=%f\n\n",s);
NONO();
}
填空题参考答案：
1) t = 1;
2) for (i=1; i<n; i++)
3) t *= x/i;
修改题参考答案：
1) k=i;
2) c=k%10;
程序题参考答案：
double fun(double x[10])
{
int i;
double avg=0.0, sum=0.0, abs=0.0, fc;
for (i=0;i<10;i++) sum+=x;
avg=sum/10; /* 计算平均值 */
for (i=0;i<10;i++)
abs+=(x-avg)*(x-avg);
fc=sqrt(abs/10) ;
return fc;
}
第45套
函数fun的功能是：计算
f(x)=1+x+x^2/2!+...+x^n/n!
直到|x^n/n!|<10^-6。若x=2.5，函数值为：12.182494
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <math.h>
double fun(double x)
{ double f, t; int n;
/**********found**********/
f = 1.0+___1___;
t = x;
n = 1;
do {
n++;
/**********found**********/
t *= x/___2___;
/**********found**********/
f += ___3___;
} while (fabs(t) >= 1e-6);
return f;
}
main()
{ double x, y;
x=2.5;
y = fun(x);
printf("\nThe result is :\n");
printf("x=%-12.6f y=%-12.6f \n", x, y);
}
给定程序MODI1.C中函数fun的功能是: 计算n的5次方的值(规定n的值大于2、小于8),通过形参指针传回主函数；并计算该值的个位、十位、百位上数字之和作为函数值返回。
例如,7的5次方是16807, 其低3位数的和值是15。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
#include <math.h>
int fun( int n ,int *value )
{ int d,s,i;
/**************found**************/
d=0; s=0;
for(i=1; i<=5; i++) d=d*n;
*value=d;
for(i=1; i<=3; i++)
{ s=s+d%10;
/**************found**************/
d=d\10;
}
return s;
}
main()
{ int n, sum, v;
do
{ printf("\nEnter n( 2<n<8): ");scanf("%d",&n); }
while(n<=2||n>=8);
sum=fun( n,&v );
printf("\n\nThe result:\n value=%d sum=%d\n\n",v,sum);
}
请编写函数fun, 其功能是: 计算并输出给定数组(长度为9)中每相邻两个元素之平均值的平方根之和。
例如, 给定数组中的9个元素依次为12.0、34.0、4.0、23.0、34.0、45.0、18.0、3.0、11.0, 输出应为: s=35.951014。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其他函数中的任何内容,仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <math.h>
double fun(double x[9])
{
}
main()
{ double s,a[9]={12.0,34.0,4.0,23.0,34.0,45.0,18.0,3.0,11.0};
int i;
printf("\nThe original data is :\n");
for(i=0;i<9;i++)printf("%6.1f",a); printf("\n\n");
s=fun(a);
printf("s=%f\n\n",s);
NONO();
}
填空题参考答案：
1) f = 1.0+x;
2) t *= x/n;
3) f += t;
修改题参考答案：
1) d=1; s=0;
2) d=d/10;
程序题参考答案：
double fun(double x[9])
{
int i ;
double avg=0.0,sum=0.0;
for (i=0;i<8;i++) {
avg=(x+x[i+1])/2;
sum+=sqrt(avg);
}
return sum;
}
第46套
函数fun的功能是：统计所有小于等于n(n>2)的素数的个数，素数的个数作为函数值返回。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
int fun(int n)
{ int i,j, count=0;
printf("\nThe prime number between 3 to %d\n", n);
for (i=3; i<=n; i++) {
/**********found**********/
for (___1___; j<i; j++)
/**********found**********/
if (___2___%j == 0)
break;
/**********found**********/
if (___3___>=i)
{ count++; printf( count%15? "%5d":"\n%5d",i); }
}
return count;
}
main()
{ int n=20, r;
r = fun(n);
printf("\nThe number of prime is : %d\n", r);
}
数列中,第一项值为3, 后一项都比前一项的值增5；给定程序MODI1.C中函数fun的功能是: 计算前n(4<n<50)项的累加和；每累加一次把被4除后余2的当前累加值放入数组中, 符合此条件的累加值的个数作为函数值返回主函数。
例如, 当n的值为20时,该数列为3,8,13,18,23,28,……,93,98。符合此条件的累加值应为42,126,366,570,1010。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
#define N 20
int fun(int n,int *a)
{ int i,j,k,sum;
/**************found**************/
sum=j==0;
for(k=3,i=0;i<n;i++,k+=5)
{ sum=sum+k;
/**************found**************/
if(sum%4=2)
a[j++]=sum;
}
return j;
}
main()
{ int a[N],d,n,i;
printf("\nEnter n (4<n<=50): ");scanf("%d",&n);
d=fun(n,a);
printf("\n\nThe result :\n");
for(i=0; i<d; i++)printf("%6d",a);printf("\n\n");
}
请编写函数fun, 其功能是: 计算并输出下列多项式的值:
Sn=1-1/2+1/3-1/4+...+1/2n-1-1/2n
例如, 在主函数中从键盘给n输入8后, 输出为: s=0.662872。
注意: 要求n的值大于1但不大于100。
部分源程序在文件PROG1.C中。
请勿改动主函数main和其他函数中的任何内容, 仅在函数fun的花括号中填入编写的若干语句。
#include <stdio.h>
double fun(int n)
{
}
main()
{ int n; double s;
printf("\nInput n: "); scanf("%d",&n);
s=fun(n);
printf("\ns=%f\n",s);
NONO();
}
阅读题参考答案：2314
填空题参考答案：
1) for (j=2; j<i; j++)
2) if (i%j == 0)
3) if (j>=i)
修改题参考答案：
1) sum=0;j=0;
2) if(sum%4==2)
程序题参考答案：
double fun(int n)
{
int i;
double sum=0.0;
if (n>1 && n<=100) {
for(i=1; i<=n; i++)
sum+=1.0/(2*i-1)-1.0/(2*i);
}
return sum;
}
第47套
函数fun的功能是：统计长整数n的各个位上出现数字1、2、3的次数,并通过外部(全局)变量c1，c2，c3返回主函数。例如：当n=123114350时，结果应该为:c1=3 c2=1 c3=2。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
int c1,c2,c3;
void fun(long n)
{ c1 = c2 = c3 = 0;
while (n) {
/**********found**********/
switch(___1___)
{
/**********found**********/
case 1: c1++;___2___;
/**********found**********/
case 2: c2++;___3___;
case 3: c3++;
}
n /= 10;
}
}
main()
{ long n=123114350L;
fun(n);
printf("\nThe result :\n");
printf("n=%ld c1=%d c2=%d c3=%d\n",n,c1,c2,c3);
}
给定程序MODI1.C中函数fun的功能是: 统计一个无符号整数中各位数字值为零的个数, 通过形参传回主函数；并把该整数中各位上最大的数字值作为函数值返回。例如, 若输入无符号整数30800, 则数字值为零的个数为3, 各位上数字值最大的是8。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
int fun(unsigned n, int *zero)
{ int count=0,max=0,t;
do
{ t=n%10;
/**************found**************/
if(t=0)
count++;
if(max<t) max=t;
n=n/10;
}while(n);
/**************found**************/
zero=count;
return max;
}
main()
{ unsigned n; int zero,max;
printf("\nInput n(unsigned): "); scanf("%d",&n);
max = fun( n,&zero );
printf("\nThe result: max=%d zero=%d\n",max,zero);
}
请编写函数fun, 其功能是: 计算并输出下列多项式的值:
1 1 1
S = 1 + ── + ─── + … + ─────
1*2 1*2*3 1*2*3*…50
例如, 在主函数中从键盘给n输入50后,输出为:s=1.718282。
注意: 要求n的值大于1但不大于100。
部分源程序在文件PROG1.C中。
请勿改动主函数main和其他函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
double fun(int n)
{
}
main()
{ int n; double s;
printf("\nInput n: "); scanf("%d",&n);
s=fun(n);
printf("\n\ns=%f\n\n",s);
NONO();
}
填空题参考答案：
1) switch(n%10)
2) case 1: c1++;break;
3) case 2: c2++;break;
修改题参考答案：
1) if(t==0)
2) *zero=count;
程序题参考答案：
double fun(int n)
{
double s=0, t=1;
int i ;
for(i=1; i<=n; i++) {
t *= i;
s += 1.0/t;
}
return s;
}
第48套
用筛选法可得到2～n（n<10000）之间的所有素数，方法是：首先从素数2开始，将所有2的倍数的数从数表中删去(把数表中相应位置的值置成0)；接着从数表中找下一个非0数，并从数表中删去该数的所有倍数；依此类推,直到所找的下一个数等于n为止。这样会得到一个序列：
2，3，5，7，11，13，17，19，23，……
函数fun用筛选法找出所有小于等于n的素数，并统计素数的个数作为函数值返回。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
int fun(int n)
{ int a[10000], i,j, count=0;
for (i=2; i<=n; i++) a = i;
i = 2;
while (i<n) {
/**********found**********/
for (j=a*2; j<=n; j+=___1___)
a[j] = 0;
i++;
/**********found**********/
while (___2___==0)
i++;
}
printf("\nThe prime number between 2 to %d\n", n);
for (i=2; i<=n; i++)
/**********found**********/
if (a!=___3___)
{ count++; printf( count%15?"%5d":"\n%5d",a); }
return count;
}
main()
{ int n=20, r;
r = fun(n);
printf("\nThe number of prime is : %d\n", r);
}
给定程序MODI1.C中函数fun的功能是: 为一个偶数寻找两个素数, 这两个素数之和等于该偶数，并将这两个素数通过形参指针传回主函数。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
#include <math.h>
void fun(int a,int *b,int *c)
{ int i,j,d,y;
for(i=3;i<=a/2;i=i+2) {
/**************found**************/
Y=1;
for(j=2;j<=sqrt((double)i);j++)
if(i%j==0) y=0;
if(y==1) {
/**************found**************/
d==a-i;
for(j=2;j<=sqrt((double)d);j++)
if(d%j==0) y=0;
if(y==1)
{ *b=i; *c=d; }
}
}
}
main()
{ int a,b,c;
do
{ printf("\nInput a: "); scanf("%d",&a); }
while(a%2);
fun(a,&b,&c);
printf("\n\n%d = %d + %d\n",a,b,c);
}
请编写函数fun, 它的功能是:计算并输出n(包括n)以内能被5或9整除的所有自然数的倒数之和。
例如,在主函数中从键盘给n输入20后, 输出为: s=0.583333。
注意: 要求n的值不大于100。
部分源程序在文件PROG1.C中。
请勿改动主函数main和其他函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
double fun(int n)
{
}
main()
{ int n; double s;
printf("\nInput n: "); scanf("%d",&n);
s=fun(n);
printf("\n\ns=%f\n",s);
NONO();
}
填空题参考答案：
1) for (j=a*2; j<=n; j+=a)
2) while (a==0)
3) if (a!=0)
修改题参考答案：
1) y=1;
2) d=a-i;
程序题参考答案：
double fun(int n)
{
int i;
double sum=0.0;
for(i=1; i<=n; i++)
if(i%5 == 0 || i%9 == 0) /* 被5或9整除 */
sum+=1.0/i;
return sum;
}
第49套
甲乙丙丁四人同时开始放鞭炮，甲每隔t1秒放一次，乙每隔t2秒放一次, 丙每隔t3秒放一次，丁每隔t4秒放一次，每人各放n次。函数fun的功能是根据形参提供的值，求出总共听到多少次鞭炮声作为函数值返回。注意，当几个鞭炮同时炸响，只算一次响声，第一次响声是在第0秒。
例如，若t1=7，t2=5，t3=6，t4=4，n=10，则总共可听到28次鞭炮声。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
/**********found**********/
#define OK(i, t, n) ((___1___%t==0) && (i/t<n))
int fun(int t1, int t2, int t3, int t4, int n)
{ int count, t , maxt=t1;
if (maxt < t2) maxt = t2;
if (maxt < t3) maxt = t3;
if (maxt < t4) maxt = t4;
count=1; /* 给count赋初值 */
/**********found**********/
for(t=1; t< maxt*(n-1); ___2___)
{
if(OK(t, t1, n) || OK(t, t2, n)|| OK(t, t3, n) || OK(t, t4, n) )
count++;
}
/**********found**********/
return ___3___;
}
main()
{ int t1=7, t2=5, t3=6, t4=4, n=10, r;
r = fun(t1, t2, t3, t4, n);
printf("The sound : %d\n", r);
}
给定程序MODI1.C中函数fun的功能是: 根据输入的三个边长(整型值), 判断能否构成三角形; 构成的是等边三角形, 还是等腰三角形。若能构成等边三角形函数返回3,若能构成等腰三角形函数返回2, 若能构成一般三角形函数返回1, 若不能构成三角形函数返回0。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
#include <math.h>
/**************found**************/
void fun(int a,int b,int c)
{ if(a+b>c && b+c>a && a+c>b) {
if(a==b && b==c)
return 3;
else if(a==b||b==c||a==c)
return 2;
/**************found**************/
else retrun 1
}
else return 0;
}
main()
{ int a,b,c,shape;
printf("\nInput a,b,c: "); scanf("%d%d%d",&a,&b,&c);
printf("\na=%d, b=%d, c=%d\n",a,b,c);
shape =fun(a,b,c);
printf("\n\nThe shape : %d\n",shape);
}
请编写函数fun, 其功能是: 计算并输出3到n之间(含3和n)所有素数的平方根之和。
例如, 在主函数中从键盘给n输入100后,输出为: sum=148.874270。
注意: 要求n的值大于2但不大于100。
部分源程序在文件PROG1.C中。
请勿改动主函数main和其他函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <math.h>
#include <stdio.h>
double fun(int n)
{
}
main()
{ int n; double sum;
printf("\n\nInput n: "); scanf("%d",&n);
sum=fun(n);
printf("\n\nsum=%f\n\n",sum);
NONO();
}
填空题参考答案：
1) #define OK(i, t, n) ((i%t==0) && (i/t<n))
2) for(t=1; t< maxt*(n-1); t++)
3) return count;
修改题参考答案：
1) int fun(int a,int b,int c)
2) else return 1;
程序题参考答案：
double fun(int n)
{
int i,j=0;
double s=0;
for (i=3; i<=n; i++) {
for (j=2; j<i; j++)
if (i%j == 0) break;
if (j == i) s=s+sqrt(i);
}
return s;
}
第50套
函数fun的功能是：从三个形参a，b，c中找出中间的那个数，作为函数值返回。
例如，当a=3, b=5, c=4时，中数为4。
请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
int fun(int a, int b, int c)
{
int t;
/**********found**********/
t = (a>b) ? (b>c? b 
a>c?c:___1___)) : ((a>c)?___2___ : ((b>c)?c:___3___));
return t;
}
main()
{ int a1=3, a2=5, a3=4, r;
r = fun(a1, a2, a3);
printf("\nThe middle number is : %d\n", r);
}
给定程序MODI1.C中函数fun的功能是: 首先将大写字母转换为对应小写字母;若小写字母为a～u,则将其转换为其后的第5个字母;若小写字母为v～z, 使其值减21。转换后的小写字母作为函数值返回。例如,若形参是字母A,则转换为小写字母f; 若形参是字母W,则转换为小写字母b。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
#include <ctype.h>
char fun(char c)
{ if( c>='A' && c<='Z')
/**************found**************/
C=C+32;
if(c>='a' && c<='u')
/**************found**************/
c=c-5;
else if(c>='v'&&c<='z')
c=c-21;
return c;
}
main()
{ char c1,c2;
printf("\nEnter a letter(A-Z): "); c1=getchar();
if( isupper( c1 ) )
{ c2=fun(c1);
printf("\n\nThe letter \'%c\' change to \'%c\'\n", c1,c2);
}
else printf("\nEnter (A-Z)!\n");
}
请编写函数fun, 其功能是: 计算并输出
s=1+(1+sqrt(2))+(1+sqrt(2)+sqrt(3)+....
例如, 在主函数中从键盘给n输入20后,输出为:s=534.188884。
注意: 要求n的值大于1但不大于100。
部分源程序在文件PROG1.C中。
请勿改动主函数main和其他函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <math.h>
#include <stdio.h>
double fun(int n)
{
}
main()
{ int n; double s;
printf("\n\nInput n: "); scanf("%d",&n);
s=fun(n);
printf("\n\ns=%f\n\n",s);
NONO();
}
阅读题参考答案：4122
填空题参考答案：
1) t = (a>b) ? (b>c? b a>c?c:a)) : ((a>c)?a : ((b>c)?c:b));
修改题参考答案：
1) c=c+32;
2) c=c+5;
程序题参考答案：
double fun(int n)
{
int i;
double fac=1.0;
double sum=1.0;
for(i=2;i<=n;i++) {
fac+=sqrt(i);
sum+=fac;
}
return sum;
}
第51套
给定程序中，函数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 <stdio.h>
int fun(int x)
{ int n, s1, s2, s3, t;
/**********found**********/
n=__1__;
t=100;
/**********found**********/
while(t<=__2__)
{ s1=t%10; s2=(t/10)%10; s3=t/100;
if(s1+s2+s3==15)
{ printf("%d ",t);
n++;
}
/**********found**********/
__3__;
}
return n;
}
main()
{ int x=-1;
while(x>999||x<0)
{ printf("Please input(0<x<=999): "); scanf("%d",&x); }
printf("\nThe result is: %d\n",fun(x));
}
给定程序MODI1.C中函数fun的功能是：先将s所指字符串中的字符按逆序存放到t所指字符串中，然后把s所指串中的字符按正序连接到t所指串的后面。
例如：当s所指的字符串为："ABCDE"时，
则t所指的字符串应为："EDCBAABCDE"。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
void fun (char *s, char *t)
{
/************found************/
int i;
sl = strlen(s);
for (i=0; i<sl; i++)
/************found************/
t = s[sl-i];
for (i=0; i<sl; i++)
t[sl+i] = s;
t[2*sl] = '\0';
}
main()
{ char s[100], t[100];
printf("\nPlease enter string s:"); scanf("%s", s);
fun(s, t);
printf("The result is: %s\n", t);
}
函数fun的功能是： 将a、b中的两个两位正整数合并形成一个新的整数放在c中。合并的方式是：将a中的十位和个位数依次放在变量c的百位和个位上，b中的十位和个位数依次放在变量c的千位和十位上。
例如，当a＝45，b=12。调用该函数后，c=1425。
注意: 部分源程序存在文件PROG1.C中。数据文件IN.DAT中的数据不得修改。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun(int a, int b, long *c)
{
}
main() /* 主函数 */
{ int a,b; long c;void NONO ();
printf("Input a, b:");
scanf("%d%d", &a, &b);
fun(a, b, &c);
printf("The result is: %ld\n", c);
NONO();
}
填空题参考答案：
1) n=0;
2) while(t<=x)
3) t++;
修改题参考答案：
1) int i,sl;
2) t = s[sl-i-1];
程序题参考答案：
void fun(int a, int b, long *c)
{
*c=(b/10)*1000+(a/10)*100+(b%10)*10+(a%10);
}
第52套
给定程序中，函数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 <stdio.h>
int fun(int x)
{ int n, s1, s2, s3, t;
n=0;
t=100;
/**********found**********/
while(t<=__1__){
/**********found**********/
s1=t%10; s2=(__2__)%10; s3=t/100;
/**********found**********/
if(s1+s2+s3==__3__)
{ printf("%d ",t);
n++;
}
t++;
}
return n;
}
main()
{ int x=-1;
while(x<0)
{ printf("Please input(x>0): "); scanf("%d",&x); }
printf("\nThe result is: %d\n",fun(x));
}
给定程序MODI1.C中函数fun的功能是：从低位开始取出长整型变量s中偶数位上的数，依次构成一个新数放在t中。高位仍在高位,低位仍在低位。
例如，当s中的数为：7654321时，t中的数为：642。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
/************found************/
void fun (long s, long t)
{ long sl=10;
s /= 10;
*t = s % 10;
/************found************/
while ( s < 0)
{ s = s/100;
*t = s%10*sl + *t;
sl = sl * 10;
}
}
main()
{ long s, t;
printf("\nPlease enter s:"); scanf("%ld", &s);
fun(s, &t);
printf("The result is: %ld\n", t);
}
学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中,请编写函数fun，它的功能是：按分数的高低排列学生的记录，高分在前。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#define N 16
typedef struct
{ char num[10];
int s;
} STREC;
void fun( STREC a[] )
{
}
main()
{ STREC s[N]={{"GA005",85},{"GA003",76},{"GA002",69},{"GA004",85},
{"GA001",91},{"GA007",72},{"GA008",64},{"GA006",87},
{"GA015",85},{"GA013",91},{"GA012",64},{"GA014",91},
{"GA011",66},{"GA017",64},{"GA018",64},{"GA016",72}};
int i;FILE *out ;
fun( s );
printf("The data after sorted :\n");
for(i=0;i<N; i++)
{ if( (i)%4==0 )printf("\n");
printf("%s %4d ",s.num,s.s);
}
printf("\n");
out = fopen("out.dat","w") ;
for(i=0;i<N; i++)
{ if( (i)%4==0 && i) fprintf(out, "\n");
fprintf(out, "%4d ",s.s);
}
fprintf(out,"\n");
fclose(out) ;
}
填空题参考答案：
1) while(t<=999){
2) s1=t%10; s2=(t/10)%10; s3=t/100;
3) if(s1+s2+s3==x)
修改题参考答案：
1) void fun (long s, long *t)
2) while ( s > 0)
程序题参考答案：
void fun( STREC a[] )
{
STREC tmp;
int i,j;
for(i = 0; i < N-1; i++)
for(j = i+1; j < N; j++)
if(a.s < a[j].s) {
tmp = a;
a = a[j];
a[j] = tmp;
}
}
第53套
给定程序中，函数fun的功能是：将形参n中，各位上为偶数的数取出，并按原来从高位到低位的顺序组成一个新的数，并作为函数值返回。
例如，从主函数输入一个整数：27638496，函数返回值为：26846。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
unsigned long fun(unsigned long n)
{ unsigned long x=0, s, i; int t;
s=n;
/**********found**********/
i=__1__;
/**********found**********/
while(__2__)
{ t=s%10;
if(t%2==0){
/**********found**********/
x=x+t*i; i=__3__;
}
s=s/10;
}
return x;
}
main()
{ unsigned long n=-1;
while(n>99999999||n<0)
{ printf("Please input(0<n<100000000): "); scanf("%ld",&n); }
printf("\nThe result is: %ld\n",fun(n));
}
给定程序MODI1.C中函数fun的功能是：输出M行M列整数方阵，然后求两条对角线上元素之和，返回此和数。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define M 5
/************found************/
int fun(int n, int xx[][])
{ int i, j, sum=0;
printf( "\nThe %d x %d matrix:\n", M, M );
for( i = 0; i < M; i++ )
{ for( j = 0; j < M; j++ )
/************found************/
printf( "%f ", xx[j] );
printf("\n");
}
for( i = 0 ; i < n ; i++ )
sum += xx+xx[ 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 ( "\nThe sum of all elements on 2 diagnals is %d.",fun( M, aa ));
}
函数fun的功能是：将a、b中的两个两位正整数合并形成一个新的整数放在c中。合并的方式是:将a中的十位和个位数依次放在变量c的千位和十位上，b中的十位和个位数依次放在变量c的个位和百位上。
例如，当a＝45，b=12。调用该函数后，c=4251。
注意: 部分源程序存在文件PROG1.C中。数据文件IN.DAT中的数据不得修改。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun(int a, int b, long *c)
{
}
main()
{ int a,b; long c;void NONO ();
printf("Input a, b:");
scanf("%d%d", &a, &b);
fun(a, b, &c);
printf("The result is: %ld\n", c);
NONO();
}
阅读题参考答案：4341
填空题参考答案：
1) i=1;
2) while(s)
3) x=x+t*i; i=i*10;
修改题参考答案：
1) int fun(int n,int xx[][M])
2) printf("%d",xx[j]);
程序题参考答案：
void fun(int a, int b, long *c)
{
*c=(a/10)*1000+(b%10)*100+(a%10)*10+(b/10);
}
第54套
给定程序中，函数fun的功能是：将形参n中，各位上为偶数的数取出，并按原来从高位到低位相反的顺序组成一个新的数，并作为函数值返回。
例如，输入一个整数：27638496，函数返回值为：64862。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
unsigned long fun(unsigned long n)
{ unsigned long x=0; int t;
while(n)
{ t=n%10;
/**********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("Please input(0<n<100000000): "); scanf("%ld",&n); }
printf("\nThe result is: %ld\n",fun(n));
}
给定程序MODI1.C中函数fun的功能是：将长整型数中每一位上为奇数的数依次取出，构成一个新数放在t中。高位仍在高位，低位仍在低位。
例如，当s中的数为：87653142时，t中的数为：7531。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
void fun (long s, long *t)
{ int d;
long sl=1;
/************found************/
t = 0;
while ( s > 0)
{ d = s%10;
/************found************/
if (d%2 == 0)
{ *t = d * sl + *t;
sl *= 10;
}
s /= 10;
}
}
main()
{ long s, t;
printf("\nPlease enter s:"); scanf("%ld", &s);
fun(s, &t);
printf("The result is: %ld\n", t);
}
编写一个函数fun,它的功能是:实现两个字符串的连接(不使用库函数strcat),即把p2所指的字符串连接到p1所指的字符串后。
例如，分别输入下面两个字符串：
FirstString--
SecondString
程序输出：
FirstString--SecondString
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun(char p1[], char p2[])
{
}
main()
{ char s1[80], s2[40] ;void NONO ();
printf("Enter s1 and s2:\n") ;
scanf("%s%s", s1, s2) ;
printf("s1=%s\n", s1) ;
printf("s2=%s\n", s2) ;
printf("Invoke fun(s1,s2):\n") ;
fun(s1, s2) ;
printf("After invoking:\n") ;
printf("%s\n", s1) ;
NONO() ;
}
填空题参考答案：
1) if(t%2==0)
2) x=10*x+t;
3) n=n/10;
修改题参考答案：
1) *t = 0;
2) if (d%2 != 0)
程序题参考答案：
void fun(char p1[], char p2[])
{
int i,j;
for(i=0 ; p1 ; i++)
;
for(j=0 ; p2[j] ; j++)
p1[i++]=p2[j];
p1=0;
}
第55套
给定程序中，函数fun的功能是：将形参n所指变量中，各位上为偶数的数去除,剩余的数按原来从高位到低位的顺序组成一个新的数，并通过形参指针n传回所指变量。
例如，输入一个数：27638496，新的数：为739。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
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("Please input(0<n<100000000): "); scanf("%ld",&n); }
fun(&n);
printf("\nThe result is: %ld\n",n);
}
给定程序MODI1.C中函数 fun 的功能是：计算n!。
例如，给n输入5，则输出120.000000。
请改正程序中的错误，使程序能输出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
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("Input N:") ;
scanf("%d", &n) ;
printf("\n\n%d! =%lf\n\n", n, fun(n)) ;
}
请编写一个函数fun，它的功能是：将一个数字字符串转换为一个整数(不得调用C语言提供的将字符串转换为整数的函数)。例如，若输入字符串"-1234",则函数把它转换为整数值 -1234。函数fun中给出的语句仅供参考。
注意: 部分源程序存在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容， 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
long fun ( char *p)
{
/* 以下代码仅供参考 */
int i, len, t; /* len为串长，t为正负标识 */
long x=0;
len=strlen(p);
if(p[0]=='-')
{ t=-1; len--; p++; }
else t=1;
/* 以下完成数字字符串转换为一个数字 */
return x*t;
}
main() /* 主函数 */
{ char s[6];void NONO ();
long n;
printf("Enter a string:\n") ;
gets(s);
n = fun(s);
printf("%ld\n",n);
NONO ( );
}
填空题参考答案：
1) { t=*n % 10;
2) if(t%2!= 0)
3) *n=x;
修改题参考答案：
1) if (n == 0)
2) result *= n--;
程序题参考答案：
long fun ( char *p)
{
/* 以下代码仅供参考 */
int i, len, t; /* len为串长，t为正负标识 */
long x=0;
len=strlen(p);
if(p[0]=='-')
{ t=-1; len--; p++; }
else t=1;
/* 以下完成数字字符串转换为一个数字 */
for(i=0 ; p ; i++)
x = x*10+p-'0';
return x*t;
}
第56套
给定程序中，函数fun的功能是：计算下式前n项的和作为函数值返回。
s=1*3/2^2+3*5/4^2+5*7/6^2+...
例如，当形参n的值为10时，函数返回：9.612558。
请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
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("Please input(n>0): "); scanf("%d",&n); }
printf("\nThe result is: %f\n",fun(n));
}
给定程序MODI1.C中函数 fun 的功能是：统计substr所指子字符串在str所指字符串中出现的次数。
例如，若字符串为aaas lkaaas，子字符串为as，则应输出2。
请改正程序中的错误，使它能计算出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
int fun (char *str,char *substr)
{ int i,j,k,num=0;
/************found************/
for(i = 0, str, 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("Input a string:") ;
gets(str);
printf("Input a substring:") ;
gets(substr);
printf("%d\n",fun(str,substr));
}
请编写一个函数fun，它的功能是：根据以下公式求π的值(要求满足精度0.0005, 即某项小于0.0005时停止迭代):
π 1 1×2 1×2×3 1×2×3×4 1×2×…×n
─ = 1+─+─-+────+──────+……+────────
2 3 3×5 3×5×7 3×5×7×9 3×5×…×(2n+1)
程序运行后，如果输入精度0.0005，则程序输出为3.14…。
注意: 部分源程序存在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <math.h>
double fun ( double eps)
{
}
main( )
{ double x;void NONO ();
printf("Input eps:") ;
scanf("%lf",&x); printf("\neps = %lf, PI=%lf\n", x, fun(x));
NONO();
}
填空题参考答案：
1) s=0;
2) for(i=1; i<=n; i++)
3) s=s+(2.0*i-1)*(2.0*i+1)/(t*t);
修改题参考答案：
1) for(i = 0; str; i++)
2) if(substr[k+1]=='\0')
程序题参考答案：
double fun ( double eps)
{
double s=1,t=1.0/3;
int n=1;
while(t>=eps){ s+=t; n++; t=t*n/(2.0*n+1); }
return (s*2.0);
}
第57套
给定程序中，函数fun的功能是：计算下式前n项的和作为函数值返回。
s=1*3/2^2-3*5/4^2+5*7/6^2+....
例如，当形参n的值为10时，函数返回：-0.204491。
请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
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)
{ printf("Please input(n>0): "); scanf("%d",&n); }
printf("\nThe result is: %f\n",fun(n));
}
给定程序MODI1.C中函数 fun 的功能是：判断一个整数是否是素数，若是返回1，否则返回0。
在main()函数中，若fun返回1输出YES，若fun返回0输出NO!。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数。不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
int fun ( int m )
{ int k = 2;
while ( k <= m && (m%k))
/************found************/
k++
/************found************/
if (m = k )
return 1;
else return 0;
}
main( )
{ int n;
printf( "\nPlease enter n: " ); scanf( "%d", &n );
if ( fun ( n ) ) printf( "YES\n" );
else printf( "NO!\n" );
}
请编写一个函数fun，它的功能是：找出一维整型数组元素中最大的值和它所在的下标， 最大的值和它所在的下标通过形参传回。数组元素中的值已在主函数中赋予。
主函数中x是数组名， n是x中的数据个数，max存放最大值,index存放最大值所在元素的下标。
注意: 部分源程序存在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdlib.h>
#include <stdio.h>
void fun(int a[], int n , int *max, int *d )
{
}
main()
{ int i, x[20], max , index, n = 10;void NONO ();
for (i=0;i < n;i++) {x = rand()%50; printf("%4d", x) ; }
printf("\n");
fun( x, n , &max, &index);
printf("Max =%5d , Index =%4d\n",max, index );
NONO();
}
填空题参考答案：
1) k=1;
2) t=2*i;
3) k=k*(-1);
修改题参考答案：
1) k++;
2) if (m == k )
程序题参考答案：
void fun(int a[], int n , int *max, int *d )
{
int i,ma=0 ;
for(i = 1; i < n; i++)
if(a[ma] < a)
ma = i;
*d=ma ;
*max=a[ma];
}
第58套
给定程序中，函数fun的功能是计算下式
s=3/2^2-5/4^2+7/6^2+...
直到|(2*n+1)/(2*n)^2|<=10^-3。
例如：若形参e的值为1e-3，函数的返回值为0.551690。
请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
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("\nThe result is: %f\n",fun(e));
}
给定程序MODI1.C中函数 fun 的功能是：求出以下分数序列的前n项之和。和值通过函数值返回到main函数。
2 3 5 8 13 21
┄┄ , ┄┄ , ┄┄ , ┄┄ , ┄┄ , ┄┄ , ……
1 2 3 5 8 13
例如，若n = 5，则应输出：8.391667。
请改正程序中的错误，使它能计算出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
/************found************/
void 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( "\nThe value of function is: %lf\n", fun ( n ) );
}
请编写一个函数fun，它的功能是：求出一个2×M整型二维数组中最大元素的值,并将此值返回调用函数。
注意: 部分源程序存在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#define M 4
int fun (int a[][M])
{
}
main( )
{ int arr[2][M]={5,8,3,45,76,-4,12,82} ;void NONO ();
printf("max =%d\n", fun(arr)) ;
NONO( ) ;
}
填空题参考答案：
1) x=3./4;
2) while(x > e)
3) x=(2*i+1)/(t*t);
修改题参考答案：
1) double fun ( int n )
2) s = s + (double)a / b;
程序题参考答案：
int fun (int a[][M])
{
int i, j, max=a[0][0];
for(i=0; i<2; i++)
for(j=0; j<M; j++)
if(max<a[j]) max=a[j];
return max;
}
第59套
给定程序中，函数fun的功能是计算下式
s=1/2^2+3/4^2+5/6^2+...
直到|(2n-1)/(2n)^2|<=10^-3，并把计算的结果作为函数值返回。
例如，若形参e的值为1e-3，函数的返回值2.985678。
请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
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("\nThe result is: %f\n",fun(e));
}
给定程序MODI1.C中函数 fun 的功能是：将s所指字符串的正序和反序进行连接，形成一个新串放在t所指的数组中。
例如，当s所指字符串为："ABCD" 时，则t所指字符串中的内容应为："ABCDDCBA"。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
/************found************/
void fun (char s, char t)
{
int i, d;
d = strlen(s);
for (i = 0; i<d; i++) t = s;
for (i = 0; i<d; i++) t[d+i] = s[d-1-i];
/************found************/
t[2*d-1] = '\0';
}
main()
{
char s[100], t[100];
printf("\nPlease enter string S:"); scanf("%s", s);
fun(s, t);
printf("\nThe result is: %s\n", t);
}
函数fun的功能是： 将s所指字符串中除了下标为奇数、同时ASCII值也为奇数的字符之外，其余的所有字符都删除,串中剩余字符所形成的一个新串放在t所指的数组中。
例如，若s所指字符串中的内容为："ABCDEFG12345",其中字符A的ASCII码值虽为奇数，但所在元素的下标为偶数，因此必需删除；而字符1的ASCII码值为奇数，所在数组中的下标也为奇数,因此不应当删除，其它依此类推。最后t所指的数组中的内容应是："135"。
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
void fun(char *s, char t[])
{
}
main()
{
char s[100], t[100];void NONO ();
printf("\nPlease enter string S:"); scanf("%s", s);
fun(s, t);
printf("\nThe result is: %s\n", t);
NONO();
}
填空题参考答案：
1) s=0; i=0;
2) i++;
3) x=(2.0*i-1)/((2.0*i)*(2.0*i));
修改题参考答案：
1) void fun (char *s, char *t)
2) t[2*d] = '\0';
程序题参考答案：
void fun(char *s, char t[])
{
int i, j = 0 ;
for(i = 0 ; s ; i ++)
if(i%2==1 && s % 2==1) t[j++] = s ;
t[j] = 0 ;
}
第60套
给定程序中，函数fun的功能是：将形参s所指字符串中的所有字母字符顺序前移，其他字符顺序后移，处理后新字符串的首地址作为函数值返回。
例如，s所指字符串为:asd123fgh543df,处理后新字符串:asdfghdf123543。
请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
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<n; i++)
{ if(((s>='a')&&(s<='z'))||((s>='A')&&(s<='Z'))) {
/**********found**********/
t[j]=__1__; j++;}
else
{ p[k]=s; k++; }
}
/**********found**********/
for(i=0; i<__2__; i++) t[j+i]=p;
/**********found**********/
t[j+k]= __3__;
return t;
}
main()
{ char s[80];
printf("Please input: "); scanf("%s",s);
printf("\nThe result is: %s\n",fun(s));
}
给定程序MODI1.C中函数 fun 的功能是：将s所指字符串中最后一次出现的与t1所指字符串相同的子串替换成t2所指字符串,所形成的新串放在w所指的数组中。在此处，要求t1和t2所指字符串的长度相同。
例如，当s所指字符串中的内容为："abcdabfabc"，t1所指子串中的内容为："ab"，t2所指子串中的内容为："99"时， 结果，在w所指的数组中的内容应为："abcdabf99c"。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
void fun (char *s, char *t1, char *t2 , char *w)
{
char *p , *r, *a=s;
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("\nPlease enter string S:"); scanf("%s", s);
printf("\nPlease enter substring t1:"); scanf("%s", t1);
printf("\nPlease enter substring t2:"); scanf("%s", t2);
if ( strlen(t1)==strlen(t2) )
{ fun( s, t1, t2, w);
printf("\nThe result is : %s\n", w);
}
else printf("\nError : strlen(t1) != strlen(t2)\n");
}
函数fun的功能是：将s所指字符串中ASCII值为奇数的字符删除，串中剩余字符形成一个新串放在t所指的数组中。
例如，若s所指字符串中的内容为："ABCDEFG12345"，其中字符A的ASCII码值为奇数、…、字符1的ASCII码值也为奇数、… 都应当删除，其它依此类推。最后t所指的数组中的内容应是："BDF24"。
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
void fun(char *s, char t[])
{
}
main()
{
char s[100], t[100];void NONO ();
printf("\nPlease enter string S:"); scanf("%s", s);
fun(s, t);
printf("\nThe result is: %s\n", t);
NONO();
}
填空题参考答案：
1) t[j]=s; j++;}
2) for(i=0; i<k; i++) t[j+i]=p;
3) t[j+k]= 0;
修改题参考答案：
1) while ( *w )
2) if ( *r == *p )
程序题参考答案：
void fun(char *s, char t[])
{
int i, j = 0 ;
for(i = 0 ; s; i++) if(s % 2==0) t[j++] = s ;
t[j] = 0 ;
}
第61套
给定程序中，函数fun的功能是：将形参s所指字符串中的所有数字字符顺序前移，其他字符顺序后移，处理后新字符串的首地址作为函数值返回。
例如，s所指字符串为：asd123fgh5##43df，
处理后新字符串为：123543asdfgh##df。
请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
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<n; i++)
{ if(isdigit(s)) {
/**********found**********/
p[__1__]=s; j++;}
else
{ t[k]=s; k++; }
}
/**********found**********/
for(i=0; i<__2__; i++) p[j+i]= t;
p[j+k]=0;
/**********found**********/
return __3__;
}
main()
{ char s[80];
printf("Please input: "); scanf("%s",s);
printf("\nThe result is: %s\n",fun(s));
}
给定程序MODI1.C中函数fun的功能是：首先把b所指字符串中的字符按逆序存放， 然后将a所指字符串中的字符和b所指字符串中的字符，按排列的顺序交叉合并到c所指数组中，过长的剩余字符接在c所指数组的尾部。例如，当a所指字符串中的内容为"abcdefg"，b所指字符串中的内容为"1234"时，c所指数组中的内容应该为"a4b3c2d1efg"；而当a所指字符串中的内容为"1234"，b所指字符串中的内容为"abcdefg"时，c所指数组中的内容应该为"1g2f3e4dcba"。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
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; b = 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("\nEnter s1 string : ");scanf("%s",s1);
printf("\nEnter s2 string : ");scanf("%s",s2);
fun( s1, s2, t );
printf("\nThe result is : %s\n", t );
}
函数fun的功能是：将s所指字符串中下标为偶数同时ASCII值为奇数的字符删除，s所指串中剩余的字符形成的新串放在t所指的数组中。
例如，若s所指字符串中的内容为"ABCDEFG12345"，其中字符C的ASCII码值为奇数，在数组中的下标为偶数， 因此必须删除；而字符1的ASCII码值为奇数，在数组中的下标也为奇数，因此不应当删除，其它依此类推。
最后t所指的数组中的内容应是"BDF12345"。
注意: 部分源程序存在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
void fun(char *s, char t[])
{
}
main()
{
char s[100], t[100];void NONO ();
printf("\nPlease enter string S:"); scanf("%s", s);
fun(s, t);
printf("\nThe result is: %s\n", t);
NONO();
}
阅读题参考答案：4342
填空题参考答案：
1) p[j]=s; j++;}
2) for(i=0; i<k; i++) p[j+i]= t;
3) return p;
修改题参考答案：
1) while ( i < j )
2) if ( *a )
程序题参考答案：
void fun(char *s, char t[])
{
int i, j = 0 ;
for(i = 0 ; s ; i++)
if(i % 2 ==0 && s % 2==1)
;
else
t[j++] = s ;
t[j] = 0 ;
}
第62套
给定程序中，函数fun的功能是：计算形参x所指数组中N个数的平均值（规定所有数均为正数）,作为函数值返回；并将大于平均值的数放在形参y所指数组中,在主函数中输出。
例如，有10个正数：46 30 32 40 6 17 45 15 48 26，平均值为：
30.500000
主函数中输出：46 32 40 45 48
请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdlib.h>
#include <stdio.h>
#define N 10
double fun(double x[],double *y)
{ int i,j; double av;
/**********found**********/
av=__1__;
/**********found**********/
for(i=0; i<N; i++) av = av + __2__;
for(i=j=0; i<N; i++)
/**********found**********/
if(x>av) y[__3__]= x;
y[j]=-1;
return av;
}
main()
{ int i; double x[N],y[N];
for(i=0; i<N; i++){ x=rand()%50; printf("%4.0f ",x);}
printf("\n");
printf("\nThe average is: %f\n",fun(x,y));
for(i=0; y>=0; i++) printf("%5.1f ",y);
printf("\n");
}
给定程序MODI1.C中函数fun的功能是：根据整型形参m，计算如下公式的值。
1 1 1 1
y = ------- + --------- + --------- + …… + -------
100*100 200*200 300*300 m*m
例如，若m = 2000，则应输出： 0.000160。
请改正程序中的语法错误，使它能计算出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
/************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( "\nThe result is %lf\n", fun ( n ) ) ;
}
已知学生的记录由学号和学习成绩构成，N名学生的数据已存入a结构体数组中。请编写函数 fun，函数的功能是：找出成绩最低的学生记录，通过形参返回主函数(规定只有一个最低分)。
注意: 部分源程序存在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
#define N 10
typedef struct ss
{ char num[10]; int s; } STU;
void fun( STU a[], STU *s )
{
}
main ( )
{ STU a[N]={ {"A01",81},{"A02",89},{"A03",66},{"A04",87},{"A05",77},
{"A06",90},{"A07",79},{"A08",61},{"A09",80},{"A10",71} }, m ;
int i;void NONO ();
printf("***** The original data *****\n");
for ( i=0; i< N; i++ )printf("No = %s Mark = %d\n", a.num,a.s);
fun ( a, &m );
printf ("***** THE RESULT *****\n");
printf ("The lowest : %s , %d\n",m.num, m.s);
NONO( );
}
填空题参考答案：
1) av=0;
2) for(i=0; i<N; i++) av = av + x/N;
3) if(x>av) y[j++]= x;
修改题参考答案：
1) double fun ( int m )
2) for( i = 100; i <= m; i += 100 )
程序题参考答案：
void fun( STU a[], STU *s )
{
int i, j = 0;
for(i = 1 ; i < N ; i++)
if(a[j].s > a.s)
j = i ;
*s = a[j] ;
}
第63套
给定程序中，函数fun的功能是：计算x所指数组中N个数的平均值（规定所有数均为正数）,平均值通过形参返回主函数，将小于平均值且最接近平均值的数作为函数值返回，在主函数中输出。
例如，有10个正数：46 30 32 40 6 17 45 15 48 26，平均值为：30.500000
主函数中输出：m=30.0
请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdlib.h>
#include <stdio.h>
#define N 10
double fun(double x[],double *av)
{ int i,j; double d,s;
s=0;
for(i=0; i<N; i++) s = s +x;
/**********found**********/
__1__=s/N;
d=32767;
for(i=0; i<N; i++)
if(x<*av && *av - x<=d){
/**********found**********/
d=*av-x; j=__2__;}
/**********found**********/
return __3__;
}
main()
{ int i; double x[N],av,m;
for(i=0; i<N; i++){ x=rand()%50; printf("%4.0f ",x);}
printf("\n");
m=fun(x,&av);
printf("\nThe average is: %f\n",av);
printf("m=%5.1f ",m);
printf("\n");
}
给定程序MODI1.C中函数fun的功能是：根据整型形参n，计算如下公式的。
A1=1 , A2=1/(1+A1), A3=1/(1+A2)....
例如，若 n=10，则应输出： 0.617977。
请改正程序中的语法错误，使它能得出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程
序的结构！
#include <stdio.h>
/************found************/
int fun ( int n )
{ float A=1; int i;
/************found************/
for (i=2; i<n; i++)
A = 1/(1+A);
return A ;
}
main( )
{ int n ;
printf("\nPlease enter n: ") ;
scanf("%d", &n ) ;
printf("A%d=%f\n", n, fun(n) ) ;
}
程序定义了N×N的二维数组，并在主函数中自动赋值。请编写函数fun，函数的功能是：使数组右上三角元素中的值乘以m 。
例如：若m的值为2，a 数组中的值为
| 1 9 7 | | 2 18 14|
a =| 2 3 8 | 则返回主程序后a数组中的值应为 | 2 6 16|
| 4 5 6 | | 4 5 12|
注意: 部分源程序存在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容， 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <stdlib.h>
#define N 5
void fun ( int a[][N], int m )
{
}
main ( )
{ int a[N][N], m, i, j;void NONO ();
printf("***** The array *****\n");
for ( i =0; i<N; i++ )
{ for ( j =0; j<N; j++ )
{ a[j] = rand()%20; printf( "%4d", a[j] ); }
printf("\n");
}
do m = rand()%10 ; while ( m>=3 );
printf("m = %4d\n",m);
fun ( a ,m );
printf ("THE RESULT\n");
for ( i =0; i<N; i++ )
{ for ( j =0; j<N; j++ ) printf( "%4d", a[j] );
printf("\n");
}
NONO ( );
}
阅读题参考答案：4143
填空题参考答案：
1) *av=s/N;
2) d=*av-x; j=i;}
3) return x[j];
修改题参考答案：
1) float fun ( int n )
2) for (i=2; i<=n; i++)
程序题参考答案：
void fun ( int a[][N], int m )
{
int i, j;
for(i = 0 ; i < N ; i++)
for(j = i ; j < N ; j++)
a[j] *= m ;
}
第64套
给定程序中，函数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 <stdlib.h>
#include <stdio.h>
#define N 10
double fun(double *x)
{ int i, j; double s, av, y[N];
s=0;
for(i=0; i<N; i++) s=s+x;
/**********found**********/
av=__1__;
for(i=j=0; i<N; i++)
if( x>av ){
/**********found**********/
y[__2__]=x; x=-1;}
for(i=0; i<N; i++)
/**********found**********/
if( x!= __3__) y[j++]=x;
for(i=0; i<N; i++)x = y;
return av;
}
main()
{ int i; double x[N];
for(i=0; i<N; i++){ x=rand()%50; printf("%4.0f ",x);}
printf("\n");
printf("\nThe average is: %f\n",fun(x));
printf("\nThe result :\n",fun(x));
for(i=0; i<N; i++) printf("%5.0f ",x);
printf("\n");
}
给定程序MODI1.C的功能是：读入一个英文文本行，将其中每个单词的第一个字母改成大写，然后输出此文本行(这里的“单词”是指由空格隔开的字符串)。
例如，若输入：I am a student to take the examination.,
则应输出：I Am A Student To Take The Examination.。
请改正程序中的错误，使程序能得出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <ctype.h>
#include <string.h>
/************found************/
include <stdio.h>
/************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( "\nPlease enter an English text line: " ); gets( chrstr );
printf( "\n\nBefore changing:\n %s", chrstr );
upfst( chrstr );
printf( "\nAfter changing:\n %s\n", chrstr );
}
程序定义了N×N的二维数组，并在主函数中赋值。请编写函数fun,函数的功能是：求出数组周边元素的平均值并作为函数值返给主函数中的s。
例如：a 数组中的值为
|0 1 2 7 9|
|1 9 7 4 5|
a = |2 3 8 3 1|
|4 5 6 8 2|
|5 9 1 4 1|
则返回主程序后s的值应为: 3.375。
注意: 部分源程序存在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <stdlib.h>
#define N 5
double fun ( int w[][N] )
{
}
main ( )
{ int a[N][N]={0,1,2,7,9,1,9,7,4,5,2,3,8,3,1,4,5,6,8,2,5,9,1,4,1};
int i, j;void NONO ();
double s ;
printf("***** The array *****\n");
for ( i =0; i<N; i++ )
{ for ( j =0; j<N; j++ )
{ printf( "%4d", a[j] ); }
printf("\n");
}
s = fun ( a );
printf ("***** THE RESULT *****\n");
printf( "The sum is : %lf\n",s );
NONO( );
}
阅读题参考答案：3213
填空题参考答案：
1) av=s/N;
2) y[j++]=x; x=-1;}
3) if( x!= -1) y[j++]=x;
修改题参考答案：
1) #include <stdio.h>
2) upfst ( char *p )
程序题参考答案：
double fun ( int w[][N] )
{
int i, j, n=0;
double sum=0;
for(i=0 ; i<N ; i++)
for(j=0 ; j<N ; j++)
if(i==0 || i==N-1 || j==0 || j==N-1)
{ sum=sum+w[j]; n++;}
return sum/n;
}
第65套
给定程序中，函数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 <stdlib.h>
#include <stdio.h>
#define N 10
double fun(double *x)
{ int i, j; double av, y[N];
av=0;
/**********found**********/
for(i=0; i<N; i++) av +=__1__;
for(i=j=0; i<N; i++)
if( x<av ){
/**********found**********/
y[j]=x; x=-1; __2__;}
i=0;
while(i<N)
{ if( x!= -1 ) y[j++]=x;
/**********found**********/
__3__;
}
for(i=0; i<N; i++)x = y;
return av;
}
main()
{ int i; double x[N];
for(i=0; i<N; i++){ x=rand()%50; printf("%4.0f ",x);}
printf("\n");
printf("\nThe average is: %f\n",fun(x));
printf("\nThe result :\n",fun(x));
for(i=0; i<N; i++) printf("%5.0f ",x);
printf("\n");
}
给定程序MODI1.C中函数 fun 的功能是：统计字符串中各元音字母（即：A、E、I、O、U）的个数。注意：字母不分大、小写。
例如：若输入：THIs is a boot，则输出应该是：1、0、2、2、0。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
void fun ( char *s, int num[5] )
{ int k, i=5;
for ( k = 0; k<i; k++ )
/**********found**********/
num=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++;
}
}
main( )
{ char s1[81]; int num1[5], i;
printf( "\nPlease enter a string: " ); gets( s1 );
fun ( s1, num1 );
for ( i=0; i < 5; i++ ) printf ("%d ",num1); printf ("\n");
}
请编写函数 fun，函数的功能是求出二维数组周边元素之和，作为函数值返回。二维数组中的值在主函数中赋予。
例如：二维数组中的值为
1 3 5 7 9
2 9 9 9 4
6 9 9 9 8
1 3 5 7 0
则函数值为 61。
注意: 部分源程序存在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#define M 4
#define N 5
int fun ( int a[M][N] )
{
}
main( )
{ int aa[M][N]={{1,3,5,7,9},
{2,9,9,9,4},
{6,9,9,9,8},
{1,3,5,7,0}};
int i, j, y;void NONO ();
printf ( "The original data is : \n" );
for ( i=0; i<M; i++ )
{ for ( j =0; j<N; j++ ) printf( "%6d", aa[j] );
printf ("\n");
}
y = fun ( aa );
printf( "\nThe sum: %d\n" , y );
printf("\n");
NONO( );
}
阅读题参考答案：4132
填空题参考答案：
1) for(i=0; i<N; i++) av +=x/N;
2) y[j]=x; x=-1; j++;}
3) i++;
修改题参考答案：
1) num[k]=0;
2) switch ( *s )
程序题参考答案：
int fun ( int a[M][N] )
{
int tot = 0, i, j ;
for(i=0 ; i<M ; i++)
for(j=0 ; j<N ; j++)
if(i==0 || i==M-1 || j==0 || j==N-1)
tot+=a[j];
return tot ;
}
第66套
给定程序中，函数fun的功能是将a和b所指的两个字符串转换成面值相同的
数，并进行相加作为函数值返回，规定字符串中只含9个以下数字字符。
例如，主函数中输入字符串：32486和12345，在主函数中输出的函数值为：44831。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#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 )
{
/**********found**********/
return __3__;
}
main()
{ char s1[N],s2[N];
do
{ printf("Input string s1 : "); gets(s1); }
while( strlen(s1)>N );
do
{ printf("Input string s2 : "); gets(s2); }
while( strlen(s2)>N );
printf("The result is: %ld\n", fun(s1,s2) );
}
给定程序MODI1.C中 fun 函数的功能是：分别统计字符串中大写字母和小写字母的个数。
例如, 给字符串 s 输入：AAaaBBb123CCccccd，则应输出结果：
upper = 6, lower = 8。
请改正程序中的错误，使它能计算出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
/**********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( "\nPlease a string : " ); gets ( s );
fun ( s, & upper, &lower );
printf( "\n upper = %d lower = %d\n", upper, lower );
}
请编一个函数fun，函数的功能是使实型数保留2位小数，并对第三位进行四舍五入 （规定实型数为正数）。
例如：实型数为 1234.567, 则函数返回 1234.570000；
实型数为 1234.564, 则函数返回 1234.560000。
注意: 部分源程序存在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
float fun ( float h )
{
}
main( )
{ float a;void NONO ();
printf ("Enter a: "); scanf ( "%f", &a );
printf ( "The original data is : " );
printf ( "%f \n\n", a );
printf ( "The result : %f\n", fun ( a ) );
NONO( );
}
填空题参考答案：
1) d=d*10+*s-'0';
2) s++; }
3) return ctod(a)+ctod(b);
修改题参考答案：
1) void fun ( char *s, int *a, int *b )
2) *a=*a+1 ;
3) *b=*b+1;
程序题参考答案：
float fun ( float h )
{
return (float) (h * 100 + 0.5) / 100 ;
}
第67套
给定程序中，函数fun的功能是：调用随机函数产生20个互不相同的整数放在形参a所指数组中（此数组在主函数中已置0）。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdlib.h>
#include <stdio.h>
#define N 20
void fun( int *a)
{ int i, x, n=0;
x=rand()%20;
/**********found**********/
while (n<__1__)
{ for(i=0; i<n; i++ )
/**********found**********/
if( x==a ) __2__;
/**********found**********/
if( i==__3__){ a[n]=x; n++; }
x=rand()%20;
}
}
main()
{ int x[N]={0} ,i;
fun( x );
printf("The result : \n");
for( i=0; i<N; i++ )
{ printf("%4d",x);
if((i+1)%5==0)printf("\n");
}
printf("\n\n");
}
给定程序MODI1.C中函数fun的功能是: 先从键盘上输入一个3行3列矩阵的各个元素的值, 然后输出主对角线元素之和。
请改正函数fun中的错误或在横线处填上适当的内容并把横线删除,使它能得出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
void fun()
{
int a[3][3],sum;
int i,j;
/*********found**********/
______;
printf("Input data:");
for (i=0;i<3;i++)
{ for (j=0;j<3;j++)
/*********found**********/
scanf("%d",a[j]);
}
for (i=0;i<3;i++)
sum=sum+a;
printf("Sum=%d\n",sum);
}
main()
{
fun();
}
编写程序, 实现矩阵（3行3列）的转置(即行列互换)
例如, 输入下面的矩阵:
100 200 300
400 500 600
700 800 900
程序输出:
100 400 700
200 500 800
300 600 900
注意: 部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun(int array[3][3])
{
}
main()
{
int i,j;void NONO ();
int array[3][3]={{100,200,300},
{400,500,600},
{700,800,900}};
for (i=0;i<3;i++)
{ for (j=0;j<3;j++)
printf("%7d",array[j]);
printf("\n");
}
fun(array);
printf("Converted array:\n");
for (i=0;i<3;i++)
{ for (j=0;j<3;j++)
printf("%7d",array[j]);
printf("\n");
}
NONO();
}
阅读题参考答案：1324
填空题参考答案：
1) while (n<N)
2) if( x==a ) break;
3) if( i==n){ a[n]=x; n++; }
修改题参考答案：
1) sum=0;
2) scanf("%d",&a[j]);
程序题参考答案：
void fun(int array[3][3])
{
int i,j,t ;
for(i = 0 ; i < 3 ; i++)
for(j = 0 ; j < i ; j++)
{ t=array[j] ; array[j]=array[j]; array[j]=t; }
}
第68套
给定程序中，函数fun的功能是：找出N×N矩阵中每列元素中的最大值，并按顺序依次存放于形参b所指的一维数组中。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define N 4
void fun(int (*a)[N], int *b)
{ int i,j;
for(i=0; i<N; i++) {
/**********found**********/
b= __1__;
for(j=1; j<N; j++)
/**********found**********/
if(b __2__ a[j]) b=a[j];
}
}
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("\nThe matrix :\n");
for(i=0;i<N; i++)
{ for(j=0;j<N; j++) printf("%4d",x[j]);
printf("\n");
}
/**********found**********/
fun(__3__);
printf("\nThe result is:");
for(i=0; i<N; i++) printf("%3d",y);
printf("\n");
}
给定程序MODI1.C中函数fun的功能是: 交换主函数中两个变量的值。例如: 若变量a中的值原为8,b中的值为3。程序运行后a中的值为3, b中的值为8。
请改正程序中的错误, 使它能计算出正确的结果。
注意: 不要改动 main 函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
/*********found**********/
void 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, %d\n",a,b);
}
编写函数fun, 函数的功能是求出小于或等于lim的所有素数并放在aa数组中,函数返回所求出的素数的个数。函数fun中给出的语句仅供参考。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#define MAX 100
int fun(int lim, int aa[MAX])
{
/* 以下代码仅供参考 */
int i,j,k=0;
/* 其中变量k用于统计素数个数 */
for(i=2;i<=lim;i++)
{
/* 以下完成判断aa数组中小于或等于lim的素数并统计个数 */
}
return k;
}
main()
{
int limit, i, sum;void NONO ();
int aa[MAX] ;
printf("输入一个整数");
scanf("%d", &limit);
sum=fun(limit, aa);
for(i=0 ; i < sum ; i++) {
if(i % 10 == 0 && i != 0) printf("\n") ;
printf("%5d", aa) ;
}
NONO();
}
阅读题参考答案：2142
填空题参考答案：
1) b= a[0];
2) if(b < a[j]) b=a[j];
3) fun(x,y);
修改题参考答案：
1) void fun(int *x,int *y)
2) t=*x;*x=*y;*y=t;
程序题参考答案：
int fun(int lim, int aa[MAX])
{
/* 以下代码仅供参考 */
int i,j,k=0;
/* 其中变量k用于统计素数个数 */
for(i=2;i<=lim;i++)
{
/* 以下完成判断aa数组中小于或等于lim的素数并统计个数 */
for(j = 2 ; j <i ; j++)
if(i % j == 0) break;
if(j ==i ) aa[k++] = i;
}
return k;
}
第69套
给定程序中，函数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
1 1 1 1 1
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#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<m; i++) {
/**********found**********/
for(j= __2__ ; j<N-i; j++)
a[j]=a[N-i-1][j]=i+1;
for(k=i+1; k<N-i; k++)
/**********found**********/
a[k]=a[k][N-i-1]= __3__;
}
}
main()
{ int x[N][N]={0},i,j;
fun(x);
printf("\nThe result is:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++) printf("%3d",x[j]);
printf("\n");
}
}
给定程序MODI1.C中函数 fun 的功能是: 将十进制正整数m转换成k(2≤k≤9)进制数, 并按高位到低位顺序输出。
例如，若输入8和2,则应输出1000(即十进制数8转换成二进制表示是1000)。
请改正 fun 函数中的错误，使它能得出正确的结果。
注意：不要改动 main 函数。不得增行或删行，也不得更改程序的结构！
#include <conio.h>
#include <stdio.h>
void fun( int m, int k )
{
int aa[20], i;
for( i = 0; m; i++ )
{
/**********found**********/
aa = m/k;
m /= k;
}
for( ; i; i-- )
/**********found**********/
printf( "%d", aa[ i ] );
}
main()
{
int b, n;
printf( "\nPlease enter a number and a base:\n" );
scanf( "%d %d", &n, &b );
fun( n, b );
printf("\n");
}
编写一个函数,从num个字符串中找出最长的一个字符串,并通过形参指针max传回该串地址。(注意: 主函数中用****作为结束输入的标志，函数fun中给出的语句仅供参考。)
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
void fun(char(*a)[81],int num,char **max)
{
/* 以下代码仅供参考 */
int i,k=0,len, maxlen; /* k为a数组中最长串所在元素的下标，初始为0，maxlen为其长度 */
maxlen=strlen(a[k]);
for(i=1;i<num;i++)
{
/* 以下完成查找最长串 */
}
*max=a[k];
}
main()
{
char ss[10][81],*ps;void NONO ();
int n,i=0;
printf("输入若干个字符串:");
gets(ss);
puts(ss);
while(!strcmp(ss,"****")==0)
{
i++;
gets(ss);
puts(ss);
}
n=i;
fun(ss,n,&ps);
printf("\nmax=%s\n",ps);
NONO();
}
阅读题参考答案：2143
填空题参考答案：
1) void fun(int (*a) [N])
2) for(j= i ; j<N-i; j++)
3) a[k]=a[k][N-i-1]= i+1;
修改题参考答案：
1) aa = m%k;
2) printf( "%d", aa[ i-1 ] );
程序题参考答案：
void fun(char(*a)[81],int num,char **max)
{
/* 以下代码仅供参考 */
int i,k=0,maxlen; /* k为a数组中最长串所在元素的下标，初始为0，maxlen为其
maxlen=strlen(a[k]);
for(i=1;i<num;i++)
{
/* 以下完成查找最长串 */
if(strlen(a) > maxlen) {
maxlen = strlen(a) ;
k = i ;
}
}
*max=a[k];
}
第70套
给定程序中，函数fun的功能是：判定形参a所指的N×N（规定N为奇数）的矩阵是否是"幻方"，若是，函数返回值为1； 不是，函数返回值为0。"幻方"的判定条件是：矩阵每行、每列、主对角线及反对角线上元素之和都相等。
例如，以下3×3的矩阵就是一个"幻方"：
4 9 2
3 5 7
8 1 6
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define N 3
int fun(int (*a)[N])
{ int i,j,m1,m2,row,colum;
m1=m2=0;
for(i=0; i<N; i++)
{ j=N-i-1; m1+=a; m2+=a[j]; }
if(m1!=m2) return 0;
for(i=0; i<N; i++) {
/**********found**********/
row=colum= __1__;
for(j=0; j<N; j++)
{ row+=a[j]; colum+=a[j]; }
/**********found**********/
if( (row!=colum) __2__ (row!=m1) ) return 0;
}
/**********found**********/
return __3__;
}
main()
{ int x[N][N],i,j;
printf("Enter number for array:\n");
for(i=0; i<N; i++)
for(j=0; j<N; j++) scanf("%d",&x[j]);
printf("Array:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++) printf("%3d",x[j]);
printf("\n");
}
if(fun(x)) printf("The Array is a magic square.\n");
else printf("The Array isn't a magic square.\n");
}
给定程序MODI1.C中fun函数的功能是: 根据整型形参m，计算如下公式的值。
1 1 1
t = 1 - ----- - ----- - …… - -----
2 3 m
例如，若主函数中输入5，则应输出 -0.283333。
请改正函数fun中的错误或在横线处填上适当的内容并把横线删除, 使它能计算出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
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( "\nPlease enter 1 integer numbers:\n" );
scanf( "%d", &m);
printf( "\n\nThe result is %lf\n", fun( m ) );
}
请编写一个函数，函数的功能是删除字符串中的所有空格。
例如, 主函数中输入"asd af aa z67", 则输出为 "asdafaaz67"。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <ctype.h>
void fun(char *str)
{
}
main()
{
char str[81];void NONO ();
printf("Input a string:") ;
gets(str);
puts(str);
fun(str);
printf("*** str: %s\n",str);
NONO();
}
void NONO ()
{
/* 请在此函数内打开文件，输入调试数据，调用 fun 函数，
输出数据，关闭文件。 */
char str[81];
int n = 0;
FILE *rf, *wf ;
rf = fopen("in.dat","r") ;
wf = fopen("out.dat","w") ;
while(n < 10) {
fgets(str, 80, rf);
fun(str);
fprintf(wf, "%s", str) ;
n++ ;
}
fclose(rf) ;
fclose(wf) ;
}
填空题参考答案：
1) row=colum= 0;
2) if( (row!=colum) || (row!=m1) ) return 0;
3) return 1;
修改题参考答案：
1) t = t-1.0/i;
2) return t;
程序题参考答案：
void fun(char *str)
{
int i ,j=0 ;
for(i=0 ; str; i++)
if(str != ' ')
str[j++] = str ;
str[j] = 0 ;
}
第71套
给定程序中，函数fun的功能是：将a所指4×3矩阵中第k行的元素与第0行元素交换。
例如，有下列矩阵：
1 2 3
4 5 6
7 8 9
10 11 12
若k为2，程序执行结果为：
7 8 9
4 5 6
1 2 3
10 11 12
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define N 3
#define M 4
/**********found**********/
void fun(int (*a)[N], int __1__)
{ int i,temp ;
/**********found**********/
for(i = 0 ; i < __2__ ; i++)
{ temp=a[0] ;
/**********found**********/
a[0] = __3__ ;
a[k] = temp ;
}
}
main()
{ int x[M][N]={ {1,2,3},{4,5,6},{7,8,9},{10,11,12} },i,j;
printf("The array before moving:\n\n");
for(i=0; i<M; i++)
{ for(j=0; j<N; j++) printf("%3d",x[j]);
printf("\n\n");
}
fun(x,2);
printf("The array after moving:\n\n");
for(i=0; i<M; i++)
{ for(j=0; j<N; j++) printf("%3d",x[j]);
printf("\n\n");
}
}
给定程序MODI1.C中函数 fun 的功能是: 读入一个字符串(长度＜20 ),将该字符串中的所有字符按ASCII码升序排序后输出。
例如, 若输入: edcba, 则应输出: abcde。
请改正程序中的错误，使它能统计出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
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( "\nPlease enter a character string: " );
gets( s );
printf( "\n\nBefore sorting:\n \"%s\"", s );
fun( s );
printf( "\nAfter sorting decendingly:\n \"%s\"", s );
}
请编写一个函数fun, 其功能是: 将ss所指字符串中所有下标为奇数位置上的字母转换为大写（若该位置上不是字母, 则不转换）。
例如, 若输入"abc4EFg"，则应输出"aBc4EFg"。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
void fun( char *ss )
{
}
void main( void )
{
char tt[51];void NONO ();
printf( "\nPlease enter an character string within 50 characters:\n" );
gets( tt );
printf( "\n\nAfter changing, the string\n \"%s\"", tt );
fun(tt) ;
printf( "\nbecomes\n \"%s\"", tt );
NONO();
}
填空题参考答案：
1) void fun(int (*a)[N], int k)
2) for(i = 0 ; i < N ; i++)
3) a[0] = a[k] ;
修改题参考答案：
1) for( i = strlen( t )-1; i; i-- )
2) if( t[j] > t[ j + 1 ] )
程序题参考答案：
void fun( char *ss )
{
int i = 0 ;
for(i=0 ; ss ; i++)
if(i % 2==1 && ss >= 'a' && ss <= 'z')
ss -= 32 ;
}
第72套
给定程序中，函数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 <stdio.h>
#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<M; i++)
{ temp=a[0];
/**********found**********/
for(j=0; j< __2__ ; j++) a[j]=a[j+1];
/**********found**********/
a[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("The array before moving:\n\n");
for(i=0; i<M; i++)
{ for(j=0; j<N; j++) printf("%3d",x[j]);
printf("\n");
}
fun(x,2);
printf("The array after moving:\n\n");
for(i=0; i<M; i++)
{ for(j=0; j<N; j++) printf("%3d",x[j]);
printf("\n");
}
}
给定程序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函数，不得增行或删行，也不得更改程序的结构！
#include <conio.h>
#include <stdio.h>
#define M 10
int a[M][M] = {0} ;
/**************found**************/
void 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 ( " Enter n : " ) ; scanf ("%d", &n ) ;
fun ( a, n ) ;
for ( i = 0 ; i < n ; i++)
{ for (j = 0 ; j < n ; j++)
printf ( "%4d", a[j] ) ;
printf ( "\n" ) ;
}
}
函数fun的功能是：将a、b中的两个两位正整数合并形成一个新的整数放在c中。合并的方式是:将a中的十位和个位数依次放在变量c的十位和千位上，b中的十位和个位数依次放在变量c的个位和百位上。
例如，当a＝45，b=12。调用该函数后，c=5241。
注意: 部分源程序存在文件PROG1.C中。数据文件IN.DAT中的数据不得修改。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun(int a, int b, long *c)
{
}
main()
{ int a,b; long c;void NONO ();
printf("Input a, b:");
scanf("%d%d", &a, &b);
fun(a, b, &c);
printf("The result is: %ld\n", c);
NONO();
}
填空题参考答案：
1) for(p=1; p<= k; p++)
2) for(j=0; j< N-1 ; j++) a[j]=a[j+1];
3) a[N-1]= temp;
修改题参考答案：
1) void fun(int a[][M], int m)
2) a[j][k] = (k+1)*(j+1) ;
程序题参考答案：
void fun(int a, int b, long *c)
{
*c=(a%10)*1000+(b%10)*100+(a/10)*10+(b/10);
}
第73套
给定程序中，函数fun的功能是：在3×4的矩阵中找出在行上最大、在列上最小的那个元素，若没有符合条件的元素则输出相应信息。
例如，有下列矩阵：
1 2 13 4
7 8 10 6
3 5 9 7
程序执行结果为：find: a[2][2]=9
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#define M 3
#define N 4
void fun(int (*a)[N])
{ int i=0,j,find=0,rmax,c,k;
while( (i<M) && (!find))
{ rmax=a[0]; c=0;
for(j=1; j<N; j++)
if(rmax<a[j]) {
/**********found**********/
rmax=a[j]; c= __1__ ; }
find=1; k=0;
while(k<M && find) {
/**********found**********/
if (k!=i && a[k][c]<=rmax) find= __2__ ;
k++;
}
if(find) printf("find: a[%d][%d]=%d\n",i,c,a[c]);
/**********found**********/
__3__ ;
}
if(!find) printf("not found!\n");
}
main()
{ int x[M][N],i,j;
printf("Enter number for array:\n");
for(i=0; i<M; i++)
for(j=0; j<N; j++) scanf("%d",&x[j]);
printf("The array:\n");
for(i=0; i<M; i++)
{ for(j=0; j<N; j++) printf("%3d",x[j]);
printf("\n\n");
}
fun(x);
}
给定程序MODI1.C中函数fun的功能是：根据整型形参m的值，计算如下公式的值。
1 1 1
t = 1 - ----- - ----- - …… - -----
2*2 3*3 m*m
例如，若 m 中的值为: 5，则应输出: 0.536389。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
double fun ( int m )
{ 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( "\nThe result is %lf\n", fun ( n ) ) ;
}
m个人的成绩存放在score数组中，请编写函数fun，它的功能是:将低于平均分的人数作为函数值返回，将低于平均分的分数放在below所指的数组中。
例如，当score数组中的数据为：10、20、30、40、50、60、70、80、90时，函数返回的人数应该是4, below中的数据应为: 10、20、30、40。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
int fun(int score[], int m, int below[])
{
}
main( )
{ int i, n, below[9] ;void NONO ();
int score[9] = {10, 20, 30, 40, 50, 60, 70, 80, 90} ;
n = fun(score, 9, below) ;
printf( "\nBelow the average score are: " ) ;
for (i = 0 ; i < n ; i++) printf("%d ", below) ;
NONO() ;
}
填空题参考答案：
1) rmax=a[j]; c= j ; }
2) if (k!=i && a[k][c]<=rmax) find= 0 ;
3) i++ ;
修改题参考答案：
1) for(i = 2 ; i <= m ; i++)
2) y -= 1.0/(i * i) ;
程序题参考答案：
int fun(int score[], int m, int below[])
{
float av=0.0 ;
int i, j=0 ;
for(i=0; i<m; i++) av += score ;
av /= m;
for(i=0; i<m; i++)
if(av>score) below[j++]=score;
return j;
}
第74套
给定程序中，函数fun的功能是：把形参s所指字符串中最右边的n个字符复制到形参t所指字符数组中，形成一个新串。若s所指字符串的长度小于n，则将整个字符串复制到形参t所指字符数组中。
例如，形参s所指的字符串为:abcdefgh，n的值为5，程序执行后t所指字符数组中的字符串应为：defgh。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#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("Enter a string: ");gets(s);
printf( "Enter n:"); scanf("%d",&n);
fun(s,n,t);
printf("The string t : "); puts(t);
}
给定程序MODI1.C中函数fun的功能是：找出一个大于形参m且紧随m的素数，并作为函数值返回。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
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("n=%d\n", n) ;
}
请编写函数fun，它的功能是：求出能整除形参x且不是偶数的各整数,并按从小到大的顺序放在pp所指的数组中,这些除数的个数通过形参n返回。
例如，若 x 中的值为: 35，则有 4 个数符合要求，它们是: 1, 5, 7, 35。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun ( int x, int pp[], int *n )
{
}
main( )
{ int x, aa[1000], n, i ;void NONO ();
printf( "\nPlease enter an integer number:\n" ) ; scanf("%d", &x) ;
fun(x, aa, &n ) ;
for( i = 0 ; i < n ; i++ )
printf("%d ", aa) ;
printf("\n") ;
NONO( ) ;
}
填空题参考答案：
1) if(n>=len) strcpy(t,s);
2) for(i=len-n; i<=len-1; i++) t[j++]= s ;
3) t[j]= 0 ;
修改题参考答案：
1) if (i % k == 0)
2) if (k >= i)
程序题参考答案：
void fun ( int x, int pp[], int *n )
{
int i,j=0;
for(i=1; i <= x; i++)
if(x % i== 0 && i % 2==1) pp[j++]=i;
*n=j;
}
第75套
给定程序中，函数fun的功能是：判断形参s所指字符串是否是"回文"（Palindrome），若是，函数返回值为1；不是，函数返回值为0。"回文"是正读和反读都一样的字符串（不区分大小写字母）。
例如，LEVEL和Level是"回文"，而LEVLEV不是"回文"。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int fun(char *s)
{ char *lp,*rp;
/**********found**********/
lp= __1__ ;
rp=s+strlen(s)-1;
while((toupper(*lp)==toupper(*rp)) && (lp<rp) ) {
/**********found**********/
lp++; rp __2__ ; }
/**********found**********/
if(lp<rp) __3__ ;
else return 1;
}
main()
{ char s[81];
printf("Enter a string: "); scanf("%s",s);
if(fun(s)) printf("\n\"%s\" is a Palindrome.\n\n",s);
else printf("\n\"%s\" isn't a Palindrome.\n\n",s);
}
给定程序MODI1.C中fun函数的功能是：求出以下分数序列的前n项之和。
2 3 5 8 13 21
┄┄ , ┄┄ , ┄┄ , ┄┄ , ┄┄ , ┄┄ , ……
1 2 3 5 8 13
和值通过函数值返回main函数。
例如，若 n = 5，则应输出： 8.391667。
请改正程序中的错误，使它能得出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
/**************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( "\nThe value of function is: %lf\n", fun ( n ) ) ;
}
请编写函数fun，函数的功能是：将大于形参m且紧靠m的k个素数存入xx所指的数组中。例如，若输入17, 5，则应输出：19, 23, 29, 31, 37。函数fun中给出的语句仅供参考。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun(int m, int k, int xx[])
{
/* 以下代码仅供参考 */
int i, j=1, t=m+1;
while(j<=k)
{
/* 以下完成判断素数，并存放到数组xx中 */
}
}
main()
{
int m, n, zz[1000] ;void NONO ();
printf( "\nPlease enter two integers:") ;
scanf("%d%d", &m, &n ) ;
fun( m, n, zz) ;
for( m = 0 ; m < n ; m++ )
printf("%d ", zz[m]) ;
printf("\n") ;
NONO( ) ;
}
填空题参考答案：
1) lp= s ;
2) lp++; rp -- ; }
3) if(lp<rp) return 0 ;
修改题参考答案：
1) double fun (int n )
2) c = a; a += b; b = c;
程序题参考答案：
void fun(int m, int k, int xx[])
{
/* 以下代码仅供参考 */
int i, j=0, t=m+1;
while(j<k)
{
/* 以下完成判断素数，并存放到数组xx中 */
for(i = 2 ; i < t; i++)
if(t % i==0) break;
if(i==t)
xx[j++] = i;
t++;
}
}
第76套
给定程序中，函数fun的功能是：计算出形参s所指字符串中包含的单词个数,作为函数值返回。为便于统计，规定各单词之间用空格隔开。
例如，形参s所指的字符串为：This is a C language program.，函数的返回值为6。
请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
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("\nEnter a line text:\n"); gets(str);
n=fun(str);
printf("\nThere are %d words in this text.\n\n",n);
}
给定程序MODI1.C中函数 fun 的功能是：从n(形参)个学生的成绩中统计出低于平均分的学生人数，此人数由函数值返回,平均分存放在形参aver所指的存储单元中。
例如，若输入 8 名学生的成绩：80.5 60 72 90.5 98 51.5 88 64则低于平均分的学生人数为： 4 （平均分为：75.5625 ）。
请改正程序中的错误，使它能统计出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#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 ( "\nPlease enter m: " ) ; scanf ("%d", &m ) ;
printf ( "\nPlease enter %d mark :\n ", m ) ;
for( i = 0 ; i < m ; i++ ) scanf ( "%f", s + i ) ;
printf( "\nThe number of students : %d \n" , fun ( s, m, &aver ) );
printf( "Ave = %f\n", aver ) ;
}
请编写函数fun，其功能是求出数组的最大元素在数组中的下标并存放在k所指的存储单元中。
例如, 输入如下整数: 876 675 896 101 301 401 980 431 451 777
则输出结果为: 6, 980
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun(int *s, int t, int *k)
{
}
main( )
{
int a[10]={876,675,896,101,301,401,980,431,451,777}, k ;void NONO ();
fun(a, 10, &k) ;
printf("%d, %d\n", k, a[k]) ;
NONO( ) ;
}
填空题参考答案：
1) n++ ; flag=1;}
2) if (*s==' ') flag= 0 ;
3) s++ ;
修改题参考答案：
1) t += s[k] ;
2) *aver = ave ;
程序题参考答案：
void fun(int *s, int t, int *k)
{
int i, pos = 0, max = *s ;
for(i = 1 ; i < t ; i++) {
if(max < s) {
max = s ;
pos = i ;
}
}
*k = pos ;
}
第77套
给定程序中，函数fun的功能是：将形参s所指字符串中所有ASCII码值小于97的字符存入形参t所指字符数组中，形成一个新串，并统计出符合条件的字符个数作为函数值返回。
例如，形参s所指的字符串为：Abc@1x56*，程序执行后t所指字符数组中的字符串应为：A@156*。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
int fun(char *s, char *t)
{ int n=0;
while(*s)
{ if(*s < 97) {
/**********found**********/
*(t+n)= __1__ ; n++; }
/**********found**********/
__2__ ;
}
*(t+n)=0;
/**********found**********/
return __3__ ;
}
main()
{ char s[81],t[81]; int n;
printf("\nEnter a string:\n"); gets(s);
n=fun(s,t);
printf("\nThere are %d letter which ASCII code is less than 97: %s\n",n,t);
}
给定程序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 <stdio.h>
int fun(double x[], int n)
{
/************found************/
int j, c=0, double xa=0.0;
for (j=0; j<n; j++ )
xa += x[j]/n;
printf("ave =%f\n",xa);
for (j=0; j<n; j++ )
/************found************/
if (x[j] => xa)
c++;
return c;
}
main ( )
{ double x[100] = {193.199, 195.673, 195.757, 196.051, 196.092, 196.596, 196.579, 196.763};
printf("%d\n", fun (x, 8));
}
编写函数fun，其功能是：根据以下公式求P的值，结果由函数值带回。m与n为两个正整数且要求m > n。
m!
P = ───
n!(m-n)!
例如：m＝12，n＝8时，运行结果为495.000000。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
float fun(int m, int n)
{
}
main() /* 主函数 */
{ void NONO ();
printf("P=%f\n", fun (12,8));
NONO();
}
填空题参考答案：
1) *(t+n)= *s ; n++; }
2) s++ ;
3) return n ;
修改题参考答案：
1) int j, c=0; double xa=0.0;
2) if (x[j] >= xa)
程序题参考答案：
float fun(int m, int n)
{
float mj=1,nj=1,mjnj=1;
int i;
for(i=1 ; i<=m ; i++)
mj=mj*i;
for(i=1 ; i<=n ; i++)
nj=nj*i;
for(i=1 ; i<=m-n ; i++)
mjnj=mjnj*i;
return mj/(nj*mjnj);
}
第78套
给定程序中，函数fun的功能是：将形参s所指字符串中的数字字符转换成对应的数值，计算出这些数值的累加和作为函数值返回。
例如，形参s所指的字符串为：abs5def126jkm8，程序执行后的输出结果为：22。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#include <ctype.h>
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("\nEnter a string:\n\n"); gets(s);
n=fun(s);
printf("\nThe result is: %d\n\n",n);
}
给定程序MODI1.C中函数fun的功能是：计算小于形参k的最大的10个能被13
17整除的自然数之和。k的值由主函数传入，若k的值为500，则函数值为4622。
请改正程序中的错误，使程序能输出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
int fun( int k )
{ int m=0, mc=0 ;
while ((k >= 2) && (mc < 10))
{
/************found************/
if ((k%13 = 0) || (k%17 = 0))
{ m = m+ k; mc++; }
k--;
}
return m;
/************found************/
_____
main ( )
{
printf("%d\n", fun (500));
}
编写函数fun，它的功能是：求小于形参n同时能被3与7整除的所有自然数之和的平方根，并作为函数值返回。
例如若n为1000时，程序输出应为：s = 153.909064。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <math.h>
#include <stdio.h>
double fun( int n)
{
}
main() /* 主函数 */
{ void NONO ();
printf("s =%f\n", fun ( 1000) );
NONO();
}
填空题参考答案：
1) if( isdigit(*s) ) sum+= *s- 48 ;
2) s++;
3) return sum ;
修改题参考答案：
1) if ((k%13 == 0) || (k%17 == 0))
2) }
程序题参考答案：
double fun( int n)
{
double sum=0.0;
int i;
for(i=1; i<n; i++)
if((i % 3==0) && (i % 7==0)) sum+=i;
return sqrt(sum) ;
}
第79套
给定程序中，函数fun的功能是：找出形参s所指字符串中出现频率最高的字母（不区分大小写），并统计出其出现的次数。
例如，形参s所指的字符串为：abcAbsmaxless，程序执行后的输出结果为：
letter 'a' : 3 times
letter 's' : 3 times
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#include <ctype.h>
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<k[n]) max= __3__ ;
}
printf("\nAfter count :\n");
for(i=0; i<26;i++)
if (k==max) printf("\nletter \'%c\' : %d times\n",i+'a',k);
}
main()
{ char s[81];
printf("\nEnter a string:\n\n"); gets(s);
fun(s);
}
给定程序MODI1.C中函数 fun 的功能是：求S的值。
s=2^2/(1*3)*4^2/(3*5)*...
例如，当k为10时，函数值应为：1.533852。
请改正程序中的错误，使程序能输出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <math.h>
/************found************/
void fun( int k )
{ int n; double 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("%f\n", fun (10));
}
编写函数fun，它的功能是：计算并输出下列级数和：
1 1 1
S = ── + ── + … + ───
1×2 2×3 n(n+1)
例如，当n = 10时，函数值为：0.909091。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
double fun( int n )
{
}
main() /* 主函数 */
{ void NONO ();
printf("%f\n", fun(10));
NONO();
}
填空题参考答案：
1) ch=tolower(*s);
2) k[n]+= 1 ;
3) if(max<k[n]) max= k[n] ;
修改题参考答案：
1) float fun( int k )
2) return s;
程序题参考答案：
double fun( int n )
{
double s = 0.0 ;
int i ;
for(i = 1 ; i <= n ; i++) s = s + 1.0 / (i * (i + 1)) ;
return s ;
}
第80套
给定程序中，函数fun的功能是：利用指针数组对形参ss所指字符串数组中的字符串按由长到短的顺序排序，并输出排序结果。ss所指字符串数组中共有N个字符串，且串长小于M。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#define N 5
#define M 8
void fun(char (*ss)[M])
{ char *ps[N],*tp; int i,j,k;
for(i=0; i<N; i++) ps=ss;
for(i=0; i<N-1; i++) {
/**********found**********/
k= __1__ ;
for(j=i+1; j<N; j++)
/**********found**********/
if(strlen(ps[k]) < strlen(__2__) ) k=j;
/**********found**********/
tp=ps; ps=ps[k]; ps[k]= __3__ ;
}
printf("\nThe string after sorting by length:\n\n");
for(i=0; i<N; i++) puts(ps);
}
main()
{ char ch[N][M]={"red","green","blue","yellow","black"};
int i;
printf("\nThe original string\n\n");
for(i=0;i<N;i++)puts(ch); printf("\n");
fun(ch);
}
已知一个数列从第0项开始的前三项分别为0，0，1，以后的各项都是其相邻的前三项之和。给定程序MODI1.C中函数fun的功能是:计算并输出该数列前n项的平方根之和。n的值通过形参传入。
例如，当n＝10时，程序的输出结果应为：23.197745。
请改正程序中的错误，使程序能输出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <math.h>
/************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("Input N=");
scanf("%d", &n);
printf("%f\n", fun(n) );
}
编写函数fun，它的功能是计算下列级数和，和值由函数值返回。
s=1+x+x^2/2!+x^3/3!+...+x^n/n!
例如，当n = 10，x＝0.3时，函数值为1.349859。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <math.h>
double fun(double x , int n)
{
}
main()
{ void NONO ();
printf("%f\n", fun(0.3,10));
NONO();
}
填空题参考答案：
1) k= i ;
2) if(strlen(ps[k]) < strlen(ps[j]) ) k=j;
3) tp=ps; ps=ps[k]; ps[k]= tp ;
修改题参考答案：
1) double fun(int n)
2) return sum;
程序题参考答案：
double fun(double x , int n)
{
double s = 1.0, t= 1 ;
int i ;
for(i = 1 ; i <= n ; i++)
{
t=t*x/i;
s += t;
}
return s ;
}
第81套
给定程序中，函数fun的功能是：在形参ss所指字符串数组中查找与形参t所指字符串相同的串，找到后返回该串在字符串数组中的位置（下标值），未找到则返回-1。ss所指字符串数组中共有N个内容不同的字符串，且串长小于M。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#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,t)==0 ) return __2__ ;
return -1;
}
main()
{ char ch[N][M]={"if","while","switch","int","for"},t[M];
int n,i;
printf("\nThe original string\n\n");
for(i=0;i<N;i++)puts(ch); printf("\n");
printf("\nEnter a string for search: "); gets(t);
n=fun(ch,t);
/**********found**********/
if(n== __3__) printf("\nDon't found!\n");
else printf("\nThe position is %d .\n",n);
}
给定程序MODI1.C中函数fun的功能是：从整数1到55之间，选出能被3整除、且有一位上的数是5的那些数,并把这些数放在b所指的数组中，这些数的个数作为函数值返回。规定，函数中a1放个位数，a2放十位数。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
int 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=k; i++; }
}
/************found************/
return k;
}
main( )
{ int a[100],k,m;
m=fun( a );
printf("The result is :\n");
for(k=0; k<m; k++) printf("%4d",a[k]); printf("\n");
}
假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是：将字符串尾部的*号全部删除，前面和中间的*号不删除。
例如，字符串中的内容为：****A*BC*DEF*G*******，删除后,字符串中的内容应当是：****A*BC*DEF*G。在编写函数时，不得使用C语言提供的字符串函数。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun( char *a )
{
}
main()
{ char s[81];void NONO ();
printf("Enter a string:\n");gets(s);
fun( s );
printf("The string after deleted:\n");puts(s);
NONO();
}
填空题参考答案：
1) for(i=0; i< N ; i++)
2) if(strcmp(ss,t)==0 ) return i ;
3) if(n== -1) printf("\nDon't found!\n");
修改题参考答案：
1) a2=k/10;
2) return i;
程序题参考答案：
void fun( char *a )
{
int i;
for(i=0 ; a ; i++)
;
for(i-- ; a=='*' ; i--)
;
a[i+1]=0;
}
第82套
给定程序中，函数fun的功能是:在形参ss所指字符串数组中，删除所有串长超过k的字符串，函数返回所剩字符串的个数。ss所指字符串数组中共有N个字符串，且串长小于M。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#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);
/**********found**********/
if(len<= __2__)
/**********found**********/
strcpy(ss[j++],__3__);
}
return j;
}
main()
{ char x[N][M]={"Beijing","Shanghai","Tianjing","Nanjing","Wuhan"};
int i,f;
printf("\nThe original string\n\n");
for(i=0;i<N;i++)puts(x); printf("\n");
f=fun(x,7);
printf("The string witch length is less than or equal to 7 :\n");
for(i=0; i<f; i++) puts(x);printf("\n");
}
给定程序MODI1.C中函数fun的功能是：逐个比较p、q所指两个字符串对应位置中的字符，把ASCII值大或相等的字符依次存放到c所指数组中，形成一个新的字符串。
例如，若主函数中a字符串为：aBCDeFgH，
主函数中b字符串为：ABcd，
则c中的字符串应为：aBcdeFgH。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
#include <string.h>
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]="aBCDeFgH", b[10]="ABcd", c[80]={'\0'};
fun(a,b,c);
printf("The string a: "); puts(a);
printf("The string b: "); puts(b);
printf("The result : "); puts(c);
}
假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是:除了字符串前导的*号之外,将串中其它*号全部删除。在编写函数时,不得使用C语言提供的字符串函数。函数fun中给出的语句仅供参考。
例如，字符串中的内容为：****A*BC*DEF*G*******，删除后, 字符串中的内容应当是：****ABCDEFG。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun( char *a )
{
/* 以下代码仅供参考 */
int i=0,k;
while(a=='*') i++;
k=i;
while(a!='\0') /* 以下程序段实现非*字符前移 */
{
}
a[k]='\0';
}
main()
{ char s[81];void NONO ();
printf("Enter a string:\n");gets(s);
fun( s );
printf("The string after deleted:\n");puts(s);
NONO();
}
填空题参考答案：
1) for(i=0; i<N ; i++)
2) if(len<= k)
3) strcpy(ss[j++],ss);
修改题参考答案：
1) int k = 0;
2) while( *p || *q )
程序题参考答案：
void fun( char *a )
{
/* 以下代码仅供参考 */
int i=0,k;
while(a=='*') i++;
k=i;
while(a!='\0') /* 以下程序段实现非*字符前移 */
{
if(a != '*') a[k++]=a;
i++;
}
a[k]='\0';
}
第83套
给定程序中，函数fun的功能是:在形参ss所指字符串数组中，查找含有形参substr所指子串的所有字符串并输出，若没找到则输出相应信息。ss所指字符串数组中共有N个字符串，且串长小于M。程序中库函数strstr(s1, s2)的功能是在s1串中查找s2子串，若没有，函数值为0，若有，为非0。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#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, __2__) != NULL )
{ find=1; puts(ss); printf("\n"); }
/**********found**********/
if (find==__3__) printf("\nDon't found!\n");
}
main()
{ char x[N][M]={"BASIC","C langwage","Java","QBASIC","Access"},str[M];
int i;
printf("\nThe original string\n\n");
for(i=0;i<N;i++)puts(x); printf("\n");
printf("\nEnter a string for search : "); gets(str);
fun(x,str);
}
给定程序MODI1.C中函数fun的功能是：求三个数的最小公倍数。
例如，给主函数中的变量x1、x2、x3分别输入15 11 2，
则输出结果应当是：330。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
/************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("Input x1 x2 x3: "); scanf("%d%d%d",&x1,&x2,&x3);
printf("x1=%d, x2=%d, x3=%d \n",x1,x2,x3);
j=fun(x1,x2,x3);
printf("The minimal common multiple is : %d\n",j);
}
假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是：只删除字符串前导和尾部的*号,串中字母之间的*号都不删除。形参n给出了字符串的长度, 形参h给出了字符串中前导*号的个数，形参e给出了字符串中最后*号的个数。在编写函数时，不得使用C语言提供的字符串函数。
例如，字符串中的内容为：****A*BC*DEF*G*******，删除后,字符串中的内容应当是：A*BC*DEF*G。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun( char *a, int n,int h,int e )
{
}
main()
{ char s[81],*t,*f; int m=0, tn=0, fn=0;void NONO ();
printf("Enter a string:\n");gets(s);
t=f=s;
while(*t){t++;m++;}
t--;
while(*t=='*'){t--;tn++;}
while(*f=='*'){f++;fn++;}
fun( s , m,fn,tn );
printf("The string after deleted:\n");puts(s);
NONO();
}
填空题参考答案：
1) for(i=0; i< N ; i++)
2) if( strstr(ss, substr) != NULL )
3) if (find==0) printf("\nDon't found!\n");
修改题参考答案：
1) fun(int x, int y, int z )
2) return j;
程序题参考答案：
void fun( char *a, int n,int h,int e )
{
int i,j=0;
a[n-e]=0;
for(i=h ; a ; i++)
a[j++]=a;
a[j]=0;
}
第84套
给定程序中，函数fun的功能是:在形参ss所指字符串数组中，将所有串长超过k的字符串中右边的字符删除，只保留左边的k个字符。ss所指字符串数组中共有N个字符串，且串长小于M。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
#define N 5
#define M 10
/**********found**********/
void fun(char (*ss) __1__, int k)
{ int i=0 ;
/**********found**********/
while(i< __2__) {
/**********found**********/
ss[k]=__3__; i++; }
}
main()
{ char x[N][M]={"Create","Modify","Sort","skip","Delete"};
int i;
printf("\nThe original string\n\n");
for(i=0;i<N;i++)puts(x); printf("\n");
fun(x,4);
printf("\nThe string after deleted :\n\n");
for(i=0; i<N; i++) puts(x); printf("\n");
}
给定程序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 <math.h>
#include <stdio.h>
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************/
return(s);
}
main()
{ double x;
printf("\nPlease enter a precision: "); scanf("%lf",&x);
printf("\neps=%lf, Pi=%lf\n\n",x,fun(x));
}
假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是：使字符串的前导*号不得多于n个;若多于n个，则删除多余的*号; 若少于或等于n个，则什么也不做,字符串中间和尾部的*号不删除。函数fun中给出的语句仅供参考。
例如，字符串中的内容为：*******A*BC*DEF*G****，若n的值为4，删除后，字符串中的内容应当是：****A*BC*DEF*G****；若n的值为8,则字符串中的内容仍为：*******A*BC*DEF*G****。n的值在主函数中输入。 在编写函数时，不得使用C语言提供的字符串函数。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun( char *a, int n )
{
/* 以下代码仅供参考 */
int i=0,j,k=0;
while(a[k]=='*') k++; /* k为统计*字符个数 */
if(k>n)
{
i=n;j=k;
/* 以下完成将下标为k至串尾的字符前移k-n个位置 */
}
}
main()
{ char s[81]; int n;void NONO ();
printf("Enter a string:\n");gets(s);
printf("Enter n : ");scanf("%d",&n);
fun( s,n );
printf("The string after deleted:\n");puts(s);
NONO();
}
填空题参考答案：
1) void fun(char (*ss) [M], int k)
2) while(i< N) {
3) ss[k]=0; i++; }
修改题参考答案：
1) t=1;
2) return(2*s);
程序题参考答案：
void fun( char *a, int n )
{
/* 以下代码仅供参考 */
int i=0,j,k=0;
while(a[k]=='*') k++; /* k为统计*字符个数 */
if(k>n)
{
i=n;j=k;
/* 以下完成将下标为k至串尾的字符前移k-n个位置 */
for(; a[j] !=0 ; j++)
a[i++]=a[j];
a = 0;
}
}
第85套
程序通过定义学生结构体变量，存储了学生的学号、姓名和3门课的成绩。函数fun的功能是将形参a所指结构体变量中的数据赋给函数中的结构体变量b，并修改b中的学号和姓名，最后输出修改后的数据。例如：a所指变量中的学号、姓名、和三门课的成绩依次是：10001、"ZhangSan"、95、80、88，则修改后输出b中的数据应为：10002、"LiSi"、95、80、88。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
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__, "LiSi");
printf("\nThe data after modified :\n");
printf("\nNo: %ld Name: %s\nScores: ",b.sno, b.name);
/**********found**********/
for (i=0; i<3; i++) printf("%6.2f ", b.__3__);
printf("\n");
}
main()
{ struct student s={10001,"ZhangSan", 95, 80, 88};
int i;
printf("\n\nThe original data :\n");
printf("\nNo: %ld Name: %s\nScores: ",s.sno, s.name);
for (i=0; i<3; i++) printf("%6.2f ", s.score);
printf("\n");
fun(s);
}
给定程序MODI1.C中函数fun的功能是：从s所指字符串中删除所有小写字母c。
请改正程序中的错误，使它能计算出正确的结果。
注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
void fun( char *s )
{ int i,j;
for(i=j=0; s!='\0'; i++)
if(s!='c')
/************found************/
s[j]=s;
/************found************/
s='\0';
}
main()
{ char s[80];
printf("Enter a string: "); gets(s);
printf("The original string: "); puts(s);
fun(s);
printf("The string after deleted : "); puts(s);printf("\n\n");
}
假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是：将字符串中的前导*号全部移到字符串的尾部。函数fun中给出的语句仅供参考。
例如，字符串中的内容为：*******A*BC*DEF*G****，移动后,字符串中的内容应当是：A*BC*DEF*G***********。在编写函数时, 不得使用C语言提供的字符串函数。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun( char *a )
{
/* 以下代码仅供参考 */
char *p,*q;
int n=0;
p=a;
while(*p=='*') /* 统计串头'*'个数n */
{n++; p++;}
q=a;
/* 向前复制字符串，请填写相应的语句完成其功能 */
for(;n>0;n--) /* 在串尾补n个'*' */
*q++='*';
*q='\0';
}
main()
{ char s[81]; int n=0; void NONO ();
printf("Enter a string:\n");gets(s);
fun( s );
printf("The string after moveing:\n");puts(s);
NONO();
}
填空题参考答案：
1) b = a;
2) strcpy(b.name, "LiSi");
3) for (i=0; i<3; i++) printf("%6.2f ", b.score);
修改题参考答案：
1) s[j++]=s;
2) s[j]='\0';
程序题参考答案：
void fun( char *a )
{
/* 以下代码仅供参考 */
char *p,*q;
int n=0;
p=a;
while(*p=='*') /* 统计串头'*'个数n */
{n++; p++;}
q=a;
/* 向前复制字符串，请填写相应的语句完成其功能 */
while(*p) {
*q=*p;
p++;q++;
}
for(;n>0;n--) /* 在串尾补n个'*' */
*q++='*';
*q='\0';
}
第86套
程序通过定义学生结构体变量，存储了学生的学号、姓名和3门课的成绩。函数fun的功能是对形参b所指结构体变量中的数据进行修改,最后在主函数中输出修改后的数据。
例如: b所指变量t中的学号、姓名、和三门课的成绩依次是: 10002、"ZhangQi"、93、85、87，修改后输出t中的数据应为：10004、" LiJie "、93、85、87。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
struct student {
long sno;
char name[10];
float score[3];
};
void fun( struct student *b)
{
/**********found**********/
b__1__ = 10004;
/**********found**********/
strcpy(b__2__, "LiJie");
}
main()
{ struct student t={10002,"ZhangQi", 93, 85, 87};
int i;
printf("\n\nThe original data :\n");
printf("\nNo: %ld Name: %s\nScores: ",t.sno, t.name);
for (i=0; i<3; i++) printf("%6.2f ", t.score);
printf("\n");
/**********found**********/
fun(__3__);
printf("\nThe data after modified :\n");
printf("\nNo: %ld Name: %s\nScores: ",t.sno, t.name);
for (i=0; i<3; i++) printf("%6.2f ", t.score);
printf("\n");
}
给定程序MODI1.C中函数fun的功能是：应用递归算法求形参a的平方根。求平方根的迭代公式如下：
1 a
x1 = ─ ( x0 + ─ )
2 x0
例如，a为2时，平方根值为：1.414214。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
#include <math.h>
/**********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;
printf("Enter x: "); scanf("%lf",&x);
printf("The square root of %lf is %lf\n",x,fun(x,1.0));
}
学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中, 请编写函数fun，它的功能是：把高于等于平均分的学生数据放在b所指的数组中，高于等于平均分的学生人数通过形参n传回，平均分通过函数值返回。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#define N 12
typedef struct
{ char num[10];
double s;
} STREC;
double fun( STREC *a, STREC *b, int *n )
{
}
main()
{ STREC s[N]={{"GA05",85},{"GA03",76},{"GA02",69},{"GA04",85},
{"GA01",91},{"GA07",72},{"GA08",64},{"GA06",87},
{"GA09",60},{"GA11",79},{"GA12",73},{"GA10",90}};
STREC h[N], t;FILE *out ;
int i,j,n; double ave;
ave=fun( s,h,&n );
printf("The %d student data which is higher than %7.3f:\n",n,ave);
for(i=0;i<n; i++)
printf("%s %4.1f\n",h.num,h.s);
printf("\n");
out = fopen("out.dat","w") ;
fprintf(out, "%d\n%7.3f\n", n, ave);
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(h.s<h[j].s) {t=h ;h=h[j]; h[j]=t;}
for(i=0;i<n; i++)
fprintf(out,"%4.1f\n",h.s);
fclose(out);
}
填空题参考答案：
1) b->sno = 10004;
2) strcpy(b->name, "LiJie");
3) fun(&t);
修改题参考答案：
1) double fun(double a, double x0)
2) if( fabs(x1-x0)>0.00001 )
程序题参考答案：
double fun( STREC *a, STREC *b, int *n )
{
double t=0 ;
int i,j=0;
for(i = 0 ; i < N ; i++) t = t + a.s ;
t = t / N ;
for(i = 0 ; i < N ; i++) if(a.s >= t) b[j++] = a ;
*n=j;
return t ;
}
第87套
程序通过定义学生结构体变量，存储了学生的学号、姓名和3门课的成绩。函数fun的功能是将形参a中的数据进行修改,把修改后的数据作为函数值返回主函数进行输出。
例如：传给形参a的数据中，学号、姓名、和三门课的成绩依次是：10001、"ZhangSan"、95、80、88，修改后的数据应为：10002、"LiSi"、96、81、89。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
struct student {
long sno;
char name[10];
float score[3];
};
/**********found**********/
__1__ fun(struct student a)
{ int i;
a.sno = 10002;
/**********found**********/
strcpy(__2__, "LiSi");
/**********found**********/
for (i=0; i<3; i++) __3__+= 1;
return a;
}
main()
{ struct student s={10001,"ZhangSan", 95, 80, 88}, t;
int i;
printf("\n\nThe original data :\n");
printf("\nNo: %ld Name: %s\nScores: ",s.sno, s.name);
for (i=0; i<3; i++) printf("%6.2f ", s.score);
printf("\n");
t = fun(s);
printf("\nThe data after modified :\n");
printf("\nNo: %ld Name: %s\nScores: ",t.sno, t.name);
for (i=0; i<3; i++) printf("%6.2f ", t.score);
printf("\n");
}
假定整数数列中的数不重复，并存放在数组中。给定程序MODI1.C中函数fun的功能是：删除数列中值为x的元素。n中存放的是数列中元素的个数。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
#define N 20
int fun(int *a,int n,int x)
{ int p=0,i;
a[n]=x;
while( x!=a
)
p=p+1;
/**********found**********/
if(P==n) return -1;
else
{ for(i=p;i<n-1;i++)
/**********found**********/
a[i+1]=a;
return n-1;
}
}
main()
{ int w[N]={-3,0,1,5,7,99,10,15,30,90},x,n,i;
n=10;
printf("The original data :\n");
for(i=0;i<n;i++) printf("%5d",w);
printf("\nInput x (to delete): "); scanf("%d",&x);
printf("Delete : %d\n",x);
n=fun(w,n,x);
if ( n==-1 ) printf("***Not be found!***\n\n");
else
{ printf("The data after deleted:\n");
for(i=0;i<n;i++) printf("%5d",w);printf("\n\n");
}
}
学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中, 请编写函数fun，它的功能是：把分数最低的学生数据放在b所指的数组中，注意：分数最低的学生可能不止一个，函数返回分数最低的学生的人数。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#define N 16
typedef struct
{ char num[10];
int s;
} STREC;
int fun( STREC *a, STREC *b )
{
}
main()
{ STREC s[N]={{"GA05",85},{"GA03",76},{"GA02",69},{"GA04",85},
{"GA01",91},{"GA07",72},{"GA08",64},{"GA06",87},
{"GA015",85},{"GA013",91},{"GA012",64},{"GA014",91},
{"GA011",91},{"GA017",64},{"GA018",64},{"GA016",72}};
STREC h[N];
int i,n;FILE *out ;
n=fun( s,h );
printf("The %d lowest score :\n",n);
for(i=0;i<n; i++)
printf("%s %4d\n",h.num,h.s);
printf("\n");
out = fopen("out.dat","w") ;
fprintf(out, "%d\n",n);
for(i=0;i<n; i++)
fprintf(out, "%4d\n",h.s);
fclose(out);
}
填空题参考答案：
1) struct student fun(struct student a)
2) strcpy(a.name, "LiSi");
3) for (i=0; i<3; i++) a.score+= 1;
修改题参考答案：
1) if(p==n) return -1;
2) a=a[i+1];
程序题参考答案：
int fun( STREC *a, STREC *b )
{
int i, j = 0, min=a[0].s ;
for(i = 0 ; i < N; i++)
if(min > a.s)
{
j = 0 ; min = a.s ;
}
for(i = 0 ; i < N; i++)
if(min == a.s)
b[j++] = a ;
return j ;
}
第88套
程序通过定义学生结构体变量，存储了学生的学号、姓名和3门课的成绩。函数fun的功能是将形参a所指结构体变量s中的数据进行修改,并把a中地址作为函数值返回主函数，在主函数中输出修改后的数据。
例如：a所指变量s中的学号、姓名、和三门课的成绩依次是：10001、" ZhangSan "、95、80、88，修改后输出t中的数据应为：10002、"LiSi "、96、81、89。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
struct student {
long sno;
char name[10];
float score[3];
};
/**********found**********/
__1__ fun(struct student *a)
{ int i;
a->sno = 10002;
strcpy(a->name, "LiSi");
/**********found**********/
for (i=0; i<3; i++) __2__ += 1;
/**********found**********/
return __3__ ;
}
main()
{ struct student s={10001,"ZhangSan", 95, 80, 88}, *t;
int i;
printf("\n\nThe original data :\n");
printf("\nNo: %ld Name: %s\nScores: ",s.sno, s.name);
for (i=0; i<3; i++) printf("%6.2f ", s.score);
printf("\n");
t = fun(&s);
printf("\nThe data after modified :\n");
printf("\nNo: %ld Name: %s\nScores: ",t->sno, t->name);
for (i=0; i<3; i++) printf("%6.2f ", t->score);
printf("\n");
}
给定程序MODI1.C中函数fun的功能是：从N个字符串中找出最长的那个串,并将其地址作为函数值返回。各字符串在主函数中输入,并放入一个字符串数组中。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
#include <string.h>
#define N 5
#define M 81
/**********found**********/
fun(char (*sq)[M])
{ int i; char *sp;
sp=sq[0];
for(i=0;i<N;i++)
if(strlen( sp)<strlen(sq))
sp=sq ;
/**********found**********/
return sq;
}
main()
{ char str[N][M], *longest; int i;
printf("Enter %d lines :\n",N);
for(i=0; i<N; i++) gets(str);
printf("\nThe N string :\n",N);
for(i=0; i<N; i++) puts(str);
longest=fun(str);
printf("\nThe longest string :\n"); puts(longest);
}
函数fun的功能是：将a、b中的两个两位正整数合并形成一个新的整数放在c中。合并的方式是:将a中的十位和个位数依次放在变量c的百位和个位上，b中的十位和个位数依次放在变量c的十位和千位上。
例如，当a＝45，b=12。调用该函数后，c=2415。
注意: 部分源程序存在文件PROG1.C中。数据文件IN.DAT中的数据不得修改。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun(int a, int b, long *c)
{
}
main()
{ int a,b; long c; void NONO ();
printf("Input a, b:");
scanf("%d%d", &a, &b);
fun(a, b, &c);
printf("The result is: %ld\n", c);
NONO();
}
填空题参考答案：
1) struct student * fun(struct student *a)
2) for (i=0; i<3; i++) a->score += 1;
3) return a ;
修改题参考答案：
1) char *fun(char (*sq)[M])
2) return sp;
程序题参考答案：
void fun(int a, int b, long *c)
{
*c = (b%10)*1000+(a/10)*100+(b/10)*10+a%10;
}
第89套
程序通过定义学生结构体数组，存储了若干名学生的学号、姓名和3门课的成绩。函数fun的功能是将存放学生数据的结构体数组，按照姓名的字典序（从小到大）排序。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <string.h>
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<n; j++)
/**********found**********/
if (strcmp(__3__) > 0)
{ t = a; a = a[j]; a[j] = t; }
}
main()
{ struct student s[4]={{10001,"ZhangSan", 95, 80, 88},{10002,"LiSi", 85, 70, 78},
{10003,"CaoKai", 75, 60, 88}, {10004,"FangFang", 90, 82, 87}};
int i, j;
printf("\n\nThe original data :\n\n");
for (j=0; j<4; j++)
{ printf("\nNo: %ld Name: %-8s Scores: ",s[j].sno, s[j].name);
for (i=0; i<3; i++) printf("%6.2f ", s[j].score);
printf("\n");
}
fun(s, 4);
printf("\n\nThe data after sorting :\n\n");
for (j=0; j<4; j++)
{ printf("\nNo: %ld Name: %-8s Scores: ",s[j].sno, s[j].name);
for (i=0; i<3; i++) printf("%6.2f ", s[j].score);
printf("\n");
}
}
给定程序MODI1.C中函数fun的功能是：在p所指字符串中找出ASCII码值最大的字符，将其放在第一个位置上；并将该字符前的原字符向后顺序移动。
例如，调用fun函数之前给字符串输入：ABCDeFGH，
调用后字符串中的内容为：eABCDFGH。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
void fun( char *p )
{ char max,*q; int i=0;
max=p;
while( p!=0 )
{ if( max<p )
{ max=p;
/**********found**********/
q=p+i
}
i++;
}
/**********found**********/
wihle( q>p )
{ *q=*(q-1);
q--;
}
p[0]=max;
}
main()
{ char str[80];
printf("Enter a string: "); gets(str);
printf("\nThe original string: "); puts(str);
fun(str);
printf("\nThe string after moving: "); puts(str); printf("\n\n");
}
学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中, 请编写函数fun，它的功能是：把指定分数范围内的学生数据放在b所指的数组中，分数范围内的学生人数由函数值返回。
例如，输入的分数是60 69, 则应当把分数在60到69的学生数据进行输出，包含60分和69分的学生数据。主函数中将把60放在low中，把69放在heigh中。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#define N 16
typedef struct
{ char num[10];
int s;
} STREC;
int fun( STREC *a,STREC *b,int l, int h )
{
}
main()
{ STREC s[N]={{"GA005",85},{"GA003",76},{"GA002",69},{"GA004",85},
{"GA001",96},{"GA007",72},{"GA008",64},{"GA006",87},
{"GA015",85},{"GA013",94},{"GA012",64},{"GA014",91},
{"GA011",90},{"GA017",64},{"GA018",64},{"GA016",72}};
STREC h[N],tt;FILE *out ;
int i,j,n,low,heigh,t;
printf("Enter 2 integer number low & heigh : ");
scanf("%d%d", &low,&heigh);
if ( heigh< low ){ t=heigh;heigh=low;low=t; }
n=fun( s,h,low,heigh );
printf("The student's data between %d--%d :\n",low,heigh);
for(i=0;i<n; i++)
printf("%s %4d\n",h.num,h.s);
printf("\n");
out = fopen("out.dat","w") ;
n=fun( s,h,80,98 );
fprintf(out,"%d\n",n);
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(h.s>h[j].s) {tt=h ;h=h[j]; h[j]=tt;}
for(i=0;i<n; i++)
fprintf(out,"%4d\n",h.s);
fprintf(out,"\n");
fclose(out);
}
填空题参考答案：
1) struct student t;
2) for (i=0; i<n-1; i++)
3) if (strcmp(a.name,a[j].name) > 0)
修改题参考答案：
1) q=p+i;
2) while( q>p )
程序题参考答案：
int fun( STREC *a,STREC *b,int l, int h )
{
int i,j = 0 ;
for(i = 0 ; i < N ; i++)
if(a.s >= l && a.s <= h) b[j++] = a ;
return j ;
}
第90套
程序通过定义学生结构体变量,存储了学生的学号、姓名和3门课的成绩。所有学生数据均以二进制方式输出到student.dat文件中。函数fun的功能是从指定文件中找出指定学号的学生数据，读入此学生数据，对该生的分数进行修改，使每门课的分数加3分,修改后重写文件中该学生的数据，即用该学生的新数据覆盖原数据，其它学生数据不变；若找不到，则什么都不做。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#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,"rb+");
/**********found**********/
while (!feof(__1__))
{ fread(&n, sizeof(STU), 1, fp);
/**********found**********/
if (n.sno__2__sno) break;
}
if (!feof(fp))
{ for (i=0; i<3; i++) n.score += 3;
/**********found**********/
fseek(__3__, -(long)sizeof(STU), SEEK_CUR);
fwrite(&n, sizeof(STU), 1, fp);
}
fclose(fp);
}
main()
{ STU t[N]={ {10001,"MaChao", 91, 92, 77}, {10002,"CaoKai", 75, 60, 88},
{10003,"LiSi", 85, 70, 78}, {10004,"FangFang", 90, 82, 87},
{10005,"ZhangSan", 95, 80, 88}}, ss[N];
int i,j; FILE *fp;
fp = fopen("student.dat", "wb");
fwrite(t, sizeof(STU), N, fp);
fclose(fp);
printf("\nThe original data :\n");
fp = fopen("student.dat", "rb");
fread(ss, sizeof(STU), N, fp);
fclose(fp);
for (j=0; j<N; j++)
{ printf("\nNo: %ld Name: %-8s Scores: ",ss[j].sno, ss[j].name);
for (i=0; i<3; i++) printf("%6.2f ", ss[j].score);
printf("\n");
}
fun("student.dat", 10003);
fp = fopen("student.dat", "rb");
fread(ss, sizeof(STU), N, fp);
fclose(fp);
printf("\nThe data after modifing :\n");
for (j=0; j<N; j++)
{ printf("\nNo: %ld Name: %-8s Scores: ",ss[j].sno, ss[j].name);
for (i=0; i<3; i++) printf("%6.2f ", ss[j].score);
printf("\n");
}
}
给定程序MODI1.C中函数fun的功能是：利用插入排序法对字符串中的字符按从小到大的顺序进行排序。插入法的基本算法是：先对字符串中的头两个元素进行排序。然后把第三个字符插入到前两个字符中，插入后前三个字符依然有序；再把第四个字符插入到前三个字符中,……。待排序的字符串已在主函数中赋予。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include <stdio.h>
#include <string.h>
#define N 80
void insert(char *aa)
{ int i,j,n; char ch;
/**********found**********/
n=strlen[ aa ];
for( i=1; i<n ;i++ ) {
/**********found**********/
c=aa;
j=i-1;
while ((j>=0) && ( ch<aa[j] ))
{ aa[j+1]=aa[j];
j--;
}
aa[j+1]=ch;
}
}
main( )
{ char a[N]="QWERTYUIOPASDFGHJKLMNBVCXZ";
printf ("The original string : %s\n", a);
insert(a) ;
printf("The string after sorting : %s\n\n",a );
}
N名学生的成绩已在主函数中放入一个带头节点的链表结构中,h指向链表的头节点。请编写函数fun，它的功能是：找出学生的最高分，由函数值返回。
注意: 部分源程序在文件PROG1.C文件中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <stdlib.h>
#define N 8
struct slist
{ double s;
struct slist *next;
};
typedef struct slist STREC;
double fun( STREC *h )
{
}
STREC * creat( double *s)
{ STREC *h,*p,*q; int i=0;
h=p=(STREC*)malloc(sizeof(STREC));p->s=0;
while(i<N)
{ q=(STREC*)malloc(sizeof(STREC));
q->s=s; i++; p->next=q; p=q;
}
p->next=0;
return h;
}
outlist( STREC *h)
{ STREC *p;
p=h->next; printf("head");
do
{ printf("->%2.0f",p->s);p=p->next;}
while(p!=0);
printf("\n\n");
}
main()
{ double s[N]={85,76,69,85,91,72,64,87}, max;void NONO ();
STREC *h;
h=creat( s ); outlist(h);
max=fun( h );
printf("max=%6.1f\n",max);
NONO();
}
填空题参考答案：
1) while (!feof(fp))
2) if (n.sno==sno) break;
3) fseek(fp, -(long)sizeof(STU), SEEK_CUR);
修改题参考答案：
1) n=strlen( aa );
2) ch=aa;
程序题参考答案：
double fun( STREC *h )
{
double max=h->s;
STREC *p;
p=h->next;
while(p!=NULL)
{ if(p->s>max )
max=p->s;
p=p->next;
}
return max;
}
第91套
给定程序中, 函数fun的功能是用函数指针指向要调用的函数,并进行调用。规定在__2__处使f指向函数f1，在__3__处使f指向函数f2。当调用正确时，程序输出:
x1=5.000000, x2=3.000000, x1*x1+x1*x2=40.000000
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
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)();
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("\nx1=%f, x2=%f, x1*x1+x1*x2=%f\n",x1, x2, r);
}
给定程序MODI1.C是建立一个带头结点的单向链表,并用随机函数为各结点赋值。函数fun的功能是将单向链表结点 (不包括头结点)数据域为偶数的值累加起来, 并且作为函数值返回。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
#include <stdlib.h>
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;
}
return sum;
}
NODE *creatlink(int n)
{ NODE *h, *p, *s;
int i;
h=p=(NODE *)malloc(sizeof(NODE));
for(i=1; i<=n; i++)
{ s=(NODE *)malloc(sizeof(NODE));
s->data=rand()%16;
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 ,"\n\nTHE LIST :\n\n HEAD " );
while(p)
{ fprintf(pf ,"->%d ",p->data ); p=p->next; }
fprintf (pf,"\n");
}
outresult(int s, FILE *pf)
{ fprintf(pf,"\nThe sum of even numbers : %d\n",s);}
main()
{ NODE *head; int even;
head=creatlink(12);
head->data=9000;
outlink(head , stdout);
even=fun(head);
printf("\nThe result :\n"); outresult(even, stdout);
}
请编写函数fun, 函数的功能是: 判断字符串是否为回文?若是, 函数返回1，主函数中输出: YES, 否则返回0, 主函数中输出NO。回文是指顺读和倒读都一样的字符串。
例如, 字符串LEVEL是回文, 而字符串123312就不是回文。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
#define N 80
int fun(char *str)
{
}
main()
{ char s[N] ;void NONO ();
printf("Enter a string: ") ; gets(s) ;
printf("\n\n") ; puts(s) ;
if(fun(s)) printf(" YES\n") ;
else printf(" NO\n") ;
NONO() ;
}
填空题参考答案：
1) double (*f)();
2) f = f1 ; /* point fountion f1 */
3) f = f2 ; /* point fountion f2 */
修改题参考答案：
1) p=h->next;
2) p=p->next;
程序题参考答案：
int fun(char *str)
{
int i ;
for(i = 0,j = strlen(str)-1 ; i < j; i++,j--)
if(str != str[j]) return 0 ;
return 1 ;
}
第92套
给定程序中,函数fun的功能是将带头节点的单向链表结点数据域中的数据从小到大排序。即若原链表结点数据域从头至尾的数据为：10、4、2、8、6，排序后链表结点数据域从头至尾的数据为：2、4、6、8、10。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <stdlib.h>
#define N 6
typedef struct node {
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<N; i++)
{ q=(NODE *)malloc(sizeof(NODE));
q->data=a;
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("The list is NULL!\n");
else
{ printf("\nHead ");
do
{ printf("->%d", p->data); p=p->next; }
while(p!=NULL);
printf("->End\n");
}
}
main()
{ NODE *head;
int a[N]= {0, 10, 4, 2, 8, 6 };
head=creatlist(a);
printf("\nThe original list:\n");
outlist(head);
fun(head);
printf("\nThe list after sorting :\n");
outlist(head);
}
给定程序MODI1.C是建立一个带头结点的单向链表, 并用随机函数为各结点数据域赋值。函数fun的作用是求出单向链表结点(不包括头结点)数据域中的最大值,并且作为函数值返回。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
#include <stdlib.h>
typedef struct aa
{ int data;
struct aa *next;
} NODE;
int 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,"\nThe max in link : %d\n",s);}
NODE *creatlink(int n, int m)
{ NODE *h, *p, *s;
int i;
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,"\nTHE LIST :\n\n HEAD ");
while(p)
{ fprintf(pf,"->%d ",p->data); p=p->next; }
fprintf(pf,"\n");
}
main()
{ NODE *head; int m;
head=creatlink(12, 100);
outlink(head , stdout);
m=fun(head);
printf("\nTHE RESULT :\n"); outresult(m, stdout);
}
请编写函数fun, 函数的功能是: 将M行N列的二维数组中的数据,按行的顺序依次放到一维数组中, 一维数组中数据的个数存放在形参n所指的存储单元中。
例如, 二维数组中的数据为:
33 33 33 33
44 44 44 44
55 55 55 55
则一维数组中的内容应是:
33 33 33 33 44 44 44 44 55 55 55 55。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun(int (*s)[10], int *b, int *n, int mm, int nn)
{
}
main()
{ int w[10][10] = {{33,33,33,33},{44,44,44,44},{55,55,55,55}},i,j ;
int a[100] = {0}, n = 0 ;void NONO ();
printf("The matrix:\n") ;
for(i = 0 ; i < 3 ; i++)
{ for(j = 0 ; j < 4 ; j++) printf("%3d",w[j]) ;
printf("\n") ;
}
fun(w, a, &n, 3, 4) ;
printf("The A array:\n") ;
for(i = 0 ; i < n ; i++) printf("%3d",a);printf("\n\n") ;
NONO() ;
}
填空题参考答案：
1) p = h->next ;
2) q = p->next ;
3) if (p->data >= q->data)
修改题参考答案：
1) p=h->next;
2) p=p->next ;
程序题参考答案：
void fun(int (*s)[10], int *b, int *n, int mm, int nn)
{
int i, j, k=0 ;
for(i = 0 ; i < mm ; i++)
for(j = 0 ; j < nn ; j++)
b[k++] = s[j] ;
*n = k ;
}
第93套
给定程序中，函数fun的功能是将不带头结点的单向链表逆置。即若原链表中从头至尾结点数据域依次为:2、4、6、8、10，逆置后，从头至尾结点数据域依次为：10、8、6、4、2。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef struct node {
int data;
struct node *next;
} NODE;
/**********found**********/
__1__ * fun(NODE *h)
{ NODE *p, *q, *r;
p = h;
if (p == NULL)
return NULL;
q = p->next;
p->next = NULL;
while (q)
{
/**********found**********/
r = q->__2__;
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<N; i++)
{ q=(NODE *)malloc(sizeof(NODE));
q->data=a;
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("The list is NULL!\n");
else
{ printf("\nHead ");
do
{ printf("->%d", p->data); p=p->next; }
while(p!=NULL);
printf("->End\n");
}
}
main()
{ NODE *head;
int a[N]={2,4,6,8,10};
head=creatlist(a);
printf("\nThe original list:\n");
outlist(head);
head=fun(head);
printf("\nThe list after inverting :\n");
outlist(head);
}
给定程序MODI1.C中函数fun的功能是: 将s所指字符串中位于奇数位置的字符或ASCII码为偶数的字符放入t所指数组中(规定第一个字符放在第0位中)。
例如, 字符串中的数据为: AABBCCDDEEFF,
则输出应当是：ABBCDDEFF。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
#include <string.h>
#define N 80
void fun(char *s, char t[])
{ int i, j=0;
for(i=0; i<(int)strlen(s); i++)
/***********found**********/
if(i%2 && s%2==0)
t[j++]=s;
/***********found**********/
t='\0';
}
main()
{ char s[N], t[N];
printf("\nPlease enter string s : "); gets(s);
fun(s, t);
printf("\nThe result is : %s\n",t);
}
请编写函数fun, 函数的功能是: 将M行N列的二维数组中的数据, 按列的顺序依次放到一维数组中。函数fun中给出的语句仅供参考。
例如, 二维数组中的数据为:
33 33 33 33
44 44 44 44
55 55 55 55
则一维数组中的内容应是:
33 44 55 33 44 55 33 44 55 33 44 55。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
void fun(int s[][10], int b[], int *n, int mm, int nn)
{
/* 以下代码仅供参考 */
int i,j,np=0; /* np用作b数组下标 */
*n=np;
}
main()
{ int w[10][10]={{33,33,33,33},{44,44,44,44},{55,55,55,55}},i,j;
int a[100]={0}, n=0;void NONO ();
printf("The matrix:\n");
for(i=0; i<3; i++)
{ for(j=0;j<4; j++)printf("%3d",w[j]);
printf("\n");
}
fun(w,a,&n,3,4);
printf("The A array:\n");
for(i=0;i<n;i++)printf("%3d",a);printf("\n\n");
NONO();
}
填空题参考答案：
1) NODE * fun(NODE *h)
2) r = q->next;
3) q = r ;
修改题参考答案：
1) if(i%2 || s%2==0)
2) t[j]=0;
程序题参考答案：
void fun(int (*s)[10], int *b, int *n, int mm, int nn)
{
/* 以下代码仅供参考 */
int i,j,np=0; /* np用作b数组下标 */
for(i = 0 ; i < nn ; i++)
for(j = 0 ; j < mm ; j++)
b[np++] = s[j] ;
*n=np;
}
第94套
给定程序中，函数fun的功能是将带头结点的单向链表逆置。即若原链表中从头至尾结点数据域依次为:2、4、6、8、10,逆置后，从头至尾结点数据域依次为:10、8、6、4、2。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef struct node {
int data;
struct node *next;
} NODE;
void fun(NODE *h)
{ NODE *p, *q, *r;
/**********found**********/
p = h->__1__;
/**********found**********/
if (p==__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<N; i++)
{ q=(NODE *)malloc(sizeof(NODE));
q->data=a;
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("The list is NULL!\n");
else
{ printf("\nHead ");
do
{ printf("->%d", p->data); p=p->next; }
while(p!=NULL);
printf("->End\n");
}
}
main()
{ NODE *head;
int a[N]={2,4,6,8,10};
head=creatlist(a);
printf("\nThe original list:\n");
outlist(head);
fun(head);
printf("\nThe list after inverting :\n");
outlist(head);
}
给定程序MODI1.C中函数fun的功能是: 计算s所指字符串中含有t所指字符串的数目, 并作为函数值返回。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
#include <string.h>
#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= 0)
n++;
s++;
}
return n;
}
main()
{ char a[N],b[N]; int m;
printf("\nPlease enter string a : "); gets(a);
printf("\nPlease enter substring b : "); gets( b );
m=fun(a, b);
printf("\nThe result is : m = %d\n",m);
}
请编写函数fun, 函数的功能是: 将放在字符串数组中的M个字符串(每串的长度不超过N), 按顺序合并组成一个新的字符串。函数fun中给出的语句仅供参考。
例如, 字符串数组中的M个字符串为
AAAA
BBBBBBB
CC
则合并后的字符串的内容应是: AAAABBBBBBBCC。
提示：strcat(a,b)的功能是将字符串b复制到字符串a的串尾上，成为一个新串。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
#define M 3
#define N 20
void fun(char a[M][N], char *b)
{
/* 以下代码仅供参考 */
int i; *b=0;
}
main()
{ char w[M][N]={"AAAA","BBBBBBB","CC"}, a[100];
int i ;void NONO ();
printf("The string:\n");
for(i=0; i<M; i++)puts(w);
printf("\n");
fun(w,a);
printf("The A string:\n");
printf("%s",a);printf("\n\n");
NONO();
}
填空题参考答案：
1) p = h->next;
2) if (p==0) return;
3) p = q; q = r;
修改题参考答案：
1) r=t;
2) if(*r== 0)
程序题参考答案：
void fun(char a[M][N], char *b)
{
/* 以下代码仅供参考 */
int i; *b=0;
for(i = 0 ; i < M ; i++)
strcat(b, a) ;
}
第95套
给定程序中,函数fun的功能是将不带头节点的单向链表结点数据域中的数据从小到大排序。即若原链表结点数据域从头至尾的数据为：10、4、2、8、6，排序后链表结点数据域从头至尾的数据为：2、4、6、8、10。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <stdlib.h>
#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;
}
/**********found**********/
p = __3__ ;
}
}
NODE *creatlist(int a[])
{ NODE *h,*p,*q; int i;
h=NULL;
for(i=0; i<N; i++)
{ q=(NODE *)malloc(sizeof(NODE));
q->data=a;
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("The list is NULL!\n");
else
{ printf("\nHead ");
do
{ printf("->%d", p->data); p=p->next; }
while(p!=NULL);
printf("->End\n");
}
}
main()
{ NODE *head;
int a[N]= {0, 10, 4, 2, 8, 6 };
head=creatlist(a);
printf("\nThe original list:\n");
outlist(head);
fun(head);
printf("\nThe list after inverting :\n");
outlist(head);
}
给定程序MODI1.C中函数fun的功能是: 将s所指字符串中的字母转换为按字母序列的后续字母(但Z转换为A, z转换为a),其它字符不变。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
#include <ctype.h>
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("\n Enter a string with length < 80. :\n\n "); gets(s);
printf("\n The string : \n\n "); puts(s);
fun ( s );
printf ("\n\n The Cords :\n\n "); puts(s);
}
请编写函数fun, 函数的功能是: 移动一维数组中的内容; 若数组中有n个整数, 要求把下标从0到p(含p,p小于等于n-1)的数组元素平移到数组的最后。
例如, 一维数组中的原始内容为: 1,2,3,4,5,6,7,8,9,10; p的值为3。移动后, 一维数组中的内容应为: 5,6,7,8,9,10,1,2,3,4。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#define N 80
void fun(int *w, int p, int n)
{
}
main()
{ int a[N]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
int i,p,n=15;void NONO ();
printf("The original data:\n");
for(i=0; i<n; i++)printf("%3d",a);
printf("\n\nEnter p: ");scanf("%d",&p);
fun(a,p,n);
printf("\nThe data after moving:\n");
for(i=0; i<n; i++)printf("%3d",a);
printf("\n\n");
NONO();
}
填空题参考答案：
1) q = p->next ;
2) while (q)
3) p = p->next ;
修改题参考答案：
1) while(*s)
2) s++;
程序题参考答案：
void fun(int *w, int p, int n)
{
int i, j = 0, b[N] ;
for(i = p + 1 ; i < n ; i++) b[j++] = w ;
for(i = 0 ; i <= p ; i++) b[j++] = w ;
for(i = 0 ; i < n ; i++) w= b ;
}
第96套
给定程序中，函数fun的功能是根据形参i的值返回某个函数的值。当调用正确时, 程序输出：
x1=5.000000, x2=3.000000, x1*x1+x1*x2=40.000000
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
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("\nx1=%f, x2=%f, x1*x1+x1*x2=%f\n\n",x1, x2, r);
}
给定程序MODI1.C中函数fun的功能是: 比较两个字符串，将长的那个字符串的首地址作为函数值返回。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
/**********found**********/
char fun(char *s, char *t)
{ int sl=0,tl=0; char *ss, *tt;
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];
printf("\nEnter a string : "); gets(a);
printf("\nEnter a string again : "); gets(b);
printf("\nThe longer is :\n\n\"%s\"\n",fun(a,b));
}
请编写函数fun,函数的功能是: 移动字符串中的内容,移动的规则如下: 把第1到第m个字符, 平移到字符串的最后, 把第m+1到最后的字符移到字符串的前部。
例如, 字符串中原有的内容为: ABCDEFGHIJK, m的值为3, 则移动后, 字符串中的内容应该是: DEFGHIJKABC。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
#define N 80
void fun1(char *w) /* 本函数的功能是将字符串中字符循环左移一个位置 */
{
int i; char t;
t=w[0];
for(i=0;i<(int)strlen(w)-1;i++)
w=w[i+1];
w[strlen(w)-1]=t;
}
void fun(char *w, int m) /* 可调用fun1函数左移字符 */
{
}
main()
{ char a[N]= "ABCDEFGHIJK";
int m;void NONO ();
printf("The original string:\n");puts(a);
printf("\n\nEnter m: ");scanf("%d",&m);
fun(a,m);
printf("\nThe string after moving:\n");puts(a);
printf("\n\n");
NONO();
}
填空题参考答案：
1) double fun(int i, double x, double y)
2) return f1(x);
3) return f2(x, y);
修改题参考答案：
1) char *fun(char *s, char *t)
2) ss++;
3) tt++;
程序题参考答案：
void fun(char *w, int m) /* 可调用fun1函数左移字符 */
{
int i;
for(i = 0 ; i < m ; i++) fun1(w);
}
第97套
给定程序中,函数fun的功能是将形参给定的字符串、整数、浮点数写到文本文件中，再用字符方式从此文本文件中逐个读入并显示在终端屏幕上。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
void fun(char *s, int a, double f)
{
/**********found**********/
__1__ fp;
char ch;
fp = fopen("file1.txt", "w");
fprintf(fp, "%s %d %f\n", s, a, f);
fclose(fp);
fp = fopen("file1.txt", "r");
printf("\nThe result :\n\n");
ch = fgetc(fp);
/**********found**********/
while (!feof(__2__)) {
/**********found**********/
putchar(__3__); ch = fgetc(fp); }
putchar('\n');
fclose(fp);
}
main()
{ char a[10]="Hello!"; int b=12345;
double c= 98.76;
fun(a,b,c);
}
给定程序MODI1.C中函数fun的功能是: 依次取出字符串中所有数字字符, 形成新的字符串, 并取代原字符串。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
void fun(char *s)
{ int i,j;
for(i=0,j=0; s!='\0'; i++)
if(s>='0' && s<='9')
/**********found**********/
s[j]=s;
/**********found**********/
s[j]="\0";
}
main()
{ char item[80];
printf("\nEnter a string : ");gets(item);
printf("\n\nThe string is : \"%s\"\n",item);
fun(item);
printf("\n\nThe string of changing is : \"%s\"\n",item );
}
请编写函数fun, 函数的功能是: 将M行N列的二维数组中的字符数据, 按列的顺序依次放到一个字符串中。
例如, 二维数组中的数据为:
W W W W
S S S S
H H H H
则字符串中的内容应是: WSHWSHWSH。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#define M 3
#define N 4
void fun(char s[][N], char *b)
{
int i,j,n=0;
for(i=0; i < N;i++) /* 请填写相应语句完成其功能 */
{
}
b[n]='\0';
}
main()
{ char a[100],w[M][N]={{'W','W','W','W'},{'S','S','S','S'},{'H','H','H','H'}};
int i,j;void NONO ();
printf("The matrix:\n");
for(i=0; i<M; i++)
{ for(j=0;j<N; j++)printf("%3c",w[j]);
printf("\n");
}
fun(w,a);
printf("The A string:\n");puts(a);
printf("\n\n");
NONO();
}
填空题参考答案：
1) FILE * fp;
2) while (!feof(fp)) {
3) putchar(ch); ch = fgetc(fp); }
修改题参考答案：
1) s[j++]=s;
2) s[j]='\0';
程序题参考答案：
void fun(char s[][N], char *b)
{
int i,j,n=0;
for(i=0; i < N;i++) /* 请填写相应语句完成其功能 */
for(j = 0 ; j < M ; j++)
b[n++] = s[j] ;
b[n]='\0';
}
第98套
给定程序中,函数fun的功能是将参数给定的字符串、整数、浮点数写到文本文件中，再用字符串方式从此文本文件中逐个读入，并调用库函数atoi和atof将字符串转换成相应的整数、浮点数，然后将其显示在屏幕上。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#include <stdlib.h>
void fun(char *s, int a, double f)
{
/**********found**********/
__1__ fp;
char str[100], str1[100], str2[100];
int a1; double f1;
fp = fopen("file1.txt", "w");
fprintf(fp, "%s %d %f\n", s, a, f);
/**********found**********/
__2__ ;
fp = fopen("file1.txt", "r");
/**********found**********/
fscanf(__3__,"%s%s%s", str, str1, str2);
fclose(fp);
a1 = atoi(str1);
f1 = atof(str2);
printf("\nThe result :\n\n%s %d %f\n", str, a1, f1);
}
main()
{ char a[10]="Hello!"; int b=12345;
double c= 98.76;
fun(a,b,c);
}
给定程序MODI1.C中函数fun的功能是: 对N名学生的学习成绩,按从高到低的顺序找出前m(m≤10)名学生来, 并将这些学生数据存放在一个动态分配的连续存储区中, 此存储区的首地址作为函数值返回。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 10
typedef struct ss
{ char num[10];
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<N; i++) b=a;
for(k=0; k<m; k++)
{ for(i=j=0; i<N; i++)
if(b.s > 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<N; i++)
fprintf(pf,"No = %s Mark = %d\n", a.num,a.s);
fprintf(pf,"\n\n");
}
main()
{ STU a[N]={ {"A01",81},{"A02",89},{"A03",66},{"A04",87},{"A05",77},
{"A06",90},{"A07",79},{"A08",61},{"A09",80},{"A10",71} };
STU *pOrder;
int i, m;
printf("***** The Original data *****\n");
outresult(a, stdout);
printf("\nGive the number of the students who have better score: ");
scanf("%d",&m);
while( m>10 )
{ printf("\nGive the number of the students who have better score: ");
scanf("%d",&m);
}
pOrder=fun(a,m);
printf("***** THE RESULT *****\n");
printf("The top :\n");
for(i=0; i<m; i++)
printf(" %s %d\n",pOrder.num , pOrder.s);
free(pOrder);
}
请编写函数fun, 函数的功能是: 删去一维数组中所有相同的数, 使之只剩一个。数组中的数已按由小到大的顺序排列,函数返回删除后数组中数据的个数。
例如, 一维数组中的数据是: 2 2 2 3 4 4 5 6 6 6 6 7 7 8 9 9 10 10 10。删除后,数组中的内容应该是: 2 3 4 5 6 7 8 9 10。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#define N 80
int fun(int a[], int n)
{
}
main()
{ int a[N]={2,2,2,3,4,4,5,6,6,6,6,7,7,8,9,9,10,10,10,10},i,n=20;void NONO
printf("The original data :\n");
for(i=0; i<n; i++)printf("%3d",a);
n=fun(a,n);
printf("\n\nThe data after deleted :\n");
for(i=0;i<n;i++)printf("%3d",a); printf("\n\n");
NONO();
}
填空题参考答案：
1) FILE * fp;
2) fclose(fp) ;
3) fscanf(fp,"%s%s%s", str, str1, str2);
修改题参考答案：
1) t=(STU *)calloc(sizeof(STU),m);
2) t[k]=b[j];
程序题参考答案：
int fun(int a[], int n)
{
int i, j = 1;
for(i=1; i<n; i++)
if(a!=a[i-1])
a[j++]=a;
return j ;
}
第99套
程序通过定义学生结构体变量，存储了学生的学号、姓名和3门课的成绩。所有学生数据均以二进制方式输出到文件中。函数fun的功能是从形参filename所指的文件中读入学生数据，并按照学号从小到大排序后,再用二进制方式把排序后的学生数据输出到filename所指的文件中，覆盖原来的文件内容。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#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<N-1; i++)
for (j=i+1; j<N; j++)
/**********found**********/
if (s.sno __2__ s[j].sno)
{ t = s; s = s[j]; s[j] = t; }
fp = fopen(filename, "wb");
/**********found**********/
__3__(s, sizeof(STU), N, fp); /* 二进制输出 */
fclose(fp);
}
main()
{ STU t[N]={ {10005,"ZhangSan", 95, 80, 88}, {10003,"LiSi", 85, 70, 78},
{10002,"CaoKai", 75, 60, 88}, {10004,"FangFang", 90, 82, 87},
{10001,"MaChao", 91, 92, 77}}, ss[N];
int i,j; FILE *fp;
fp = fopen("student.dat", "wb");
fwrite(t, sizeof(STU), 5, fp);
fclose(fp);
printf("\n\nThe original data :\n\n");
for (j=0; j<N; j++)
{ printf("\nNo: %ld Name: %-8s Scores: ",t[j].sno, t[j].name);
for (i=0; i<3; i++) printf("%6.2f ", t[j].score);
printf("\n");
}
fun("student.dat");
printf("\n\nThe data after sorting :\n\n");
fp = fopen("student.dat", "rb");
fread(ss, sizeof(STU), 5, fp);
fclose(fp);
for (j=0; j<N; j++)
{ printf("\nNo: %ld Name: %-8s Scores: ",ss[j].sno, ss[j].name);
for (i=0; i<3; i++) printf("%6.2f ", ss[j].score);
printf("\n");
}
}
给定程序MODI1.C中函数fun的功能是: 在字符串的最前端加入n个*号, 形成新串, 并且覆盖原串。
注意: 字符串的长度最长允许为79。
请改正函数fun中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
#include <string.h>
void fun ( char s[], int n )
{
char a[80] , *p;
int i;
/**********found***********/
s=p;
for(i=0; i<n; i++) a='*';
do
{ a=*p;
i++;
}
/**********found***********/
while(*p++)
a=0;
strcpy(s,a);
}
main()
{ int n; char s[80];
printf("\nEnter a string : "); gets(s);
printf("\nThe string \"%s\"\n",s);
printf("\nEnter n ( number of * ) : "); scanf("%d",&n);
fun(s,n);
printf("\nThe string after insert : \"%s\" \n" ,s);
}
请编写函数fun,函数的功能是:统计各年龄段的人数。N个年龄通过调用随机函数获得,并放在主函数的age数组中；要求函数把0至9岁年龄段的人数放在d[0]中,把10至19岁年龄段的人数放在d[1]中,把20至29岁年龄段的人数放在d[2]中, 其余依此类推, 把100岁 (含100)以上年龄的人数都放在d[10]中。结果在主函数中输出。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容,仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#define N 50
#define M 11
void fun( int *a, int *b)
{
}
double rnd()
{ static t=29,c=217,m=1024,r=0;
r=(r*t+c)%m; return((double)r/m);
}
main()
{ int age[N], i, d[M];void NONO (int d[M]);
for(i=0; i<N;i++)age=(int)(115*rnd());
printf("The original data :\n");
for(i=0;i<N;i++) printf((i+1)%10==0?"%4d\n":"%4d",age);
printf("\n\n");
fun( age, d);
for(i=0;i<10;i++)printf("%4d---%4d : %4d\n",i*10,i*10+9,d);
printf(" Over 100 : %4d\n",d[10]);
NONO(d);
}
填空题参考答案：
1) fp = fopen(filename, "rb");
2) if (s.sno >s[j].sno)
3) fwrite(s, sizeof(STU), N, fp);
修改题参考答案：
1) p=s;
2) while(*p++);
程序题参考答案：
void fun( int *a, int *b)
{
int i;
for(i = 0 ; i < M ; i++) b = 0 ;
for(i = 0 ; i < N ; i++)
if(a / 10 >= 10)
b[10]++ ;
else
b[a / 10]++ ;
}
第100套
程序通过定义学生结构体变量，存储了学生的学号、姓名和3门课的成绩。所有学生数据均以二进制方式输出到文件中。函数fun的功能是重写形参filename所指文件中最后一个学生的数据，即用新的学生数据覆盖该学生原来的数据,其它学生的数据不变。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK1.C中。
不得增行或删行，也不得更改程序的结构！
#include <stdio.h>
#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__, "rb+");
/**********found**********/
fseek(__2__, -(long)sizeof(STU), SEEK_END);
/**********found**********/
fwrite(&n, sizeof(STU), 1, __3__);
fclose(fp);
}
main()
{ STU t[N]={ {10001,"MaChao", 91, 92, 77}, {10002,"CaoKai", 75, 60, 88},
{10003,"LiSi", 85, 70, 78}, {10004,"FangFang", 90, 82, 87},
{10005,"ZhangSan", 95, 80, 88}};
STU n={10006,"ZhaoSi", 55, 70, 68}, ss[N];
int i,j; FILE *fp;
fp = fopen("student.dat", "wb");
fwrite(t, sizeof(STU), N, fp);
fclose(fp);
fp = fopen("student.dat", "rb");
fread(ss, sizeof(STU), N, fp);
fclose(fp);
printf("\nThe original data :\n\n");
for (j=0; j<N; j++)
{ printf("\nNo: %ld Name: %-8s Scores: ",ss[j].sno, ss[j].name);
for (i=0; i<3; i++) printf("%6.2f ", ss[j].score);
printf("\n");
}
fun("student.dat", n);
printf("\nThe data after modifing :\n\n");
fp = fopen("student.dat", "rb");
fread(ss, sizeof(STU), N, fp);
fclose(fp);
for (j=0; j<N; j++)
{ printf("\nNo: %ld Name: %-8s Scores: ",ss[j].sno, ss[j].name);
for (i=0; i<3; i++) printf("%6.2f ", ss[j].score);
printf("\n");
}
}
给定程序MODI1.C中的函数Creatlink的功能是创建带头结点的单向链表, 并为各结点数据域赋0到m-1的值。
请改正函数Creatlink中指定部位的错误, 使它能得出正确的结果。
注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include <stdio.h>
#include <stdlib.h>
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("\n\nTHE LIST :\n\n HEAD ");
while(p)
{ printf("->%d ",p->data);
p=p->next;
}
printf("\n");
}
main()
{ NODE *head;
head=Creatlink(8,22);
outlink(head);
}
请编写函数fun, 函数的功能是:统计一行字符串中单词的个数,作为函数值返回。一行字符串在主函数中输入, 规定所有单词由小写字母组成,单词之间由若干个空格隔开, 一行的开始没有空格。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <string.h>
#define N 80
int fun( char *s)
{
}
main()
{ char line[N]; int num=0;void NONO ();
printf("Enter a string :\n"); gets(line);
num=fun( line );
printf("The number of word is : %d\n\n",num);
NONO();
}
填空题参考答案：
1) fp = fopen(filename, "rb+");
2) fseek(fp, -(long)sizeof(STU), SEEK_END);
3) fwrite(&n, sizeof(STU), 1, fp);
修改题参考答案：
1) p=(NODE *)malloc(sizeof(NODE));
2) return h;
程序题参考答案：
int fun( char *s)
{
int i,k = 1 ;
for(i=0 ; s ; i++)
if(s==' ')
k++;
return k ;
}
/3 
文章评论（0条评论）
登录后参与讨论