南方制药机械厂的待遇:2011年3月份全国计算机等级考试二级C语言上机题库

来源：百度文库编辑：偶看新闻时间：2024/04/29 03:11:26

二级C语言上机考试复习资料，共有50套题目
一、程序填空题
    1、给定程序中，函数fun的功能是根据形参i的值返回某个函数的值。当调用正确时, 程序输出：
    x1=5.000000, x2=3.000000, x1*x1+x1*x2=40.000000
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
double f1(double x)
{ return x*x; }
double f2(double x, double y)
{ return x*y; }
/**********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);
}    2、给定程序中，函数fun的功能是：找出形参s所指字符串中出现频率最高的字母（不区分大小写），并统计出其出现的次数。
    例如，形参s所指的字符串为：abcAbsmaxless，程序执行后的输出结果为：
          letter 'a' : 3 times
          letter 's' : 3 times
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
#include
#include
void fun(char *s)
{ int k[26]={0},n,i,max=0;    char ch;
while(*s)
{ if( isalpha(*s) ) {
/**********found**********/
      ch=tolower(__1__);
      n=ch-'a';
/**********found**********/
      k[n]+= __2__ ;
    }
    s++;
/**********found**********/
    if(max }
printf("\nAfter count :\n");
for(i=0; i<26;i++)
     if (k[i]==max) printf("\nletter \'%c\' : %d times\n",i+'a',k[i]);
}
main()
{ char s[81];
printf("\nEnter a string:\n\n"); gets(s);
fun(s);
}    3、给定程序中，函数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
#define    N    4
/**********found**********/
void fun(int ___1___ , int n)
{ int i,s;
/**********found**********/
   for(___2___; i++)
   { s=t[i][i];
      t[i][i]=t[i][n-i-1];
/**********found**********/
      t[i][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   { for(j=0; j      printf("\n");
   }
   fun(t,N);
   printf("\nThe result is:\n");
   for(i=0; i   { for(j=0; j      printf("\n");
   }
}    4、给定程序中，函数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
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 printf("\nThe result is: %d\n",fun(x));
}    5、函数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
#define    N    9
void fun(int a[], int n)
{ int i,j, max, min, px, pn, t;
   for (i=0; i   {
/**********found**********/
      max = min = ___1___;
      px = pn = i;
      for (j=i+1; j/**********found**********/
         if (max<___2___)
         {   max = a[j]; px = j; }
/**********found**********/
         if (min>___3___)
         {   min = a[j]; pn = j; }
      }
      if (pn != i)
      { t = a[i]; a[i] = 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   printf("\n");
   fun(b, N);
   printf("\nThe data after moving :\n");
   for (i=0; i   printf("\n");
}    6、给定程序中，函数fun的功能是：对形参s所指字符串中下标为奇数的字符按ASCII码大小递增排序，并将排序后下标为奇数的字符取出，存入形参p所指字符数组中，形成一个新串。
    例如，形参s所指的字符串为：baawrskjghzlicda，执行后p所指字符数组中的字符串应为：aachjlsw。
    请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
void fun(char *s, char *p)
{ int i, j, n, x, t;
   n=0;
   for(i=0; s[i]!='\0'; i++) n++;
   for(i=1; i/**********found**********/
      ___1___;
/**********found**********/
      for(j=___2___+2 ; j        if(s[t]>s[j]) t=j;
      if(t!=i)
      { x=s[i]; s[i]=s[t]; s[t]=x; }
   }
   for(i=1,j=0; i/**********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);
}    7、给定程序中，函数fun的功能是：将形参n中，各位上为偶数的数取出，并按原来从高位到低位的顺序组成一个新的数，并作为函数值返回。
    例如，从主函数输入一个整数：27638496，函数返回值为：26846。
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
unsigned long fun(unsigned long n)
{ unsigned long x=0, s, i;   int t;
   s=n;
/**********found**********/
   i=__1__;
/**********found**********/
   while(__2__)
   { t=s%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 printf("\nThe result is: %ld\n",fun(n));
}    8、给定程序中，函数fun的功能是：将a所指3×5矩阵中第k列的元素左移到第0列，第k列以后的每列元素行依次左移，原来左边的各列依次绕到右边。
    例如，有下列矩阵：
    1    2    3    4    5
    1    2    3    4    5
    1    2    3    4    5
    若k为2，程序执行结果为
    3    4    5    1    2
    3    4    5    1    2
    3    4    5    1    2
    请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！#include
#define   M   3
#define   N   5
void fun(int (*a)[N],int k)
{ int i,j,p,temp;
/**********found**********/
for(p=1; p<= __1__; p++)
     for(i=0; i     { temp=a[i][0];
/**********found**********/
        for(j=0; j< __2__ ; j++) a[i][j]=a[i][j+1];
/**********found**********/
        a[i][N-1]= __3__;
     }
}
main( )
{ int x[M][N]={ {1,2,3,4,5},{1,2,3,4,5},{1,2,3,4,5} },i,j;
printf("The array before moving:\n\n");
for(i=0; i { for(j=0; j     printf("\n");
}
fun(x,2);
printf("The array after moving:\n\n");
for(i=0; i { for(j=0; j     printf("\n");
}
}    9、给定程序中，函数fun的功能是：判断形参s所指字符串是否是"回文"（Palindrome），若是，函数返回值为1；不是，函数返回值为0。"回文"是正读和反读都一样的字符串（不区分大小写字母）。21
    例如，LEVEL和Level是"回文"，而LEVLEV不是"回文"。
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
#include
#include
int fun(char *s)
{ char *lp,*rp;
/**********found**********/
lp= __1__ ;
rp=s+strlen(s)-1;
while((toupper(*lp)==toupper(*rp)) && (lp/**********found**********/
     lp++; rp __2__ ; }
/**********found**********/
if(lp 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);
}    10、给定程序中，函数fun的功能是：把形参s所指字符串中最右边的n个字符复制到形参t所指字符数组中，形成一个新串。若s所指字符串的长度小于n，则将整个字符串复制到形参t所指字符数组中。
    例如，形参s所指的字符串为:abcdefgh，n的值为5，程序执行后t所指字符数组中的字符串应为：defgh。
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
#include
#define   N   80
void fun(char *s, int n, char *t)
{ int len,i,j=0;
len=strlen(s);
/**********found**********/
if(n>=len) strcpy(__1__);
else {
/**********found**********/
     for(i=len-n; i<=len-1; i++) t[j++]= __2__ ;
/**********found**********/
     t[j]= __3__ ;
}
}
main()
{ char s[N],t[N];    int n;
printf("Enter a string: ");gets(s);
printf( "Enter n:"); scanf("%d",&n);
fun(s,n,t);
printf("The string t : "); puts(t);
}    11、给定程序中，函数fun的功能是：将形参n中，各位上为偶数的数取出，并按原来从高位到低位相反的顺序组成一个新的数，并作为函数值返回。
    例如，输入一个整数：27638496，函数返回值为：64862。
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
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 printf("\nThe result is: %ld\n",fun(n));
}    12、给定程序中，函数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
#define    N    4
/**********found**********/
void fun(int (*t)___1___ )
{ int i, j;
   for(i=1; i   { for(j=0; j      {
/**********found**********/
         ___2___ =t[i][j]+t[j][i];
/**********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   { for(j=0; j      printf("\n");
   }
   fun(t);
   printf("\nThe result is:\n");
   for(i=0; i   { for(j=0; j      printf("\n");
   }
}    13、给定程序中，函数fun的功能是: 将s所指字符串中的所有数字字符移到所有非数字字符之后，并保持数字字符串和非数字字符串原有的先后次序。例如，形参s所指的字符串为：def35adh3kjsdf7。执行结果为：defadhkjsdf3537。
    请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
void fun(char *s)
{ int i, j=0, k=0;    char t1[80], t2[80];
   for(i=0; s[i]!='\0'; i++)
     if(s[i]>='0' && s[i]<='9')
     {
/**********found**********/
       t2[j]=s[i]; ___1___;
     }
     else t1[k++]=s[i];
t2[j]=0; t1[k]=0;
/**********found**********/
for(i=0; i/**********found**********/
for(i=0; i<___3___; i++) s[k+i]=t2[i];
}
main()
{ char s[80]="def35adh3kjsdf7";
   printf("\nThe original string is : %s\n",s);
   fun(s);
   printf("\nThe result is : %s\n",s);
}    14、给定程序中，函数fun的功能是计算下式

    例如：若形参e的值为1e-3，函数的返回值为0.551690。
    请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
double fun(double e)
{ int i, k;    double s, t, x;
s=0; k=1; i=2;
/**********found**********/
x=__1__/4;
/**********found**********/
while(x __2__ e)
{ s=s+k*x;
    k=k* (-1);
    t=2*i;
/**********found**********/
    x=__3__/(t*t);
    i++;
}
return s;
}
main()
{ double e=1e-3;
printf("\nThe result is: %f\n",fun(e));
}    15、给定程序中,函数fun的功能是将带头节点的单向链表结点数据域中的数据从小到大排序。即若原链表结点数据域从头至尾的数据为：10、4、2、8、6，排序后链表结点数据域从头至尾的数据为：2、4、6、8、10。
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
#include
#define    N    6
typedef struct node {
int data;
struct node *next;
} NODE;
void fun(NODE *h)
{ NODE *p, *q;    int t;
/**********found**********/
p = __1__ ;
while (p) {
/**********found**********/
     q = __2__ ;
     while (q) {
/**********found**********/
        if (p->data __3__ q->data)
        { t = p->data; p->data = q->data; q->data = t; }
        q = q->next;
    }
    p = p->next;
}
}
NODE *creatlist(int a[])
{ NODE *h,*p,*q;        int i;
h = (NODE *)malloc(sizeof(NODE));
h->next = NULL;
for(i=0; i { q=(NODE *)malloc(sizeof(NODE));
     q->data=a[i];
     q->next = NULL;
     if (h->next == NULL) h->next = p = q;
     else    { p->next = q; p = q;   }
}
   return h;
}
void outlist(NODE *h)
{ NODE *p;
p = h->next;
if (p==NULL) printf("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);
}    16、给定程序中，函数fun的功能是：将形参s所指字符串中的数字字符转换成对应的数值，计算出这些数值的累加和作为函数值返回。
    例如，形参s所指的字符串为：abs5def126jkm8，程序执行后的输出结果为：22。
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！#include
#include
#include
int fun(char *s)
{ int sum=0;
while(*s) {
/**********found**********/
    if( isdigit(*s) ) sum+= *s- __1__ ;
/**********found**********/
    __2__;
}
/**********found**********/
return __3__ ;
}
main()
{ char s[81];    int n;
printf("\nEnter a string:\n\n"); gets(s);
n=fun(s);
printf("\nThe result is: %d\n\n",n);
}    17、函数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
#define    N    9
int fun(int a[], int n)
{ int i,j;
   j = 0;
   for (i=0; i/**********found**********/
      if (a[i]%2==___1___)
      {
/**********found**********/
        a[j] = a[i]; ___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   printf("\n");
   n = fun(b, N);
   printf("\nThe number of odd : %d \n", n);
   printf("\nThe odd number :\n");
   for (i=0; i   printf("\n");
}    18、给定程序中，函数fun的功能是：计算下式前n项的和作为函数值返回。

    例如，当形参n的值为10时，函数返回：9.612558。
    请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
double fun(int n)
{ int i;    double s, t;
/**********found**********/
s=__1__;
/**********found**********/
for(i=1; i<=__2__; i++)
{ t=2.0*i;
/**********found**********/
    s=s+(2.0*i-1)*(2.0*i+1)/__3__;
}
return s;
}
main()
{ int n=-1;
while(n<0)
{ printf("Please input(n>0): "); scanf("%d",&n); }
printf("\nThe result is: %f\n",fun(n));
}    19、给定程序中，函数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
#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][i] ;
/**********found**********/
    a[0][i] = __3__ ;
    a[k][i] = temp ;
}
}
main()
{ int x[M][N]={ {1,2,3},{4,5,6},{7,8,9},{10,11,12} },i,j;
printf("The array before moving:\n\n");
for(i=0; i { for(j=0; j     printf("\n\n");
}
fun(x,2);
printf("The array after moving:\n\n");
for(i=0; i { for(j=0; j     printf("\n\n");
}
}    20、函数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
#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   {
      t=a[i];
/**********found**********/
      a[i] = 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   printf("\n");
   fun(b, N);
   printf("\nThe data after moving :\n");
   for (i=0; i   printf("\n");
}    21、给定程序中，函数fun的功能是：将形参n所指变量中，各位上为偶数的数去除,剩余的数按原来从高位到低位的顺序组成一个新的数，并通过形参指针n传回所指变量。
    例如，输入一个数：27638496，新的数：为739。
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
void fun(unsigned long *n)
{ unsigned long x=0, i;    int t;
i=1;
while(*n)
/**********found**********/
{ t=*n % __1__;
/**********found**********/
    if(t%2!= __2__)
    { x=x+t*i; i=i*10; }
    *n =*n /10;
}
/**********found**********/
*n=__3__;
}
main()
{ unsigned long n=-1;
while(n>99999999||n<0)
{ printf("Please input(0 fun(&n);
printf("\nThe result is: %ld\n",n);
}    22、给定程序中，函数fun的功能是：利用指针数组对形参ss所指字符串数组中的字符串按由长到短的顺序排序，并输出排序结果。ss所指字符串数组中共有N个字符串，且串长小于M。
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
#include
#define   N   5
#define   M   8
void fun(char (*ss)[M])
{ char *ps[N],*tp;    int i,j,k;
for(i=0; i for(i=0; i/**********found**********/
    k= __1__ ;
    for(j=i+1; j/**********found**********/
       if(strlen(ps[k]) < strlen(__2__) ) k=j;
/**********found**********/
    tp=ps[i]; ps[i]=ps[k]; ps[k]= __3__ ;
}
printf("\nThe string after sorting by length:\n\n");
for(i=0; i}
main()
{ char ch[N][M]={"red","green","blue","yellow","black"};
int i;
printf("\nThe original string\n\n");
for(i=0;i fun(ch);
}    23、给定程序中，函数fun的功能是：计算出形参s所指字符串中包含的单词个数,作为函数值返回。为便于统计，规定各单词之间用空格隔开。
    例如，形参s所指的字符串为：This is a C language program.，函数的返回值为6。
    请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
int fun(char *s)
{ int n=0, flag=0;
while(*s!='\0')
{ if(*s!=' ' && flag==0) {
/**********found**********/
     __1__ ; flag=1;}
/**********found**********/
    if (*s==' ') flag= __2__ ;
/**********found**********/
    __3__ ;
}
return n;
}
main()
{ char str[81];    int n;
printf("\nEnter a line text:\n"); gets(str);
n=fun(str);
printf("\nThere are %d words in this text.\n\n",n);
}    24、函数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
#define    N    9
int fun(int a[], int n)
{ int i,j;
   j = 0;
   for (i=0; i/**********found**********/
      if (___1___== 0) {
/**********found**********/
        ___2___ = a[i]; 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   printf("\n");
   n = fun(b, N);
   printf("\nThe number of even ：%d\n", n);
   printf("\nThe even :\n");
   for (i=0; i   printf("\n");
}    25、给定程序中，函数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
#define    N    4
void fun(int (*t)[N])
{ int i, j, x;
/**********found**********/
   for(i=0; i<___1___; i++)
     {
/**********found**********/
        x=t[i][___2___] ;
        for(j=N-1; j>=1; j--)
          t[i][j]=t[i][j-1];
/**********found**********/
        t[i][___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   { for(j=0; j      printf("\n");
   }
   fun(t);
   printf("\nThe result is:\n");
   for(i=0; i   { for(j=0; j      printf("\n");
   }
}    26、函数fun的功能是：逆置数组元素中的值。例如：若a所指数组中的数据依次为：1、2、3、4、5、6、7、8、9，则逆置后依次为：9、8、7、6、5、4、3、2、1。形参n给出数组中数据的个数。
    请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
void fun(int a[], int n)
{ int i,t;
/**********found**********/
   for (i=0; i<___1___; i++)
   {
      t=a[i];
/**********found**********/
      a[i] = 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[i]);
   printf("\n");
   fun(b, 9);
   printf("\nThe data after invert :\n");
   for (i=0; i<9; i++)
      printf("%4d ", b[i]);
   printf("\n");
}    27、给定程序中, 函数fun的功能是用函数指针指向要调用的函数,并进行调用。规定在__2__处使f指向函数f1，在__3__处使f指向函数f2。当调用正确时，程序输出:
    x1=5.000000, x2=3.000000, x1*x1+x1*x2=40.000000
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
double f1(double x)
{ return x*x; }
double f2(double x, double y)
{ return x*y; }
double fun(double a, double b)
{
/**********found**********/
__1__ (*f)();
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);
}    28、给定程序中，函数fun的功能是：在任意给定的9个正整数中找出按升序排列时处于中间的数，将原数据序列中比该中间数小的数用该中间数替换，位置不变，在主函数中输出处理后的数据序列，并将中间数作为函数值返回。
    例如，有9个正整数：1 5 7 23 87 5 8 21 45
         按升序排列时的中间数为：8
    处理后主函数中输出的数列为：8 8 8 23 87 8 8 21 45
    请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！#include
#define    N    9
int fun(int x[])
{ int i,j,k,t,mid,b[N];
   for(i=0;i   for(i=0;i<=N/2;i++)
   { k=i;
      for(j=i+1;jb[j]) k=j;
      if(k != i )
      {
/**********found**********/
        t=b[i]; b[i]=___1___; b[k]=t;
      }
   }
/**********found**********/
   mid=b[___2___];
   for(i=0; i/**********found**********/
     if(x[i] ___3___ mid) x[i]=mid;
   return mid;
}
main()
{ int i, x[N]={1,5,7,23,87,5,8,21,45};
   for(i=0; i   printf("\nThe mid data is: %d\n",fun(x));
   for(i=0; i   printf("\n");
}    29、给定程序中，函数fun的功能是:在形参s所指字符串中寻找与参数c相同的字符，并在其后插入一个与之相同的字符，若找不到相同的字符则函数不做任何处理。
    例如，s所指字符串为：baacda，c中的字符为：a，
          执行后s所指字符串为：baaaacdaa。
    请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
void fun(char *s, char c)
{ int i, j, n;
/**********found**********/
for(i=0; s[i]!=___1___ ; i++)
     if(s[i]==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);
}    30、给定程序的主函数中，已给出由结构体构成的链表结点a、b、c，各结点的数据域中均存入字符，函数fun()的作用是：将a、b、c三个结点链接成一个单向链表，并输出链表结点中的数据。
    请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
typedef struct list
{ char data;
   struct list *next;
} Q;
void fun( Q *pa, Q *pb, Q *pc)
{ Q *p;
/**********found**********/
   pa->next=___1___;
   pb->next=pc;
   p=pa;
   while( p )
   {
/**********found**********/
      printf(" %c",____2_____);
/**********found**********/
      p=____3____;
   }
   printf("\n");
}
main()
{ Q a, b, c;
   a.data='E'; b.data='F'; c.data='G'; c.next=NULL;
   fun( &a, &b, &c );
}
31、给定程序中，函数fun的功能是:计算N×N矩阵的主褫角线元素和反向对角线元素之和，并作为函数值返回。注意：要求先累加主对角线元素中的值，然后累加反向对角线元素中的值。例如，若N=3，有下列矩阵：
        1    2    3
        4    5    6
        7    8    9fun函数首先累
加1、5、9，然后累加3、5、7，函数的返回值为30。
    请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
#define    N    4
fun(int t[][N], int n)
{ int i, sum;
/**********found**********/
   ___1___;
   for(i=0; i/**********found**********/
     sum+=___2___ ;
   for(i=0; i/**********found**********/
     sum+= t[i][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   { for(j=0; j      printf("\n");
   }
   printf("The result is: %d",fun(t,N));
}    32、给定程序中,函数fun的功能是将形参给定的字符串、整数、浮点数写到文本文件中，再用字符方式从此文本文件中逐个读入并显示在终端屏幕上。
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！#include
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);
}    33、给定程序中，函数fun的功能是：将形参s所指字符串中所有ASCII码值小于97的字符存入形参t所指字符数组中，形成一个新串，并统计出符合条件的字符个数作为函数值返回。
    例如，形参s所指的字符串为：Abc@1x56*，程序执行后t所指字符数组中的字符串应为：A@156*。
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
int fun(char *s, char *t)
{ int n=0;
while(*s)
{ if(*s < 97) {
/**********found**********/
     *(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);
}    34、给定程序中，函数fun的功能是：将形参s所指字符串中的所有字母字符顺序前移，其他字符顺序后移，处理后新字符串的首地址作为函数值返回。
    例如，s所指字符串为:asd123fgh543df,处理后新字符串为:asdfghdf123543。
    请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
#include
#include
char *fun(char *s)
{ int i, j, k, n;    char *p, *t;
n=strlen(s)+1;
t=(char*)malloc(n*sizeof(char));
p=(char*)malloc(n*sizeof(char));
j=0; k=0;
for(i=0; i { if(((s[i]>='a')&&(s[i]<='z'))||((s[i]>='A')&&(s[i]<='Z'))) {
/**********found**********/
       t[j]=__1__; j++;}
     else
     { p[k]=s[i]; k++; }
}
/**********found**********/
for(i=0; i<__2__; i++) t[j+i]=p[i];
/**********found**********/
t[j+k]= __3__;
return t;
}
main()
{ char s[80];
printf("Please input: "); scanf("%s",s);
printf("\nThe result is: %s\n",fun(s));
}    35、给定程序中,函数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
#define    N    4
void fun(int (*t)[N])
{ int j ,r[N];
   for(j=0; j   for(j=0; j/**********found**********/
      t[0][N-j-1]=t[j][___1___ ];
   for(j=0; 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   { for(j=0; j      printf("\n");
   }
   fun(t);
   printf("\nThe result is:\n");
   for(i=0; i   { for(j=0; j      printf("\n");
   }
}    36、给定程序中，函数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
#define    N    4
void fun(int (*t)[N], int m)
{ int i, j;
/**********found**********/
   for(i=0; i   { for(j=N-1-m; j>=0; j--)
/**********found**********/
         t[i][j+___2___ ]=t[i][j];
/**********found**********/
      for(j=0; j<___3___; j++)
         t[i][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   { for(j=0; j        printf("%2d ",t[i][j]);
      printf("\n");
   }
   printf("Input m (m<=%d): ",N);scanf("%d",&m);
   fun(t,m);
   printf("\nThe result is:\n");
   for(i=0; i   { for(j=0; j        printf("%2d ",t[i][j]);
      printf("\n");
   }
}    37、给定程序中，函数fun的功能是：把形参s所指字符串中下标为奇数的字符右移到下一个奇数位置，最右边被移出字符串的字符绕回放到第一个奇数位置，下标为偶数的字符不动（注：字符串的长度大于等于2）。例如，形参s所指的字符串为：abcdefgh，执行结果为：ahcbedgf。
    请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
void fun(char *s)
{ int i, n, k;    char c;
   n=0;
   for(i=0; s[i]!='\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[i];
/**********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);
}    38、给定程序中，函数fun的功能是:求ss所指字符串数组中长度最短的字符串所在的行下标,作为函数值返回，并把其串长放在形参n所指变量中。ss所指字符串数组中共有M个字符串，且串长    请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
#include
#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[i]);
     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   k=fun(ss,&n);
   printf("\nThe length of shortest string is : %d\n",n);
   printf("\nThe shortest string is : %s\n",ss[k]);
}    39、函数fun的功能是进行数字字符转换。若形参ch中是数字字符'0'～'9', 则'0'转换成'9','1'转换成'8'，'2'转换成'7'，……，'9'转换成'0'；若是其它字符则保持不变；并将转换后的结果作为函数值返回。
    请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
/**********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);
}    40、给定程序中，函数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
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));
}    41、函数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
#define    N    9
/**********found**********/
void fun(int ___1___, int n)
{ int i, j, max, min, px, pn, t;
/**********found**********/
   for (i=0; i   { max = min = a[i];
      px = pn = i;
/**********found**********/
      for (j=___3___; j      { if (max < a[j])
         { max = a[j]; px = j; }
         if (min > a[j])
         { min = a[j]; pn = j; }
      }
      if (px != i)
      { t = a[i]; a[i] = 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   printf("\n");
   fun(b, N);
   printf("\nThe data after moving :\n");
   for (i=0; i   printf("\n");
}    42、给定程序中,函数fun的功能是将不带头节点的单向链表结点数据域中的数据从小到大排序。即若原链表结点数据域从头至尾的数据为：10、4、2、8、6，排序后链表结点数据域从头至尾的数据为：2、4、6、8、10。
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
#include
#define    N    6
typedef struct node {
int data;
struct node *next;
} NODE;
void fun(NODE *h)
{ NODE *p, *q;    int t;
p = h;
while (p) {
/**********found**********/
     q = __1__ ;
/**********found**********/
     while (__2__)
     { if (p->data > q->data)
       { t = p->data; p->data = q->data; q->data = t; }
       q = q->next;
    }
/**********found**********/
    p = __3__ ;
}
}
NODE *creatlist(int a[])
{ NODE *h,*p,*q;        int i;
   h=NULL;
   for(i=0; i   { q=(NODE *)malloc(sizeof(NODE));
      q->data=a[i];
      q->next = NULL;
      if (h == NULL) h = p = q;
      else    { p->next = q; p = q;   }
   }
   return h;
}
void outlist(NODE *h)
{ NODE *p;
   p=h;
   if (p==NULL) printf("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);
}    43、给定程序中，函数fun的功能是将带头结点的单向链表逆置。即若原链表中从头至尾结点数据域依次为:2、4、6、8、10,逆置后，从头至尾结点数据域依次为:10、8、6、4、2。
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
#include
#define    N    5
typedef struct node {
int data;
struct node *next;
} NODE;
void fun(NODE *h)
{ NODE *p, *q, *r;
/**********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 { q=(NODE *)malloc(sizeof(NODE));
     q->data=a[i];
     q->next = NULL;
     if (h->next == NULL) h->next = p = q;
     else    { p->next = q; p = q;   }
}
   return h;
}
void outlist(NODE *h)
{ NODE *p;
p = h->next;
if (p==NULL) printf("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);
}    44、给定程序中，函数fun的功能是：统计形参s所指字符串中数字字符出现的次数，并存放在形参t所指的变量中，最后在主函数中输出。例如，形参s所指的字符串为：abcdef35adgh3kjsdf7。输出结果为：4。
    请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！#include
void fun(char *s, int *t)
{ int i, n;
   n=0;
/**********found**********/
   for(i=0; ___1___ !=0; i++)
/**********found**********/
      if(s[i]>='0'&&s[i]<= ___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);
}    45、给定程序中，函数fun的功能是：在3×4的矩阵中找出在行上最大、在列上最小的那个元素，若没有符合条件的元素则输出相应信息。
    例如，有下列矩阵：
    1    2    13    4
    7    8    10    6
    3    5    9    7
    程序执行结果为：find: a[2][2]=9
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
#define   M   3
#define   N   4
void fun(int (*a)[N])
{ int i=0,j,find=0,rmax,c,k;
while( (i { rmax=a[i][0]; c=0;
     for(j=1; j       if(rmax/**********found**********/
         rmax=a[i][j]; c= __1__ ; }
     find=1; k=0;
     while(k/**********found**********/
       if (k!=i && a[k][c]<=rmax) find= __2__ ;
       k++;
     }
     if(find) printf("find: a[%d][%d]=%d\n",i,c,a[i][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    for(j=0; j printf("The array:\n");
for(i=0; i { for(j=0; j     printf("\n\n");
}
fun(x);
}    46、给定程序中，函数fun的功能是：在形参s所指字符串中的每个数字字符之后插入一个*号。例如，形参s所指的字符串为：def35adh3kjsdf7。执行结果为：def3*5*adh3*kjsdf7*。
    请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
void fun(char *s)
{ int i, j, n;
   for(i=0; s[i]!='\0'; i++)
/**********found**********/
     if(s[i]>='0' ___1___ s[i]<='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);
}    47、函数fun的功能是：输出a所指数组中的前n个数据，要求每行输出5个数。
    请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
#include
void fun( int *a, int n )
{ int i;
   for(i=0; i   {
/**********found**********/
     if( ___1___==0 )
/**********found**********/
           printf("___2___");
/**********found**********/
      printf("%d ",___3___);
   }
}
main()
{ int a[100]={0}, i,n;
   n=22;
   for(i=0; i   fun( a, n);
   printf("\n");
}    48、给定程序中，函数fun的功能是计算下式

    例如，若形参e的值为1e-3，函数的返回值2.985678。
    请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！#include
double fun(double e)
{ int i;    double s, x;
/**********found**********/
s=0; i=__1__;
x=1.0;
while(x>e){
/**********found**********/
    __2__;
/**********found**********/
    x=(2.0*i-1)/((__3__)*(2.0*i));
    s=s+x;
}
return s;
}
main()
{ double e=1e-3;
printf("\nThe result is: %f\n",fun(e));
}    49、给定程序中，函数fun的功能是：计算下式前n项的和作为函数值返回。

    例如，当形参n的值为10时，函数返回：-0.204491。
    请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
double fun(int n)
{ int i, k;    double s, t;
s=0;
/**********found**********/
k=__1__;
for(i=1; i<=n; i++) {
/**********found**********/
    t=__2__;
    s=s+k*(2*i-1)*(2*i+1)/(t*t);
/**********found**********/
    k=k*__3__;
}
return s;
}
main()
{ int n=-1;
while(n<0)
{ printf("Please input(n>0): "); scanf("%d",&n); }
printf("\nThe result is: %f\n",fun(n));
}    50、给定程序中，函数fun的功能是将不带头结点的单向链表逆置。即若原链表中从头至尾结点数据域依次为:2、4、6、8、10，逆置后，从头至尾结点数据域依次为：10、8、6、4、2。
    请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意：源程序存放在考生文件夹下的BLANK1.C中。
          不得增行或删行，也不得更改程序的结构！
#include
#include
#define    N    5
typedef struct node {
int data;
struct node *next;
} NODE;
/**********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   { q=(NODE *)malloc(sizeof(NODE));
      q->data=a[i];
      q->next = NULL;
      if (h == NULL) h = p = q;
      else    { p->next = q; p = q;   }
   }
   return h;
}
void outlist(NODE *h)
{ NODE *p;
   p=h;
   if (p==NULL) printf("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);
}二、程序修改题
    1、给定程序MODI1.C中函数fun的功能是: 比较两个字符串，将长的那个字符串的首地址作为函数值返回。
    请改正函数fun中指定部位的错误, 使它能得出正确的结果。
    注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include
/**********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));
}    2、给定程序MODI1.C中函数 fun 的功能是：求S的值。

    例如，当k为10时，函数值应为：1.533852。
    请改正程序中的错误，使程序能输出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include
#include
/************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));
}    3、由N个有序整数组成的数列已放在一维数组中，给定程序MODI1.C中函数fun的功能是：利用折半查找算法查找整数m在数组中的位置。若找到，返回其下标值；反之，返回-1。
    折半查找的基本算法是:每次查找前先确定数组中待查的范围:low和high（lowhigh，查找结束。
    请改正程序中的错误，使它能得出正确结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include
#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        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   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");
}    4、给定程序MODI1.C中函数fun的功能是：先将s所指字符串中的字符按逆序存放到t所指字符串中，然后把s所指串中的字符按正序连接到t所指串的后面。
    例如：当s所指的字符串为："ABCDE"时，
          则t所指的字符串应为："EDCBAABCDE"。
    请改正程序中的错误，使它能得出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！#include
#include
void fun (char *s, char *t)
{
/************found************/
    int   i;
    sl = strlen(s);
    for (i=0; i/************found************/
       t[i] = s[sl-i];
    for (i=0; i t[sl+i] = s[i];
    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);
}    5、给定程序MODI1.C中函数fun的功能是：用递归算法计算斐波拉契数列中第n项的值。从第1项起，斐波拉契数列为：1、1、2、3、5、8、13、21、……
    例如，若给n输入7，该项的斐波拉契数值为：13。
    请改正程序中的错误，使它能得出正确结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include
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);
}    6、给定程序MODI1.C中函数 fun 的功能是：用下面的公式求π的近似值，直到最后一项的绝对值小于指定的数（参数num ）为止：
     π        1      1      1
    ┄┄≈1 - ┄┄ + ┄┄ - ┄┄ + ...
     4         3      5      7
    例如, 程序运行后, 输入0.0001, 则程序输出3.1414。
    请改正程序中的错误，使它能输出正确的结果。
    注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include
#include
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) ;
}    7、给定程序MODI1.C中函数fun的功能是：输出M行M列整数方阵，然后求两条对角线上元素之和，返回此和数。
    请改正程序中的错误，使它能得出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include
#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[i][j] );
    printf("\n");
}
for( i = 0 ; i < n ; i++ )
    sum += xx[i][i]+xx[i][ n-i-1 ];
return( sum );
}
main( )
{ int aa[M][M]={{1,2,3,4,5},{4,3,2,1,0},
    {6,7,8,9,0},{9,8,7,6,5},{3,4,5,6,7}};
printf ( "\nThe sum of all elements on 2 diagnals is %d.",fun( M, aa ));
}    8、给定程序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
#include
#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[i][j] ) ;
        printf ( "\n" ) ;
   }
}    9、给定程序MODI1.C中fun函数的功能是：求出以下分数序列的前n项之和。
        2      3      5      8     13     21
      ┄┄ , ┄┄ , ┄┄ , ┄┄ , ┄┄ , ┄┄ , ……
        1      2      3      5      8     13和值通过函数值返回main函数。
    例如，若 n = 5，则应输出： 8.391667。
    请改正程序中的错误，使它能得出正确的结果。
    注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include
/**************found**************/
fun (int n )
{   int a = 2, b = 1, c, k ;
    double s=0.0 ;
    for ( k = 1; k <= n; k++ )
    { s = s + 1.0 * a / b ;
/**************found**************/
       c = a; a += b; b += c;
    }
    return(s) ;
}
main( )
{   int   n = 5 ;
    printf( "\nThe value of function is: %lf\n", fun ( n ) ) ;
}    10、给定程序MODI1.C中函数fun的功能是：找出一个大于形参m且紧随m的素数，并作为函数值返回。
    请改正程序中的错误，使它能得出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include
int fun(int m)
{ int i, k ;
   for (i = m + 1 ; ; i++) {
      for (k = 2 ; k < i ; k++)
/**************found**************/
         if (i % k != 0)
            break ;
/**************found**************/
         if (k < i)
           return(i);
   }
}
void main()
{
int n ;
n = fun(20) ;
printf("n=%d\n", n) ;
}    11、给定程序MODI1.C中函数fun的功能是：将长整型数中每一位上为奇数的数依次取出，构成一个新数放在t中。高位仍在高位，低位仍在低位。
    例如，当s中的数为：87653142时，t中的数为：7531。
    请改正程序中的错误，使它能得出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include
void fun (long s, long *t)
{ int   d;
long sl=1;
/************found************/
t = 0;
while ( s > 0)
{ d = s%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);
}    12、给定程序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
#include
#include
/************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);
}    13、给定程序MODI1.C中函数 fun 的功能是：用冒泡法对6个字符串按由小到大的顺序进行排序。
    请改正程序中的错误，使它能得出正确的结果。
    注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include
#include
#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[i] = str[i] ;
    printf( "\nEnter 6 string(1 string at each line): \n" ) ;
    for(i = 0 ; i < 6 ; i++) scanf("%s", pstr[i]) ;
    fun(pstr) ;
    printf("The strings after sorting:\n") ;
    for(i = 0 ; i < 6 ; i++) printf("%s\n", pstr[i]) ;
}    14、给定程序MODI1.C中函数 fun 的功能是：求出以下分数序列的前n项之和。和值通过函数值返回到main函数。
           2      3      5      8      13     21
          ┄┄ , ┄┄ , ┄┄ , ┄┄ , ┄┄ , ┄┄ , ……
           1      2      3      5      8      13
    例如，若n = 5，则应输出：8.391667。
    请改正程序中的错误，使它能计算出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include
/************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 ) );
}    15、给定程序MODI1.C是建立一个带头结点的单向链表, 并用随机函数为各结点数据域赋值。函数fun的作用是求出单向链表结点(不包括头结点)数据域中的最大值,并且作为函数值返回。
    请改正函数fun中指定部位的错误, 使它能得出正确的结果。
    注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include
#include
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);
}    16、给定程序MODI1.C中函数fun的功能是：计算小于形参k的最大的10个能被13或17整除的自然数之和。k的值由主函数传入，若k的值为500，则函数值为4622。
    请改正程序中的错误，使程序能输出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！#include
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));
}    17、给定程序MODI1.C中函数fun的功能是：求出两个非零正整数的最大公约数，并作为函数值返回。
    例如，若给num1和num2分别输入49和21，则输出的最大公约数为7；若给num1和num2分别输入27和81，则输出的最大公约数为27。
    请改正程序中的错误，使它能得出正确结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include
int fun(int a,int b)
{ int   r,t;
   if(a/************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);
}    18、给定程序MODI1.C中函数 fun 的功能是：统计substr所指子字符串在str所指字符串中出现的次数。
    例如，若字符串为aaas lkaaas，子字符串为as，则应输出2。
    请改正程序中的错误，使它能计算出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include
int fun (char *str,char *substr)
{ int i,j,k,num=0;
/************found************/
   for(i = 0, str[i], i++)
     for(j=i,k=0;substr[k]==str[j];k++,j++)
/************found************/
       If(substr[k+1]=='\0')
       { num++;
          break;
       }
   return num;
}
main()
{
char str[80],substr[80];
printf("Input a string:") ;
gets(str);
printf("Input a substring:") ;
gets(substr);
printf("%d\n",fun(str,substr));
}    19、给定程序MODI1.C中函数 fun 的功能是: 读入一个字符串(长度＜20 ),将该字符串中的所有字符按ASCII码升序排序后输出。
    例如, 若输入: edcba, 则应输出: abcde。
    请改正程序中的错误，使它能统计出正确的结果。
    注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include
#include
void fun( char t[] )
{
char c;
int i, j;
/**********found***********/
for( i = strlen( t ); i; i-- )
    for( j = 0; j < i; j++ )
/**********found***********/
      if( t[j] < t[ j + 1 ] )
      {
        c = t[j];
        t[j] = t[ j + 1 ];
        t[j + 1 ] = c;
      }
}
main()
{
char s[81];
printf( "\nPlease enter a character string: " );
gets( s );
printf( "\n\nBefore sorting:\n \"%s\"", s );
fun( s );
printf( "\nAfter sorting decendingly:\n \"%s\"\n", s );
}    20、给定程序MODI1.C中函数fun的功能是：把主函数中输入的3个数，最大的放在a中，最小的放在c中，中间的放在b中。
    例如，输入的数为：55 12 34，
          输出结果应当是：a=55.0 , b=34.0 , c=12.0。
    请改正程序中的错误，使它能得出正确结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。#include
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);
}    21、给定程序MODI1.C中函数 fun 的功能是：计算n!。
    例如，给n输入5，则输出120.000000。
    请改正程序中的错误，使程序能输出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include
double fun ( int n )
{ double result = 1.0 ;
/************found************/
if n = = 0
    return 1.0 ;
while( n >1 && n < 170 )
/************found************/
    result *= n--
return result ;
}
main ( )
{ int n ;
printf("Input N:") ;
scanf("%d", &n) ;
printf("\n\n%d! =%lf\n\n", n, fun(n)) ;
}    22、已知一个数列从第0项开始的前三项分别为0，0，1，以后的各项都是其相邻的前三项之和。给定程序MODI1.C中函数fun的功能是:计算并输出该数列前n项的平方根之和。n的值通过形参传入。
    例如，当n＝10时，程序的输出结果应为：23.197745。
    请改正程序中的错误，使程序能输出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include
#include
/************found************/
fun(int n)
{ double   sum, s0, s1, s2, s; int k;
   sum = 1.0;
   if (n <= 2) sum = 0.0;
   s0 = 0.0; s1 = 0.0; s2 = 1.0;
   for (k = 4; k <= n; k++)
   { s = s0 + s1 + s2;
      sum += sqrt(s);
      s0 = s1; s1 = s2; s2 = s;
   }
/************found************/
   return sum
}
main ( )
{ int n;
   printf("Input N=");
   scanf("%d", &n);
   printf("%f\n", fun(n) );
}    23、给定程序MODI1.C中函数 fun 的功能是：从n(形参)个学生的成绩中统计出低于平均分的学生人数，此人数由函数值返回,平均分存放在形参aver所指的存储单元中。
    例如，若输入 8 名学生的成绩：80.5 60 72 90.5 98 51.5   88 64则低于平均分的学生人数为： 4 （平均分为：75.5625 ）。
    请改正程序中的错误，使它能统计出正确的结果。
    注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include
#define N   20
int fun ( float *s, int n, float *aver )
{ float ave, t = 0.0 ;
   int count = 0, k, i ;
   for ( k = 0 ; k < n ; k++ )
/**************found**************/
     t = s[k] ;
   ave = t / n ;
   for ( i = 0 ; i < n ; i++ )
     if ( s[ i ] < ave ) count++ ;
/**************found**************/
   *aver = Ave ;
   return count ;
}
main()
{ float s[30], aver ;
   int m, i ;
   printf ( "\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 ) ;
}    24、给定程序MODI1.C中函数fun的功能是：按以下递归公式求函数值。
              ┌ 10            (n=1)
       fun(n)=┥
              └ fun(n-1)+2    (n>1)
    例如，当给n输入5时，函数值为18；当给n输入3时，函数值为14。
    请改正程序中的错误，使它能得出正确结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。#include
/************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));
}    25、
    例如，若q的值为: 50.0，则函数值为: 49.394948。
    请改正程序中的错误，使程序能输出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include
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));
}    26、给定程序MODI1.C中函数fun的功能是：将一个由八进制数字字符组成的字符串转换为与其面值相等的十进制整数。规定输入的字符串最多只能包含5位八进制数字字符。
    例如，若输入：77777，则输出将是：32767。
    请改正程序中的错误，使它能得出正确结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include
#include
#include
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]; i++)
       if(s[i]<'0'||s[i]>'7')
       { printf("Error: %c not is ocatal digits!\n\n",s[i]);exit(0); }
    printf("The original string: "); puts(s);
    n=fun(s);
    printf("\n%s is convered to integer number: %d\n\n",s,n);
}    27、给定程序MODI1.C是建立一个带头结点的单向链表,并用随机函数为各结点赋值。函数fun的功能是将单向链表结点 (不包括头结点)数据域为偶数的值累加起来, 并且作为函数值返回。
    请改正函数fun中指定部位的错误, 使它能得出正确的结果。
    注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include
#include
typedef struct aa
{ int data; struct aa *next; }NODE;
int fun(NODE *h)
{ int   sum = 0 ;
NODE *p;
/***********found**********/
p=h;
while(p)
{ if(p->data%2==0)
     sum +=p->data;
/***********found**********/
     p=h->next;
}
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);
}    28、给定程序MODI1.C中，fun函数的功能是：删除b所指数组中小于10的数据。主函数中输出删除后数组中余下的数据。
请改正函数fun中指定部位的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！#include
#include
#define   N 20
int fun( int *b )
{
/**********found**********/
   int t[N] ,i, num
   for(i=0; i     if(b[i]>=10)
/**********found**********/
       t[++num]=b[i];
/**********found**********/
    for(i=0; i      b[i]=t[i];
    return( num );
}
main()
{ int a[N],i,num;
   printf("a数组中的数据 :\n");
   for(i=0;i   printf("\n");
   num=fun(a);
   for(i=0;i   printf("\n");
}    29、在主函数中从键盘输入若干个数放入数组中, 用0结束输入并放在最后一个元素中。给定程序MODI1.C中函数fun的功能是:计算数组元素中值为正数的平均值(不包括0)。
    例如：数组中元素中的值依次为：39,-47,21,2,-8,15,0，
          则程序的运行结果为：19.250000。
    请改正程序中的错误，使它能得出正确的结果。
    注意：不要改动main 函数，不得增行或删行，也不得更改程序的结构！
#include
double fun ( int x[])
{
/************found************/
int sum = 0.0;
int c=0, i=0;
while (x[i] != 0)
{ if (x[i] > 0) {
       sum += x[i]; 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[i]); }
   while (x[i++] != 0);
   printf("%f\n", fun ( x ));
}    30、给定程序MODI1.C中，函数fun()的功能是统计s所指一维数组中0的个数（存在变量zero中）和1的个数（存在变量one中），并输出结果。
    请改正函数fun中指定部位的错误，使它能得出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include
void fun( int *s, int n )
{
/**********found**********/
   int i, one=0, zero ;
   for(i=0; i/**********found**********/
   switch( s[i] );
   {
/**********found**********/
      case 0 : zero++;
      case 1 : one ++;
   }
   printf( "one : %d    zero : %d\n", one, zero);
}
main()
{ int a[20]={1,1,1,0,1,0,0,0,1,0,0,1,1,0,0,1,0,1,0,0}, n=20;
   fun( a, n );
}    31、
    例如，若给m输入 -100，给n输入90，则函数求得的一个根值为2.000。
    请改正程序中的错误，使它能得出正确结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include
#include
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);
}    32、给定程序MODI1.C中函数fun的功能是: 依次取出字符串中所有数字字符, 形成新的字符串, 并取代原字符串。
    请改正函数fun中指定部位的错误, 使它能得出正确的结果。
    注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!#include
void fun(char *s)
{ int i,j;
   for(i=0,j=0; s[i]!='\0'; i++)
        if(s[i]>='0' && s[i]<='9')
/**********found**********/
            s[j]=s[i];
/**********found**********/
        s[j]="\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 );
}    33、给定程序MODI1.C中函数 fun 的功能是：由形参给定n个实数，输出平均值，并统计在平均值以上(含平均值)的实数个数。
    例如,n＝8时,输入：193.199,195.673,195.757,196.051,196.092,196.596,196.579,196.763
    所得平均值为:195.838750，在平均值以上的实数个数应为：5
    请改正程序中的错误，使程序能输出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include
int fun(double x[], int n)
{
/************found************/
int j, c=0, double xa=0.0;
   for (j=0; j     xa += x[j]/n;
   printf("ave =%f\n",xa);
   for (j=0; 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));
}    34、给定程序MODI1.C中函数 fun 的功能是：将s所指字符串中最后一次出现的与t1所指字符串相同的子串替换成t2所指字符串,所形成的新串放在w所指的数组中。在此处，要求t1和t2所指字符串的长度相同。
    例如，当s所指字符串中的内容为："abcdabfabc"，t1所指子串中的内容为："ab"，t2所指子串中的内容为："99"时，结果，在w所指的数组中的内容应为："abcdabf99c"。
    请改正程序中的错误，使它能得出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include
#include
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");
}    35、给定程序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
#include
/************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) );
}    36、给定程序MODI1.C中函数 fun 的功能是：计算并输出high以内最大的10个素数之和。high的值由主函数传给fun函数。
    若high的值为: 100, 则函数的值为: 732。
    请改正程序中的错误，使程序能输出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！#include
#include
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));
}    37、给定程序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
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 ) );
}    38、给定程序MODI1.C中函数 fun 的功能是：将tt所指字符串中的小写字母都改为对应的大写字母，其它字符不变。
    例如，若输入"Ab, cD"，则输出"AB, CD"。
    请改正程序中的错误，使它能得出正确的结果。
    注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include
#include
char* fun( char tt[] )
{
int i;
for( i = 0; tt[i]; i++ )
/**********found***********/
    if(( 'a' <= tt[i] )||( tt[i] <= 'z' ) )
/**********found***********/
      tt[i] += 32;
return( tt );
}
main( )
{
char tt[81];
printf( "\nPlease enter a string: " );
gets( tt );
printf( "\nThe result string is:\n%s", fun( tt ) );
}    39、给定程序MODI1.C中函数fun的功能是：将p所指字符串中的所有字符复制到b中，要求每复制三个字符之后插入一个空格。
    例如，在调用fun函数之前给a输入字符串：ABCDEFGHIJK，
    调用函数之后，字符数组b中的内容则为：ABC DEF GHI JK。
    请改正程序中的错误，使它能得出正确结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include
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");
}    40、给定程序MODI1.C中函数fun的功能是：从低位开始取出长整型变量s中偶数位上的数，依次构成一个新数放在t中。高位仍在高位,低位仍在低位。
    例如，当s中的数为：7654321时，t中的数为：642。
    请改正程序中的错误，使它能得出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！#include
/************found************/
void fun (long s, long t)
{   long sl=10;
    s /= 10;
    *t = s % 10;
/************found************/
    while ( s < 0)
    { s = s/100;
       *t = s%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);
}    41、给定程序MODI1.C中函数fun的功能是：按顺序给s所指数组中的元素赋予从2开始的偶数，然后再按顺序对每五个元素求一个平均值，并将这些值依次存放在w所指的数组中。若s所指数组中元素的个数不是5的倍数，多余部分忽略不计。
    例如，s所指数组有14个元素，则只对前10个元素进行处理，不对最后的4个元素求平均值。
    请改正程序中的错误，使它能得出正确结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
#include
#define   SIZE   20
fun(double *s, double *w)
{ int   k,i;    double sum;
   for(k=2,i=0;i   {   s[i]=k;   k+=2;   }
/**********found**********/
   sun=0.0;
   for(k=0,i=0;i   { sum+=s[i];
/**********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   { if(i%5==0) printf("\n");
      printf("%4.0f", a[i]);
   }
   printf("\n\nThe result :\n");
   for(i=0; i   printf("\n\n");
}    42、给定程序MODI1.C中函数fun的功能是: 将s所指字符串中的字母转换为按字母序列的后续字母(但Z转换为A, z转换为a),其它字符不变。
    请改正函数fun中指定部位的错误, 使它能得出正确的结果。
    注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include
#include
void fun (char *s)
{
/**********found***********/
while(*s!='@')
{ if(*s>='A' && *s<='Z' || *s>='a' && *s<='z')
     { if(*s=='Z') *s='A';
        else if(*s=='z') *s='a';
        else              *s += 1;
     }
/**********found***********/
     (*s)++;
}
}
main()
{ char s[80];
   printf("\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);
}    43、给定程序MODI1.C中函数fun的功能是: 计算s所指字符串中含有t所指字符串的数目, 并作为函数值返回。
    请改正函数fun中指定部位的错误, 使它能得出正确的结果。
    注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include
#include
#define    N     80
int fun(char *s, char *t)
{ int n;
   char *p , *r;
   n=0;
   while ( *s )
   { p=s;
/*********found**********/
      r=p;
      while(*r)
        if(*r==*p) { r++; p++; }
        else break;
/*********found**********/
      if(*r= 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);
}    44、给定程序MODI1.C中函数fun的功能是：通过某种方式实现两个变量值的交换,规定不允许增加语句和表达式。例如变量a 中的值原为8，b中的值原为3, 程序运行后 a 中的值为 3，b中的值为8。
    请改正程序中的错误，使它能得出正确的结果。
    注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！#include
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) ;
}    45、给定程序MODI1.C中函数fun的功能是：根据整型形参m的值，计算如下公式的值。
                1       1              1
      t = 1 - ----- - ----- - …… - -----
               2*2     3*3            m*m
    例如，若 m 中的值为: 5，则应输出: 0.536389。
    请改正程序中的错误，使它能得出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！
#include
double fun ( int m )
{ 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 ) ) ;
}    46、给定程序MODI1.C中函数fun的功能是：根据整型形参m，计算如下公式的值。
               1       1       1              1
     y = 1 + ----- + ----- + ----- + …… + -----
              2*2     3*3     4*4            m*m
    例如，若 m 中的值为: 5，则应输出：1.463611。
    请改正程序中的错误，使它能得出正确的结果。
    注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include
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 ) ) ;
}    47、给定程序MODI1.C中，函数fun的功能是：在任意给定的N个正整数中，从左到右依次逐个取三个数作为一组，按值大小找出该组数的中值，用该中值替换与该组数对应的原三个数中的中间位置的数。处理后原数列中首尾2个数不变。处理后数列在主函数中输出。例如，有10个正整数如下：

    请改正程序中指定部位的错误，使它能得出正确结果。
    注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！
#include
#define   N   10
int findmid(int a, int b, int c)
{ int t;
   t = (a>b)?(b>c?b:(a>c?c:a)):((a>c)?a:((b>c)?c:b));
/**********found**********/
   return b;
}
void fun(int x[])
{ int i,a,b,c,t[N];
/**********found**********/
   for(i=0;i   for(i=0;i   { a=t[i];b=t[i+1];c=t[i+2];
/**********found**********/
      t[i+1]=findmid(a,b,c);
   }
}
main()
{ int i, x[N]={6,5,7,23,18,5,8,21,45,38};
   for(i=0; i   printf("\n");
   fun(x);
   for(i=0; i   printf("\n");
}    48、给定程序MODI1.C中函数 fun 的功能是：将s所指字符串的正序和反序进行连接，形成一个新串放在t所指的数组中。
    例如，当s所指字符串为："ABCD" 时，则t所指字符串中的内容应为："ABCDDCBA"。
    请改正程序中的错误，使它能得出正确的结果。
    注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！#include
#include
/************found************/
void fun (char s, char t)
{
int   i, d;
d = strlen(s);
for (i = 0; i for (i = 0; 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);
}    49、给定程序MODI1.C中函数 fun 的功能是：判断一个整数是否是素数，若是返回1，否则返回0。
    在main()函数中，若fun返回1输出YES，若fun返回0输出NO!。
    请改正程序中的错误，使它能得出正确的结果。
    注意：不要改动main函数。不得增行或删行，也不得更改程序的结构！
#include
int fun ( int m )
{ int k = 2;
   while ( k <= m && (m%k))
/************found************/
     k++
/************found************/
   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" );
}    50、给定程序MODI1.C中函数fun的功能是: 将s所指字符串中位于奇数位置的字符或ASCII码为偶数的字符放入t所指数组中(规定第一个字符放在第0位中)。
     例如, 字符串中的数据为: AABBCCDDEEFF,
               则输出应当是：ABBCDDEFF。
    请改正函数fun中指定部位的错误, 使它能得出正确的结果。
    注意: 不要改动main函数, 不得增行或删行, 也不得更改程序的结构!
#include
#include
#define   N     80
void fun(char *s, char t[])
{ int i, j=0;
   for(i=0; i<(int)strlen(s); i++)
/***********found**********/
   if(i%2 && s[i]%2==0)
        t[j++]=s[i];
/***********found**********/
   t[i]='\0';
}
main()
{ char s[N], t[N];
   printf("\nPlease enter string s : "); gets(s);
   fun(s, t);
   printf("\nThe result is : %s\n",t);
}三、程序编写题
    1、请编写函数fun,函数的功能是: 移动字符串中的内容,移动的规则如下: 把第1到第m个字符, 平移到字符串的最后, 把第m+1到最后的字符移到字符串的前部。
    例如, 字符串中原有的内容为: ABCDEFGHIJK, m的值为3, 则移动后, 字符串中的内容应该是: DEFGHIJKABC。
    注意：部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include
#include
#define    N    80
void fun1(char *w) /* 本函数的功能是将字符串中字符循环左移一个位置 */
{
int i; char t;
t=w[0];
for(i=0;i<(int)strlen(w)-1;i++)
    w[i]=w[i+1];
w[strlen(w)-1]=t;
}
void fun(char *w, int m) /* 可调用fun1函数左移字符 */
{}
main()
{ char a[N]= "ABCDEFGHIJK";
   int m;void
   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");
}    2、编写函数fun，它的功能是：计算并输出下列级数和：
          1      1            1
    S = ── + ── + … + ───
        1×2   2×3         n(n+1)
    例如，当n = 10时，函数值为：0.909091。
    注意: 部分源程序在文件PROG1.C文件中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
double fun( int n )
{}
main()   /* 主函数 */
{ void
   printf("%f\n", fun(10));
}    3、假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是：除了尾部的*号之外,将字符串中其它*号全部删除。形参p已指向字符串中最后的一个字母。在编写函数时，不得使用C语言提供的字符串函数。
    例如，字符串中的内容为：****A*BC*DEF*G*******，删除后,字符串中的内容应当是： ABCDEFG*******。
    注意: 部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
void fun( char *a, char *p )
{}
main()
{ char s[81],*t;
   void
   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);
}    4、函数fun的功能是：将a、b中的两个两位正整数合并形成一个新的整数放在c中。合并的方式是：将a中的十位和个位数依次放在变量c的百位和个位上，b中的十位和个位数依次放在变量c的千位和十位上。
    例如，当a＝45，b=12。调用该函数后，c=1425。
    注意: 部分源程序存在文件PROG1.C中。数据文件IN.DAT中的数据不得修改。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。#include
void fun(int a, int b, long *c)
{}
main()   /* 主函数 */
{ int a,b; long c;void
   printf("Input a b:");
   scanf("%d%d", &a, &b);
   fun(a, b, &c);
   printf("The result is: %ld\n", c);
}    5、某学生的记录由学号、8门课程成绩和平均分组成，学号和8门课程的成绩已在主函数中给出。请编写函数fun,它的功能是：求出该学生的平均分放在记录的ave成员中。
    例如，学生的成绩是：85.5,76,69.5,85,91,72,64.5,87.5,他的平均分应当是：78.875。
    注意: 部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun部位中填入你编写的若干语句。
#include
#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
   fun( &s );
   printf("The %s's student data:\n", s.num);
   for(i=0;i     printf("%4.1f\n",s.s[i]);
   printf("\nave=%7.3f\n",s.ave);
}    6、请编写一个函数void fun (char a[],char b[],int n)，其功能是：删除一个字符串中指定下标的字符。其中, a指向原字符串, 删除指定字符后的字符串存放在b所指的数组中,n中存放指定的下标。
    例如,输入一个字符串: World,然后输入3,则调用该函数后的结果为: Word。
    注意: 部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容,仅在函数fun的花括号中填入你编写的若干语句。
#include
#include
#define LEN 20
void fun (char a[], char b[], int n)
{}
main( )
{   char str1[LEN], str2[LEN] ;
    int n ;
    void
    printf("Enter the string:\n") ;
    gets(str1) ;
    printf("Enter the index of the char deleted:") ;
    scanf("%d", &n) ;
    fun(str1, str2, n) ;
    printf("The new string is: %s\n", str2) ;
}    7、函数fun的功能是：将a、b中的两个两位正整数合并形成一个新的整数放在c中。合并的方式是:将a中的十位和个位数依次放在变量c的千位和十位上，b中的十位和个位数依次放在变量c的个位和百位上。
    例如，当a＝45，b=12。调用该函数后，c=4251。
    注意: 部分源程序存在文件PROG1.C中。数据文件IN.DAT中的数据不得修改。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
void fun(int a, int b, long *c)
{}
main()
{ int a,b; long c;void
   printf("Input a b:");
   scanf("%d%d", &a, &b);
   fun(a, b, &c);
   printf("The result is: %ld\n", c);
}    8、函数fun的功能是：将a、b中的两个两位正整数合并形成一个新的整数放在c中。合并的方式是:将a中的十位和个位数依次放在变量c的十位和千位上，b中的十位和个位数依次放在变量c的个位和百位上。
    例如，当a＝45，b=12。调用该函数后，c=5241。
    注意: 部分源程序存在文件PROG1.C中。数据文件IN.DAT中的数据不得修改。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。#include
void fun(int a, int b, long *c)
{}
main()
{ int a,b; long c;void
   printf("Input a b:");
   scanf("%d%d", &a, &b);
   fun(a, b, &c);
   printf("The result is: %ld\n", c);
}    9、请编写函数fun，函数的功能是：将大于形参m且紧靠m的k个素数存入xx所指的数组中。例如，若输入17, 5，则应输出：19, 23, 29, 31, 37。函数fun中给出的语句仅供参考。
    注意: 部分源程序在文件PROG1.C文件中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
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
   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") ;
}    10、请编写函数fun，它的功能是：求出能整除形参x且不是偶数的各整数,并按从小到大的顺序放在pp所指的数组中,这些除数的个数通过形参n返回。
    例如，若 x 中的值为: 35，则有 4 个数符合要求，它们是: 1, 5, 7, 35。
    注意: 部分源程序在文件PROG1.C文件中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
void fun ( int x, int pp[], int *n )
{}
main( )
{ int x, aa[1000], n, i ;void
   printf( "\nPlease enter an integer number:\n" ) ; scanf("%d", &x) ;
   fun(x, aa, &n ) ;
   for( i = 0 ; i < n ; i++ )
         printf("%d ", aa[i]) ;
   printf("\n") ;
}    11、编写一个函数fun,它的功能是:实现两个字符串的连接(不使用库函数strcat),即把p2所指的字符串连接到p1所指的字符串后。
    例如，分别输入下面两个字符串：
            FirstString--
            SecondString
    程序输出：
            FirstString--SecondString
    注意: 部分源程序在文件PROG1.C文件中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
void fun(char p1[], char p2[])
{}
main()
{    char s1[80], s2[40] ;void
     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) ;
}    12、规定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是：将字符串中的前导*号全部删除，中间和尾部的*号不删除。
    例如，字符串中的内容为：*******A*BC*DEF*G****，删除后,字符串中的内容应当是：A*BC*DEF*G****。在编写函数时，不得使用C语言提供的字符串函数。
    注意: 部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。#include
void fun( char *a )
{}
main()
{ char s[81];
   void
   printf("Enter a string:\n");gets(s);
   fun( s );
   printf("The string after deleted:\n");puts(s);
}    13、请编写函数fun，它的功能是：求出ss所指字符串中指定字符的个数，并返回此值。
    例如,若输入字符串: 123412132,输入字符为: 1,则输出:3。
    注意: 部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
#include
#define M 81
int fun(char *ss, char c)
{}
main()
{ char a[M], ch;
   void
   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));
}    14、请编写一个函数fun，它的功能是：求出一个2×M整型二维数组中最大元素的值,并将此值返回调用函数。
    注意: 部分源程序存在文件PROG1.C文件中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
#define M 4
int fun (int a[][M])
{}
main( )
{ int arr[2][M]={5,8,3,45,76,-4,12,82} ;void
   printf("max =%d\n", fun(arr)) ;
}    15、请编写函数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
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
printf("The matrix:\n") ;
for(i = 0 ; i < 3 ; i++)
{ for(j = 0 ; j < 4 ; j++) printf("%3d",w[i][j]) ;
    printf("\n") ;
}
fun(w, a, &n, 3, 4) ;
printf("The A array:\n") ;
for(i = 0 ; i < n ; i++) printf("%3d",a[i]);printf("\n\n") ;
}    16、编写函数fun，它的功能是：求小于形参n同时能被3与7整除的所有自然数之和的平方根，并作为函数值返回。
    例如若n为1000时，程序输出应为：s = 153.909064。
    注意: 部分源程序在文件PROG1.C文件中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。#include
#include
double fun( int n)
{}
main()   /* 主函数 */
{ void
   printf("s =%f\n", fun ( 1000) );
}    17、假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是：删除字符串中所有的*号。在编写函数时，不得使用C语言提供的字符串函数。
    例如，字符串中的内容为：****A*BC*DEF*G*******，删除后,字符串中的内容应当是：ABCDEFG。
    注意: 部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
void fun( char *a )
{}
main()
{ char s[81];
   void
   printf("Enter a string:\n");gets(s);
   fun( s );
   printf("The string after deleted:\n");puts(s);
}    18、请编写一个函数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
#include
double fun ( double eps)
{}
main( )
{ double x;void
printf("Input eps:") ;
scanf("%lf",&x); printf("\neps = %lf, PI=%lf\n", x, fun(x));
}    19、请编写一个函数fun, 其功能是: 将ss所指字符串中所有下标为奇数位置上的字母转换为大写（若该位置上不是字母, 则不转换）。
    例如, 若输入"abc4EFg"，则应输出"aBc4EFg"。
    注意: 部分源程序在文件PROG1.C文件中。
    请勿改动主函数main和其它函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include
#include
void fun( char *ss )
{}
void main( void )
{
   char tt[51];void
   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 );
}    20、学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中,请编写函数fun，它的功能是：把分数最高的学生数据放在b所指的数组中,注意：分数最高的学生可能不止一个，函数返回分数最高的学生的人数。
    注意: 部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。#include
#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     printf("%s %4d\n",h[i].num,h[i].s);
   printf("\n");
   out = fopen("c:\\test\\out.dat","w") ;
   fprintf(out, "%d\n",n);
   for(i=0;i     fprintf(out, "%4d\n",h[i].s);
   fclose(out);
}    21、请编写一个函数fun，它的功能是：将一个数字字符串转换为一个整数(不得调用C语言提供的将字符串转换为整数的函数)。例如，若输入字符串"-1234",则函数把它转换为整数值 -1234。函数fun中给出的语句仅供参考。
    注意: 部分源程序存在文件PROG1.C文件中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
#include
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
long    n;
printf("Enter a string:\n") ;
gets(s);
n = fun(s);
printf("%ld\n",n);
}    22、编写函数fun，它的功能是计算下列级数和，和值由函数值返回。

    例如，当n = 10，x＝0.3时，函数值为1.349859。
    注意: 部分源程序在文件PROG1.C文件中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
#include
double fun(double x , int n)
{}
main()
{ void
   printf("%f\n", fun(0.3,10));
}    23、请编写函数fun，其功能是求出数组的最大元素在数组中的下标并存放在k所指的存储单元中。
    例如, 输入如下整数: 876 675 896 101 301 401 980 431 451 777
    则输出结果为: 6, 980
    注意: 部分源程序在文件PROG1.C文件中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
void fun(int *s, int t, int *k)
{}
main( )
{
    int a[10]={876,675,896,101,301,401,980,431,451,777}, k ;void
    fun(a, 10, &k) ;
    printf("%d, %d\n", k, a[k]) ;
}    24、假定输入的字符串中只包含字母和*号。请编写函数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
void fun( char *a,int n )
{}
main()
{ char s[81]; int n;
   void
   printf("Enter a string:\n");gets(s);
   printf("Enter n : ");scanf("%d",&n);
   fun( s,n );
   printf("The string after deleted:\n");puts(s);
}    25、编写函数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
#include
int fun( int t)
{}
main()   /* 主函数 */
{ int n;
   void
   n=1000;
   printf("n = %d, f = %d\n",n, fun(n));
}    26、学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中,请编写函数fun,它的功能是：函数返回指定学号的学生数据,指定的学号在主函数中输入。若没找到指定学号,在结构体变量中给学号置空串，给成绩置-1，作为函数值返回。（用于字符串比较的函数是strcmp, strcmp(a, b)当a和b字符串相等时返回值为0）。
    注意: 部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
#include
#define   N   16
typedef struct
{ char num[10];
   int   s;
} STREC;
STREC fun( STREC *a, char *b )
{
int i;
STREC t = {'\0', -1};
}
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   { if(i%4==0) printf("\n");
      printf("%s %3d ",s[i].num,s[i].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("c:\\test\\out.dat","w") ;
   h=fun(s,"GA013");
   fprintf(out,"%s %4d\n",h.num,h.s);
   fclose(out);
}    27、请编写函数fun, 函数的功能是: 判断字符串是否为回文?若是, 函数返回1，主函数中输出: YES, 否则返回0, 主函数中输出NO。回文是指顺读和倒读都一样的字符串。
    例如, 字符串LEVEL是回文, 而字符串123312就不是回文。
    注意：部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
#include
#define N 80
int fun(char *str)
{}
main()
{ char s[N] ;void
printf("Enter a string: ") ; gets(s) ;
printf("\n\n") ; puts(s) ;
if(fun(s)) printf(" YES\n") ;
else       printf(" NO\n") ;
}    28、请编写函数fun，其功能是：统计s所指字符串中的数字字符个数，并作为函数值返回。
    例如，s所指字符串中的内容是：2def35adh25 3kjsdf 7/kj8655x，
          函数fun返回值为：11
    注意: 部分源程序在文件PROG1.C文件中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。#include
void
int fun(char *s)
{}
main()
{ char *s="2def35adh25 3kjsdf 7/kj8655x";
   printf("%s\n",s);
   printf("%d\n",fun(s));
}    29、编写函数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
double fun(int n)
{}
main()
{ int n; double s;
   void
   printf("\nPlease enter N:"); scanf("%d", &n);
   s = fun(n);
   printf("the result is: %f\n", s);
}    30、请编写函数fun，其功能是将形参s所指的字符串放入形参a所指的字符数组中，使a中存放同样的字符串。说明：不得使用系统提供的字符串函数。
    注意：部分源程序存在PROG1.C中，请勿改动主函数main和其他函数中的任何内容，仅在函数fun指定的部位填入所编写的若干语句。
#include
#define    N    20
void
void fun( char *a , char *s)
{}
main()
{ char s1[N], *s2="abcdefghijk";
   fun( s1,s2);
   printf("%s\n", s1);
   printf("%s\n", s2);
}    31、假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是: 除了字符串前导和尾部的*号之外,将串中其它*号全部删除。形参h已指向字符串中第一个字母，形参p已指向字符串中最后一个字母。在编写函数时，不得使用C语言提供的字符串函数。
   例如，字符串中的内容为：****A*BC*DEF*G********，删除后,字符串中的内容应当是：****ABCDEFG********。在编写函数时，不得使用C语言提供的字符串函数。
    注意: 部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
void fun( char *a, char *h,char *p )
{}
main()
{ char s[81],*t, *f;
   void
   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);
}    32、请编写函数fun, 函数的功能是: 将M行N列的二维数组中的字符数据, 按列的顺序依次放到一个字符串中。
    例如, 二维数组中的数据为:
         W W W W
         S S S S
         H H H H
    则字符串中的内容应是: WSHWSHWSHWSH。
    注意：部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。#include
#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
   printf("The matrix:\n");
   for(i=0; i   { for(j=0;j      printf("\n");
   }
   fun(w,a);
   printf("The A string:\n");puts(a);
   printf("\n\n");
}    33、编写函数fun，其功能是：根据以下公式求P的值，结果由函数值带回。m与n为两个正整数且要求m > n。
           m!
     P = ───
         n!(m-n)!
    例如：m＝12，n＝8时，运行结果为495.000000。
    注意: 部分源程序在文件PROG1.C文件中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
float fun(int m, int n)
{}
main()   /* 主函数 */
{ void
   printf("P=%f\n", fun (12,8));
}    34、函数fun的功能是：将s所指字符串中ASCII值为奇数的字符删除，串中剩余字符形成一个新串放在t所指的数组中。
    例如，若s所指字符串中的内容为："ABCDEFG12345"，其中字符A的ASCII码值为奇数、…、字符1的ASCII码值也为奇数、… 都应当删除，其它依此类推。最后t所指的数组中的内容应是："BDF24"。
    注意: 部分源程序存在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
#include
void fun(char *s, char t[])
{}
main()
{
char   s[100], t[100];void
printf("\nPlease enter string S:"); scanf("%s", s);
fun(s, t);
printf("\nThe result is: %s\n", t);
}    35、编写函数fun，它的功能是计算：

    s作为函数值返回。
    在C语言中可调用log ( n )函数求ln (n)。log函数的引用说明是:double log(double x)。
    例如，若m的值为: 20，fun函数值为: 6.506583。
    注意: 部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
#include
double   fun( int m )
{}
main()
{
   void
   printf("%f\n", fun(20));
}    36、编写函数fun，它的功能是：利用以下所示的简单迭代方法求方程：cos(x)-x=0 的一个实根。

    迭代步骤如下：（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
#include
double fun()
{}
main()
{
   void
   printf("Root =%f\n", fun());
}    37、请编写一个函数 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
#include
void fun(char *tt, int pp[])
{}
main( )
{ char aa[1000] ;
   int bb[26], k ;
   void
   printf( "\nPlease enter a char string:" ) ; scanf("%s", aa) ;
   fun(aa, bb ) ;
   for ( k = 0 ; k < 26 ; k++ ) printf ("%d ", bb[k]) ;
   printf( "\n" ) ;
}    38、请编写函数fun，其功能是: 将所有大于1小于整数m的非素数存入xx所指数组中, 非素数的个数通过k传回。
    例如，若输入:17，则应输出:4 6 8 9 10 12 14 15 16。
    注意: 部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
void fun( int m, int *k, int xx[] )
{}
main()
{
   int m, n, zz[100];
   void
   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] );
}    39、N名学生的成绩已在主函数中放入一个带头节点的链表结构中,h指向链表的头节点。请编写函数fun，它的功能是：求出平均分，由函数值返回。
    例如，若学生的成绩是：85，76，69，85，91，72，64，87, 则平均分应当是：78.625。
    注意: 部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
#include
#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 { q=(STREC*)malloc(sizeof(STREC));
    q->s=s[i]; 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
   STREC *h;
   h=creat( s );   outlist(h);
   ave=fun( h );
   printf("ave= %6.3f\n",ave);
}    40、学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中,请编写函数fun，它的功能是：按分数的高低排列学生的记录，高分在前。
    注意: 部分源程序在文件PROG1.C文件中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。#include
#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   { if( (i)%4==0 )printf("\n");
      printf("%s %4d ",s[i].num,s[i].s);
   }
   printf("\n");
   out = fopen("c:\\test\\out.dat","w") ;
   for(i=0;i   { if( (i)%4==0 && i) fprintf(out, "\n");
      fprintf(out, "%4d ",s[i].s);
   }
   fprintf(out,"\n");
   fclose(out) ;
}    41、学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中,请编写函数fun，它的功能是：把低于平均分的学生数据放在b所指的数组中,低于平均分的学生人数通过形参n传回，平均分通过函数值返回。
    注意: 部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
#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     printf("%s %4.1f\n",h[i].num,h[i].s);
   printf("\n");
   out = fopen("c:\\test\\out.dat","w") ;
   fprintf(out, "%d\n%7.3f\n", n, ave);
   for(i=0;i     for(j=i+1;j       if(h[i].s>h[j].s) {t=h[i] ;h[i]=h[j]; h[j]=t;}
   for(i=0;i     fprintf(out,"%4.1f\n",h[i].s);
   fclose(out);
}    42、请编写函数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
#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
   printf("The original data:\n");
   for(i=0; i   printf("\n\nEnter p: ");scanf("%d",&p);
   fun(a,p,n);
   printf("\nThe data after moving:\n");
   for(i=0; i   printf("\n\n");
}    43、请编写函数fun, 函数的功能是: 将放在字符串数组中的M个字符串(每串的长度不超过N), 按顺序合并组成一个新的字符串。函数fun中给出的语句仅供参考。
    例如, 字符串数组中的M个字符串为
     AAAA
     BBBBBBB
     CC
    则合并后的字符串的内容应是: AAAABBBBBBBCC。
    提示：strcat(a,b)的功能是将字符串b复制到字符串a的串尾上，成为一个新串。
    注意：部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容, 仅在函数fun的花括号中填入你编写的若干语句。
#include
#include
#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
   printf("The string:\n");
   for(i=0; i   printf("\n");
   fun(w,a);
   printf("The A string:\n");
   printf("%s",a);printf("\n\n");
}    44、请编写函数fun，它的功能是: 求出 1 到 1000 之间能被 7 或11整除、但不能同时被 7 和 11 整除的所有整数并将它们放在a所指的数组中，通过 n 返回这些数的个数。
    注意: 部分源程序在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。#include
void fun (int *a, int *n)
{}
main( )
{ int aa[1000], n, k ;
   void
   fun ( aa, &n ) ;
   for ( k = 0 ; k < n ; k++ )
      if((k + 1) % 10 == 0) printf("\n") ;
      else printf("%5d", aa[k]) ;
}    45、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
#include
int fun(int score[], int m, int below[])
{}
main( )
{ int i, n, below[9] ;void
   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[i]) ;
}    46、请编写函数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
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
   fun(a, t) ;
   for (i = 0 ; i < 3 ; i++) {
      for (j = 0 ; j < 3 ; j++)
        printf("%7d", t[i][j]) ;
      printf("\n") ;
   }
}    47、请编写函数fun，函数的功能是查找x在s所指数组中下标的位置作为函数值返回，若x不存在，则返回-1。
    注意：部分源程序存在PROG1.C中，请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
#include
#define   N   15
void
int fun( int *s, int x)
{}
main()
{ int a[N]={ 29,13,5,22,10,9,3,18,22,25,14,15,2,7,27},i,x,index;
   printf("a数组中的数据 :\n");
   for(i=0; i   printf("给x输入待查找的数 : ");   scanf("%d",&x);
   index=fun( a, x );
   printf("index=%d\n",index);
}    48、函数fun的功能是：将s所指字符串中除了下标为奇数、同时ASCII值也为奇数的字符之外，其余的所有字符都删除,串中剩余字符所形成的一个新串放在t所指的数组中。
    例如，若s所指字符串中的内容为："ABCDEFG12345",其中字符A的ASCII码值虽为奇数，但所在元素的下标为偶数，因此必需删除；而字符1的ASCII码值为奇数，所在数组中的下标也为奇数,因此不应当删除，其它依此类推。最后t所指的数组中的内容应是："135"。
    注意: 部分源程序存在文件PROG1.C中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。#include
#include
void fun(char *s, char t[])
{}
main()
{
char   s[100], t[100];void
printf("\nPlease enter string S:"); scanf("%s", s);
fun(s, t);
printf("\nThe result is: %s\n", t);
}    49、请编写一个函数fun，它的功能是：找出一维整型数组元素中最大的值和它所在的下标，最大的值和它所在的下标通过形参传回。数组元素中的值已在主函数中赋予。
    主函数中x是数组名， n是x中的数据个数，max存放最大值,index存放最大值所在元素的下标。
    注意: 部分源程序存在文件PROG1.C文件中。
    请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
#include
#include
void fun(int a[], int n , int *max, int *d )
{}
main()
{ int i, x[20], max , index, n = 10;void
for (i=0;i < n;i++) {x[i] = rand()%50; printf("%4d", x[i]) ; }
printf("\n");
fun( x, n , &max, &index);
printf("Max =%5d , Index =%4d\n",max, index );
}    50、请编写函数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
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
   printf("The matrix:\n");
   for(i=0; i<3; i++)
   { for(j=0;j<4; j++)printf("%3d",w[i][j]);
      printf("\n");
   }
   fun(w,a,&n,3,4);
   printf("The A array:\n");
   for(i=0;i}       参考答案
一、程序填空题
1、（1）double（2）f1（3）f2
2、（1）*s（2）1（3）k[n]
3、（1）t[][N]（2）i=0;i4、（1）0（2）x（3）t++
5、（1）a[i]（2）a[j]（3）a[j]
6、（1）t=i（2）i（3）0
7、（1）1（2）s（3）i*10
8、（1）k（2）N-1（3）temp
9、（1）s（2）--（3）return 0
10、（1）t,s（2）s[i]（3）0
11、（1）0（2）10*x（3）n/10
12、（1）[N]（2）t[i][j]（3）t[j][i]
13、（1）j++（2）s[i]=t1[i]（3）j
14、（1）3.（2）>（3）(2*i+1)
15、（1）h->next（2）p->next（3）>=
16、（1）48（2）s++（3）sum
17、（1）1（2）j++（3）j
18、（1）0（2）n（3）(t*t)
19、（1）k（2）N（3）a[k][i]
20、（1）1（2）i（3）a[p+i]
21、（1）10（2）0（3）x
22、（1）i（2）ps[j]（3）tp
23、（1）n++（2）0（3）s++
24、（1）a[i]%2（2）a[j]（3）j
25、（1）N（2）N-1（3）0
26、（1）n/2（2）i（3）a[n-i-1]
27、（1）double（2）f1（3）f2
28、（1）b[k]（2）N/2（3）<
29、（1）0（2）0（3）c
30、（1）pb（2）p->data（3）p->next
31、（1）sum=0（2）t[i][i]（3）1
32、（1）FILE *（2）fp（3）ch
33、（1）*s（2）s++（3）n
34、（1）s[i]（2）k（3）0
35、（1）0（2）j--（3）j
36、（1）i++（2）m（3）m
37、（1）1（2）s[k]（3）c
38、（1）M（2）<（3）k
39、（1）char（2）ch<='9'（3）'0'
40、（1）999（2）t/10（3）x
41、（1）*a（2）2（3）i+1
42、（1）p->next（2）q（3）p->next
43、（1）next（2）0（3）r
44、（1）s[i]（2）'9'（3）*t=n
45、（1）j（2）0（3）i++
46、（1）&&（2）0（3）s[j]
47、（1）i%5（2）\n（3）a[i]
48、（1）0（2）i++（3）2.*i
49、（1）1（2）2*i（3）(-1)
50、（1）NODE（2）next（3）r
二、程序修改题
1、（1）char *fun(char *s,char *t)（2）ss++;（3）tt++;
2、（1）float fun(int k)（2）return s;
3、（1）fun(int a[],int m)（2）else if(m>a[mid])
4、（1）int i,sl;（2）t[i]=s[sl-i-1];
5、（1）switch(g)（2）case 1: return 1; case 2:return 1;
6、（1）while((fabs(t))>=num)（2）t=s/n;
7、（1）int fun(int n,int xx[][M])（2）printf("%d",xx[i][j]);
8、（1）void fun(int a[][M], int m)（2）a[j][k]=(k+1)*(j+1);
9、（1）double fun (int n)（2）c=a;a+=b;b=c;
10、（1）if(i%k==0)（2）if(k>=i)
11、（1）*t=0;（2）if(d%2!=0)
12、（1）#define FU(m,n) ((m)/(n))（2）return (value);
13、（1）for(j=i+1;j<6;j++)（2）*(pstr+i)=*(pstr+j);
14、（1）double fun(int n)（2）s=s+(double)a/b;
15、（1）p=h->next;（2）p=p->next;
16、（1）if ((k%13 == 0) || (k%17 == 0))（2）}
17、（1）t=a;a=b;b=t;（2）return(b);
18、（1）for(i=0;str[i];i++)（2）if(substr[k+1]==0)
19、（1）for(i = strlen( t )-1; i;i--)（2）if(t[j] > t[j + 1 ] )
20、（1）float k;（2）if(*c>*a)
21、（1）if (n==0)（2）result *= n-- ;
22、（1）double fun(int n)（2）return sum;
23、（1）t+=s[k];（2）*aver=ave;
24、（1）fun (int n)（2）if(n==1)
25、（1）s=s+(n+1.)/n;（2）return t;
26、（1）n= *p-'0';（2）n=n*8+*p-'0';
27、（1）p=h->next;（2）p=p->next;
28、（1）int t[N] ,i, num=0;（2）t[num++]=b[i];（3）for(i=0; i29、（1）double sum=0.;（2）sum /= c;
30、（1）int i, one=0, zero=0;（2）switch( s[i] )（3）case 0:zero++;break;
31、（1）double r;（2）while(fabs(m-n)>0.001)
32、（1）s[j++]=s[i];（2）s[j]=0;
33、（1）int j, c=0; double xa=0.;（2）if (x[j]>=xa)
34、（1）while(*w)（2）if(*r==*p)
35、（1）double f(double x)（2）return s;
36、（1）while((2<=high) && (n<10))（2）yes=0; break;
37、（1）long s=0,t=0;（2）t=t/10;
38、（1）if(('a'<=tt[i])&&(tt[i]<='z'))（2）tt[i]-=32;
39、（1）b[k]=*p;（2）b[k]=' ';k++;
40、（1）void fun(long s,long *t)（2）while(s>0)
41、（1）sum=0;（2）if((i+1)%5==0)
42、（1）while(*s)（2）s++;
43、（1）r=t;（2）if(*r==0)
44、（1）t=*x;*x=y;（2）return t;
45、（1）for(i=2;i<=m;i++)（2）y-=1.0/i/i;
46、（1）for(i=2;i<=m;i++)（2）y+=1.0/i/i;
47、（1）return t;（2）for(i=0;i48、（1）void fun (char *s, char *t)（2）t[2*d] = 0;
49、（1）k++;（2）if(m==k)
50、（1）if(i%2 || s[i]%2==0)（2）t[j]=0;
三、编程题
1.void fun(char *w, int m)
{
char a[N];
int i;
for(i=0;iwhile(w[i]) { w[i-m]=w[i]; i++;}
i--;m--;
for(;m>=0;m--,i--) w[i]=a[m];
}2.double fun( int n )
{
int i;
double s;
for(i=1;i<=n;i++)
{ s+=1.0/(i*(i+1));
}
return s;
}
3.void fun(char *a,char *p)
{ char *q;
while(aif(*a=='*')
{ for(q=a;*q;q++)
    *q=*(q+1);
     p--;}
else a++;
}
4.void fun(int a, int b, long *c)
{
*c=a/10*100+a%10+b/10*1000+b%10*10;
}5.void fun(STREC *a)
{
   int i=0;
   double sum=0.0;
   for(;i   {
     sum+=a->s[i];
   }
   a->ave=sum/N;
}6.void fun (char a[], char b[], int n)
{
int i=0,j=0;
while(a[i])
{
     if(i!=n)
{
    b[j]=a[i];
    j++;
}
i++;
}
   b[j]='\0';
}7.void fun(int a, int b, long *c)
{
*c=a/10*1000+a%10*10+b/10+b%10*100;
}8.void fun(char p1[], char p2[])
{
char *p,*q;
p=p1;
q=p2;
while(*p) p++;
while(*q) *p++=*q++;
*p='\0';
}9.void fun(int m, int k, int xx[])
{
int i,j=m+1,n=0;
while(n{
for(i=2;iif(j%i==0) break;
if(j==i)
{
xx[n]=i;
n++;
}
j++;
}
}10.void fun ( int x, int pp[], int *n )
{
int i;
*n=0;
for(i=1;i<=x;i+=2)
{
if(x%i==0)
{
pp[*n]=i;
(*n)++;
}
}
}11.void fun(int a, int b, long *c)
{
*c=a/10*10+a%10*1000+b/10+b%10*100;
}12..void fun( char *a )
{
int i=0,j=0;
while(a[i])
{
   if(a[i]!='*')
   {
     j=i;
  break;
   }
   i++;
}
    while(a[i])
{
   a[i-j]=a[i];
   i++;
}
a[i-j]='\0';
}13.int fun(char *ss, char c)
{
int n=0,i=0;
while(ss[i])
{
    if(ss[i]==c)
    {
      n++;
    }
    i++;
}
return n;
}14.int fun (int a[][M])
{
int i,j,max=0;
for(i=0;i<2;i++)
   for(j=0;j     {
          if(max   max=a[i][j];
     }
   return max;
}
15.void fun(int (*s)[10], int *b, int *n, int mm, int nn)
{
int i,j;
*n=0;
for(i=0;ifor(j=0;j{
b[*n]=s[i][j];
(*n)++;
}
}16.double fun( int n)
{
int i;
double s=0;
for(i=1;i{
if(i%3==0 && i%7==0) s+=i;
}
return sqrt(s);
}17.void fun( char *a )
{
char p[81];
int i=0,j=0;
while(a[i])
{
  if(a[i]!='*')
   a[j++]=a[i];
i++;
}
a[j]=0;
}18.double fun ( double eps)
{
int i=0;
double pi=0,a=1;
while(a>=eps)
{
  pi+=a;
  i++;
  a=a*i/(2*i+1);
}
return pi*2;
}
19.void fun( char *ss )
{
int i=1;
while(ss[i-1] && ss[i])
{
if(ss[i]>='a' && ss[i]<='z') ss[i]+='A'-'a';
i+=2;
}
}
20.int fun( STREC *a, STREC *b )
{
   int i,j=0,s=a[0].s;
   for(i=1;i     if(a[i].s>s) s=a[i].s;
   for(i=0;i     if(a[i].s==s)
     {
     b[j]=a[i];
     j++;
     }
   return j;
}
21.long fun ( char *p)
{
long i,s=0;
if(p[0]=='-')
{
i=1;
while(p[i])
{
s=s*10+p[i]-'0';
i++;
}
s*=-1;
}
else
{
i=0;
while(p[i])
{
s=s*10+p[i]-'0';
i++;
}
}
return s;
}
22.double fun(double x , int n)
{
int i;
double a=1,b=1,s=1;
for(i=1;i<=n;i++)
{
a*=x;
b*=i;
s+=a/b;
}
return s;
}23.int fun(int *s, int t, int *k)
{
int i;
*k=0;
for(i=0;iif(s[i]>s[*k]) *k=i;
}24.void fun( char *a,int n )
{
int i=0,j=0,c,k;
while(a[i])
  i++;
c=i;
while(a[i-1]=='*')
{
  j++;
    i--;
}
if(j>n)
{
  k=j-n;
  a[c-k]='\0';
}
}25.int fun( int t)
{
int a=1,b=1,c=0,i;
for(i=4;i<=t;i++)
{if(c{c=a+b;
a=b;
b=c;}
else
break;}
return c;
}
26.STREC fun( STREC *a, char *b )
{
   STREC res;
   int i;
   for(i=0;i   {
      if(strcmp(a[i].num,b)==0)
   {
     res=a[i];
  return res;
   }
   }
   strcpy(res.num,"");
   res.s=-1;
   return res;
}
27.int fun(char *str)
{
int i,j=0;
while(str[j]) j++;
for(i=0;i<=j/2;i++)
if(str[i]!=str[j-i-1]) break;
if(i>=j/2) return 1;
else return 0;
}28、int fun(char *s)
{
int nCnt = 0, i;
for(i = 0; s[i]; i++)
   if('0'<=s[i] && s[i] <= '9')
     ++nCnt;

return nCnt;
}
29.double func(int n)
{
int i, j;
float sum, resu;
resu = 0;
for (i = 1; i <= n; i++)
{
  sum = 0;
  for (j = 1; j <= i; j++)
  {
            sum = sum + j;
  }
  resu = resu + 1 / sum;
}
return resu;
}
30、void fun( char *a , char *s)
{
int i;
for(i = 0; s[i]; i++)
    a[i] = s[i];
a[i] = '\0';
}
31.void fun( char *a, char *h,char *p )
{
int i=0;
for(;a[i]=='*';i++)
a[i]='*';
while(h{ if(*h!='*')
{a[i]=*h;
i++; }
h++;}
while(*h)
{ a[i]=*h;
i++;
h++;
}
a[i]='\0';
} 32.void fun(char (*s)[N], char *b)
{
int i,j,k=0;
for(i=0;ifor(j=0;j{
b[k]=s[j][i];
k++;
}
}33.float fun(int m, int n)
{ int i;
float m1=1.0,n1=1.0,k=1.0;
for(i=1;i<=m;i++) m1*=i;
for(i=1;i<=n;i++) n1*=i;
for(i=1;i<=m-n;i++) k*=i;
return m1/n1/k;
}34.void fun(char *s, char t[])
{
int i=0,j=0,m;
while(m=s[i])
{
  if(m%2==0)
  {
   t[j]=s[i];
         j++;
  }
    i++;
}
t[j]='\0';
}35.double   fun( int m )
{
int i=1;
double sum=0.0;
for(;i<=20;i++){
sum = sum + log(i);
}
sum=sqrt(sum);
return sum;
}
36.double fun()
{
float x0,x1=0.0;
while(1)
{x0=x1;
x1=cos(x0);
if(fabs(x0-x1)<1e-6) break;
}
return x1;
}37.void fun(char *tt, int pp[])
{
int i;
    for(i=0;i<26;i++)
  pp[i]=0;
        i=0;
while(tt[i])
{
  pp[tt[i]-97]++;
         i++;
}
}
38.void fun( int m, int *k, int xx[] )
{
int i,j,c=0;
for(i=2;i<=m;i++)
{
for(j=2;j    if(i%j==0)
   {
    xx[c]=i;
   c++;
    break;
   }
}
*k=c;
}39.double fun( STREC *h )
{
float ave,sum=0.0;
STREC *p;
p=h->next;
while(p)
{sum+=p->s;p=p->next;}
ave=sum/N;
return ave;
}40.void fun(int a, int b, long *c)
{
*c=a/10*100+a%10+b/10*10+b%10*1000;
}41.double fun( STREC *a, STREC *b, int *n )
{
   int i,j;
   double ave,sum=0.0;
   *n=0;
   for(i=0;i   {
     sum+=a[i].s;
   }
   ave=sum/N;
   for(i=0,j=0;i   {
      if(a[i].s<=ave)
   {
      b[j]=a[i];
   j++;
   (*n)++;
   }
      i++;
   }
   return ave;
}
42.void fun(int *w, int p, int n)
{
int i,a[N];
for(i=0;i<=p;i++) a[i]=w[i];
for(i=0;ifor(i=0;i<=p;i++) w[n-(p+1)+i]=a[i];
}
43.void fun(char a[M][N], char *b)
{
int i,k=0;
char *p;
for(i=0;i{ p=a[i];
while(*p) b[k++]=*p++;
}
b[k]='\0';
}
44.void fun (int *a, int *n)
{
int i=0,j=0;
*n=0;
for(;i<=1000;i++)
{
if(i%7==0||i%11==0)
{
    if(i%7==0&&i%11==0)continue;
(*n)++;
a[j++]=i;}
}
return *n;
}
45.int fun(int score[], int m, int below[])
{
int i,j=0,s=0;
for(i=0;is/=m;
for(i=0;i{
if(score[i]{
below[j]=score[i];
j++;
}
}
return j;
}46. 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[i][j]=0;for(i=0;i<3;i++)
for(j=0;j<3;j++)
    b[i][j]=a[i][j]+a[j][i];
}47、int fun( int *s, int x)
{
int i;
for(i = 0; i < N; i++)
   if(s[i] == x)
     return i;
if(i == N)
   return -1;
}48.void fun(char *s, char t[])
{
int i=0,j=0;
while(s[i])
{
if(i%2==1 && s[i]%2==1)
{
t[j]=s[i];
j++;
}
}
t[j]=0;
}49.void fun(int a[], int n , int *max, int *d )
{
int i;
*d=0;
for(i=1;iif(a[i]>a[*d]) *d=i;
*max=a[*d];
}50.void fun(int (*s)[10], int *b, int *n, int mm, int nn)
{
int i,j,k=0;
for(j=0;jfor(i=0;ib[k++]=s[i][j];
*n=k;
}
一、选择题
在下列各题的A）、B）、C）、D）四个选项中，只有一个选项是正确的，请将正确的选项涂写在答题卡相应位置上，答在试卷上不得分。（1）为了避免流程图在描述程序逻辑时的灵活性,提出了用方框图来代替传统的程序流程图,通常也把这种图称为
    A)PAD图
    B)N-S图
    C)结构图
    D)数据流图（2）结构化程序设计主要强调的是
    A)程序的规模
    B)程序的效率
    C)程序设计语言的先进性
    D)程序易读性（3）为了使模块尽可能独立,要求
    A)模块的内聚程度要尽量高,且各模块间的耦合程度要尽量强
    B)模块的内聚程度要尽量高,且各模块间的耦合程度要尽量弱
    C)模块的内聚程度要尽量低,且各模块间的耦合程度要尽量弱
    D)模块的内聚程度要尽量低,且各模块间的耦合程度要尽量强（4）需求分析阶段的任务是确定
    A)软件开发方法
    B)软件开发工具
    C)软件开发费用
    D)软件系统功能（5）算法的有穷性是指
    A)算法程序的运行时间是有限的
    B)算法程序所处理的数据量是有限的
    C)算法程序的长度是有限的
    D)算法只能被有限的用户使用（6）对长度为n的线性表排序,在最坏情况下,比较次数不是n(n-1)/2的排序方法是
    A)快速排序
    B)冒泡排序
    C)直接插入排序
    D)堆排序（7）如果进栈序列为e1,e2,e3,e4,则可能的出栈序列是
    A)e3,e1,e4,e2
    B)e2,e4,e3,e1
    C)e3,e4,e1,e2
    D) 任意顺序（8）将E-R图转换到关系模式时,实体与联系都可以表示成
    A)属性
    B)关系
    C)键
    D)域（9）有三个关系R、S和T如下:
R
B C D
a 0 k1
b 1 n1 S
B C D
f 3 h2
a 0 k1
n 2 x1 T
B C D
a 0 k1 由关系R和S通过运算得到关系T,则所使用的运算为
    A)并
    B)自然连接
    C)笛卡尔积
    D)交（10）下列有关数据库的描述,正确的是
    A)数据处理是将信息转化为数据的过程
    B)数据的物理独立性是指当数据的逻辑结构改变时,数据的存储结构不变
    C)关系中的每一列称为元组,一个元组就是一个字段
    D)如果一个关系中的属性或属性组并非该关系的关键字,但它是另一个关系的关键字,则称其为本关系的外关键字（11）以下叙述中正确的是
    A)用C程序实现的算法必须要有输入和输出操作
    B)用C程序实现的算法可以没有输出但必须要有输入
    C)用C程序实现的算法可以没有输入但必须要有输出
    D)用C程序实现的算法可以既没有输入也没有输出（12）下列可用于C语言用户标识符的一组是
    A)void, define, WORD
    B)a3_3,_123,Car
    C)For, -abc, IF Case
    D)2a, DO, sizeof （13）以下选项中可作为C语言合法常量的是
    A)-80
    B)-080
    C)-8e1.0
    D)-80.0e （14）若有语句:char *line[5];,以下叙述中正确的是
    A) 定义line是一个数组,每个数组元素是一个基类型为char为指针变量
    B) 定义line是一个指针变量,该变量可以指向一个长度为5的字符型数组
    C) 定义line是一个指针数组,语句中的*号称为间址运算符
    D) 定义line是一个指向字符型函数的指针（15）以下定义语句中正确的是
    A)int a=b=0;
    B)char A=65+1,b=′b′;
    C)float a=1,*b=&a,*c=&b;
    D)double a=00;b=1.1; （16）有以下程序段
char ch;    int k;
ch=′a′;
k=12;
printf("%c,%d,",ch,ch,k);    printf("k=%d \n",k);
已知字符a的ASCII码值为97,则执行上述程序段后输出结果是
    A)因变量类型与格式描述符的类型不匹配输出无定值
    B)输出项与格式描述符个数不符,输出为零值或不定值
    C)a,97,12k=12
    D)a,97,k=12 （17）有以下程序
main()
{ int i,s=1;
for (i=1;i<50;i++)
if(!(i%5)&&!(i%3)) s+=i;
printf("%d\n",s);}
程序的输出结果是
    A)409
    B)277
    C)1
    D)91 （18）当变量c的值不为2、4、6时,值也为"真"的表达式是
    A)(c==2)||(c==4)||(c==6)
    B)(c>=2&& c<=6)||(c!=3)||(c!=5)
    C)(c>=2&&c<=6)&&!(c%2)
    D)(c>=2&& c<=6)&&(c%2!=1) （19）若变量已正确定义,有以下程序段
    int a=3,b=5,c=7;
if(a>b) a=b; c=a;
if(c!=a) c=b;
printf("%d,%d,%d\n",a,b,c);
其输出结果是
    A)程序段有语法错
    B)3,5,3
    C)3,5,5
    D)3,5,7 （20）有以下程序
#include
main()
{ int x=1,y=0,a=0,b=0;
switch(x)
{ case 1:
switch(y)
{ case 0:a++; break;
case 1:b++; break;
}
case 2:a++; b++; break;
case 3:a++; b++;
}
printf("a=%d,b=%d\n",a,b);
}
程序的运行结果是
    A)a=1,b=0
    B)a=2,b=2
    C)a=1,b=1
    D)a=2,b=1 （21）下列程序的输出结果是
#include "stdio.h"
main()
{ int i,a=0,b=0;
for(i=1;i<10;i++)
{ if(i%2==0)
{a++;
continue;}
b++;}
printf("a=%d,b=%d",a,b); }
    A)a=4,b=4
    B)a=4,b=5
    C)a=5,b=4
    D)a=5,b=5 （22）已知
#int t=0;
while (t=1)
{...}
则以下叙述正确的是
    A)循环控制表达式的值为0
    B)循环控制表达式的值为1
    C)循环控制表达式不合法
    D)以上说法都不对（23）下面程序的输出结果是
main()
{ int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;
printf("%d\n",*(p+2));}
    A)3
    B)4
    C)1
    D)2 （24）以下错误的定义语句是
    A)int x[][3]={{0},{1},{1,2,3}};
    B)int x[4][3]={{1,2,3},{1,2,3},{1,2,3},{1,2,3}};
    C)int x[4][]={{1,2,3},{1,2,3},{1,2,3},{1,2,3}};
    D)int x[][3]={1,2,3,4}; （25）有以下程序
void ss(char *s,char t)
{ while(*s)
{ if(*s==t)*s=t-′a′+′A′;
s++; } }
main()
{ char str1[100]="abcddfefdbd",c=′d′;
ss(str1,c); printf("%s\n",str1);}
程序运行后的输出结果是
    A)ABCDDEFEDBD
    B)abcDDfefDbD
    C)abcAAfefAbA
    D)Abcddfefdbd （26）有如下程序
main()
{ char ch[2][5]={"6937","8254"},*p[2];
int i,j,s=0;
for(i=0;i<2;i++)p[i]=ch[i];
for(i=0;i<2;i++)
for(j=0;p[i][j]>′\0′;j+=2)
s=10*s+p[i][j]-′0′;
printf("%d\n",s);}
该程序的输出结果是
    A)69825
    B)63825
    C)6385
    D)693825 （27）有定义语句:char s[10];,若要从终端给s输入5个字符,错误的输入语句是
    A)gets(&s[0]);
    B)scanf("%s",s+1);
    C)gets(s);
    D)scanf("%s",s[1]); （28）以下叙述中错误的是
    A)在程序中凡是以"#"开始的语句行都是预处理命令行
    B)预处理命令行的最后不能以分号表示结束
    C)#define MAX 是合法的宏定义命令行
    D)C程序对预处理命令行的处理是在程序执行的过程中进行的（29）设有以下说明语句
typedef struct
{ int n;
char ch[8];
} PER;
则下面叙述中正确的是
    A)PER 是结构体变量名
    B)PER是结构体类型名
    C)typedef struct 是结构体类型
    D)struct 是结构体类型名（30）以下叙述中错误的是
    A)gets函数用于从终端读入字符串
    B)getchar函数用于从磁盘文件读入字符
    C)fputs函数用于把字符串输出到文件
    D)fwrite函数用于以二进制形式输出数据到文件（31）以下能正确定义一维数组的选项是
    A)int a[5]={0,1,2,3,4,5};
    B)char a[]={′0′,′1′,′2′,′3′,′4′,′5′,′\0′};
    C)char a={′A′,′B′,′C′};
    D)int a[5]="0123"; （32）有以下程序
#include
main()
{ char p[]={′a′, ′b′, ′c′},q[10]={ ′a′, ′b′, ′c′};
printf("%d%d\n",strlen(p),strlen(q));}
以下叙述中正确的是
    A) 在给p和q数组置初值时,系统会自动添加字符串结束符,故输出的长度都为3
    B) 由于p数组中没有字符串结束符,长度不能确定,但q数组中字符串长度为3
    C) 由于q数组中没有字符串结束符,长度不能确定,但p数组中字符串长度为3
    D) 由于p和q数组中都没有字符串结束符,故长度都不能确定（33）有以下程序
#include
#include
void fun(char *s[],int n)
{ char *t;        int i,j;
for(i=0;ifor(j=i+1;j if(strlen(s[i])>strlen(s[j])) {t=s[i];s[i]:s[j];s[j]=t;}
}
main()
{ char *ss[]={"bcc","bbcc","xy","aaaacc","aabcc"};
fun(ss,5);      printf("%s,%s\n",ss[0],ss[4]);
}
程序的运行结果是
    A)xy,aaaacc
    B)aaaacc,xy
    C)bcc,aabcc
    D)aabcc,bcc （34）有以下程序
#include
int f(int x)
{ int y;
if(x==0||x==1) return(3);
y=x*x-f(x-2);
return y;
}
main()
{ int z;
z=f(3);      printf("%d\n",z);
}
程序的运行结果是
    A)0
    B)9
    C)6
    D)8 （35）下面程序段的运行结果是
char str[]="ABC",*p=str;
printf("%d\n",*(p+3));
    A)67
    B)0
    C)字符′C′的地址
    D)字符′C′ （36）若有以下定义:
struct link
{ int data;
struct link *next;
} a,b,c,*p,*q;
且变量a和b之间已有如下图所示的链表结构:
指针p指向变量a,q指向变量c。则能够把c插入到a和b 之间并形成新的链表的语句组是:
    A)a.next=c; c.next=b;
    B)p.next=q; q.next=p.next;
    C)p->next=&c; q->next=p->next;
    D)(*p).next=q; (*q).next=&b; （37）对于下述程序,在方式串分别采用"wt"和"wb"运行时,两次生成的文件TEST的长度分别是
#include
void main()
{ FILE *fp=fopen("TEST",);
fputc(′A′,fp);fputc(′\n′,fp);
fputc(′B′,fp);fputc(′\n′,fp);
fputc(′C′,fp);
fclose(fp); }
    A)7字节、7字节
    B)7字节、5字节
    C)5字节、7字节
    D)5字节、5字节（38）变量a中的数据用二进制表示的形式是01011101,变量b中的数据用二进制表示的形式是11110000。若要求将a的高4位取反,低4位不变,所要执行的运算是
    A)a^b
    B)a|b
    C)a&b
    D)a<<4（39）下面的程序段运行后,输出结果是
int i,j,x=0;
static int a[8][8];
for(i=0;i<3;i++)
for(j=0;j<3;j++)
a[i][j]=2*i+j;
for(i=0;i<8;i++)
    x+=a[i][j];
printf("%d",x);
    A)9
    B)不确定值
    C)0
    D)18 （40）下列程序执行后的输出结果是
void func(int *a,int b[])
{ b[0]=*a+6; }
main()
{ int a,b[5];
a=0; b[0]=3;
func(&a,b); printf("%d\n",b[0]);}
    A)6
    B)7
    C)8
    D)9 二、填空题
请将每一个空的正确答案写在答题卡序号的横线上，答在试卷上不给分。
（1）测试的目的是暴露错误,评价程序的可靠性;而【1】   的目的是发现错误的位置并改正错误。（2）某二叉树中度为2的结点有18个,则该二叉树中有   【2】   个叶子结点。（3）当循环队列非空且队尾指针等于队头指针时,说明循环队列已满,不能进行入队运算。这种情况称为   【3】   。（4）在关系模型中,把数据看成一个二维表,每一个二维表称为一个   【4】   。（5）在计算机软件系统的体系结构中,数据库管理系统位于用户和【5】之间。（6）以下程序的输出结果是   【6】   。
main()
{ char c=′z′;
printf("%c",c-25); } （7）阅读下面语句,则程序的执行结果是   【7】。
#include "stdio.h"
main()
{    int a=-1,b=1,k;
if((++a<0)&&!(b--<=0))
    printf("%d,%d\",a,b);
else printf("%d,%d\n",b,a);} （8）下列程序的输出结果是【8】。
main()
{ int i;
for(i=1;i+1;i++)
{ if(i>4)
{ printf("%d\n",i);
break; }
printf("%d\n",i++);}}（9）以下程序的定义语句中,x[1]的初值是【9】 ,程序运行后输出的内容是【10】。
#include
main()
{ int x[]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16},*p[4],i;
for(i=0;i<4;i++)
{ p[i]=&x[2*i+1];
printf("%d",p[i][0]);
}
printf("\n");)
} （10）以下程序的输出结果是【11】。
#include
void swap(int *a, int *b)
{ int *t;
t=a; a=b; b=t;
}
main()
{ int i=3,j=5,*p=&i,*q=&j;
swap(p,q);    printf("%d %d\N,*p,*q))
} （11）以下程序的输出结果是   【12】   。
main()
{ char s[]="ABCD", *p;
for(p=s+1; pfloat fun(int x,int y)
{ return(x+y);}
main()
{ int a=2,b=5,c=8;
printf("%3.0f\n",fun((int)fun(a+c,b),a-c));} （13）有如下图所示的双链表结构,请根据图示完成结构体的定义:
lhead data rchild
struct aa
{   int data;
【14】    }node;
（14）fseek函数的正确调用形式是【15】。一、选择题(1)B
    【解析】 N-S图是由Nassi 和 Shneiderman 提出的一种符合程序化结构设计原则的图形描述工具。它的提出是为了避免流程图在描述程序逻辑时的随意性上灵活性。(2)D
    【解析】结构化程序设计方法的主要原则可以概括为自顶向下、逐步求精、模块化及限制使用goto语句,总的来说可使程序结构良好、易读、易理解、易维护。(3)B
    【解析】模块的独立程度可以由两个定性标准度量:耦合性和内聚性。耦合性是衡量不同模块彼此间互相依赖(连接)的紧密程度;内聚性是衡量一个模块内部各个元素彼此结合的紧密程度。一般来说,要求模块之间的耦合尽可能地低,而内聚性尽可能地高。(4)D
    【解析】需求分析是软件定义时期的最后一个阶段,它的基本任务就是详细调查现实世界要处理的对象(组织、部门、企业等),充分了解原系统的工作概况,明确用户的各种需求,然后在此基础上确定新系统的功能。选项A)软件开发方法是在总体设计阶段需完成的任务;选项B)软件开发工具是在实现阶段需完成的任务;选项C)软件开发费用是在可行性研究阶段需完成的任务。(5)A
    【解析】算法具有5个特性:① 有穷性:一个算法必须(对任何合法的输入值)在执行有穷步之后结束,且每一步都可在有限时间内完成,即运行时间是有限的;② 确定性:算法中每一条指令必须有确切的含义,读者理解时不会产生歧义;③ 可行性:一个算法是可行的,即算法中描述的操作都是可以通过已经实现的基本运算执行有限次来实现;④ 输入:一个算法有零个或多个输入,这些输入取自于某个特定的对象的集合;⑤ 输出:一个算法有一个或多个输出。(6)D
    【解析】在最坏情况下,快速排序、冒泡排序和直接插入排序需要的比较次数都为n(n-1)/2,堆排序需要的比较次数为nlog2n。(7)B
    【解析】由栈"后进先出"的特点可知:A)中e1不可能比e2先出,C)中e1不可能比e2先出,D)中栈是先进后出的,所以不可能是任意顺序。B)中出栈过程如下图所示:
(8)B
    【解析】关系数据库逻辑设计的主要工作是将E-R图转换成指定RDBMS中的关系模式。首先,从E-R图到关系模式的转换是比较直接的,实体与联系都可以表示成关系,E-R图中属性也可以转换成关系的属性,实体集也可以转换成关系。(9)D
    【解析】在关系运算中,交的定义如下:设R1和R2为参加运算的两个关系,它们具有相同的度n,且相对应的属性值取自同一个域,则R1 R2为交运算,结果仍为度等于n的关系,其中,交运算的结果既属于R1,又属于R2。(10)D
    【解析】数据处理是指将数据转换成信息的过程,故选项A)叙述错误;数据的物理独立性是指数据的物理结构的改变,不会影响数据库的逻辑结构,故选项B)叙述错误;关系中的行称为元组,对应存储文件中的记录,关系中的列称为属性,对应存储文件中的字段,故选项C)叙述错误。(11)C
    【解析】算法具有的5个特性是:有穷性;确定性;可行性;有0个或多个输入;有一个或多个输出。所以说,用C程序实现的算法可以没有输入但必须要有输出。(12)B
    【解析】 C语言规定标识符只能由字母、数字和下划线3种字符组成,且第一个字符必须为字母或下划线,排除选项C)和D);C语言中还规定标识符不能为C语言的关键字,而选项A)中void为关键字,故排除选项A)。(13)A
    【解析】选项B)项中,以0开头表示是一个八进制数,而八进制数的取值范围是0~7,所以-080是不合法的;选项C)和D)中,e后面的指数必须是整数,所以也不合法。(14)A
    【解析】 C语言中[ ]比*优先级高,因此line先与[5]结合,形成line[5]形式,这是数组形式,它有5个元素,然后再与line前面的"*"结合,表示此数组是一个指针数组,每个数组元素都是一个基类型为char的指针变量。(15)B
    【解析】本题考查变量的定义方法。如果要一次进行多个变量的定义,则在它们之间要用逗号隔开,因此选项A)和D)错误。在选项C)中,变量c是一个浮点型指针,它只能指向一个浮点型数据,不能指向指针变量b,故选项C)错误。(16)D
    【解析】输出格式控制符%c表示将变量以字符的形式输出;输出格式控制符%d表示将变量以带符号的十进制整型数输出,所以第一个输出语句输出的结果为a,97;第二个输出语句输出的结果为k=12。(17)D
    【解析】本题是计算50之内的自然数相加之和,题中if语句括号中的条件表达式!(i%5)&&!(i%3)表明只有能同时被5和3整除的数才符合相加的条件,1~ 49之间满足这个条件的只有,15、30和45,因为s的初始值为1,所以s=1+15+30+45=91。(18)B
    【解析】满足表达式(c>=2&&c<=6)的整型变量c的值是2,3,4,5,6。当变量c的值不为2,4,6时,其值只能为3或5,所以表达式c!=3和c!=5中至少有一个为真,即不论c为何值,选项B中的表达式都为"真"。(19)B
    【解析】两个if语句的判断条件都不满足,程序只执行了c=a这条语句,所以变量c的值等于3,变量b的值没能变化,程序输出的结果为3,5,3。所以正确答案为B)。(20)D
    【解析】本题考查switch语句,首先,x=1符合条件case 1,执行switch(y)语句,y=0符合case 0语句,执行a++并跳出switch(y)语句,此时a=1。因为case 1语句后面没有break语句,所以向后执行case 2语句,执行a++,b++,然后跳出switch(x),得a=2,b=1。(21)B
    【解析】continue语句的作用是跳过本次循环体中余下尚未执行的语句,接着再一次进行循环条件的判定。当能被2整除时,a就会增1,之后执行continue语句,直接执行到for循环体的结尾,进行i++,判断循环条件。(22)B
    【解析】t=1是将t赋值为1,所以循环控制表达式的值为1。判断t是否等于1时,应用t==1,注意"="与"=="的用法。(23)A
    【解析】在C语言中,数组元素是从0开始的。指针变量p指向数组的首地址,(p+2)就会指向数组中的第3个元素。题目中要求输出的是元素的值。(24)C
    【解析】本题考查的是二维数组的定义和初始化方法。C语言中,在定义并初始化二维数组时,可以省略数组第一维的长度,但是不能省略第二维的长度。故选项C)错误。(25)B
    【解析】在内存中,字符数据以ASCII码存储,它的存储形式与整数的存储形式类似。C语言中,字符型数据和整型数据之间可以通用,也可以对字符型数据进行算术运算,此时相当于对它们的ASCII码进行算术运算,在本题中,s++相当于s=s+1,即让s指向数组中的下一个元素。(26)C
    【解析】该题稍微难一点。主要要搞清楚以下几点:①定义了一个指针数组char *p[2]后,程序中第一个循环for(i=0;i<2;i++)p[i]=ch[i];的作用,是使指针数组的p[0]元素(它本身是一个指针)指向了二维数组ch的第一行字符串,并使指针数组的p[1]元素指向二维数组ch的第二行字符串,这样,就使指针数组p和二维数组ch建立起了一种对应关系,以后对二维数组ch的某个元素的引用就有两种等价的形式:ch[i][j]或p[i][j]。②对二维数组ch的初始化,使其第一行ch[0]中存入了字符串"6937",第二行ch[1]中的内容为字符串"8254"。③程序中第二个循环中的循环体s=s*10+p[i][j]-'0';的功能是这样的,每执行一次,将s中的值乘以10(也即,将s中的数值整体向左移动一位,并在空出来的个位上添一个0),再将当前p[i][j]中的字符量转换为相应的数字,然后把这个数字加到s的个位上。④注意到内层循环的循环条件p[i][j]>'\0 '是指p[i][j]中的字符只要不是字符串结束标志'\0'就继续循环,语句j+=2；是使下标j每次增加2,也即一个隔一个地从p［i］所指向的字符串中取出字符。经过上述解析后，不难看出，该程序首先从p［0］所指向的字符串"6937"中一个隔一个地取出字符，分别是'6'和'3'，然后从p［1］所指向的字符串"8254"中一个隔一个地取出字符，分别是'8'和'5'，同时经过转换和相加运算后，结果s中的值应该是6385。(27)D
    【解析】在格式输入中,要求给出的是变量的地址,而D)答案中给出的s[1]是一个值的表达式。(28)D
    【解析】 C语言中的预处理命令以符号#开头,这些命令是在程序编译之前进行处理的,选项D)的描述错误。(29)B
    【解析】本题中,typedef声明新的类型名PER来代替已有的类型名,PER代表上面指定的一个结构体类型,此时,也可以用PER来定义变量。(30)B
    【解析】 getchar函数的作用是从终端读入一个字符。(31)B
    【解析】选项A)中,定义的初值个数大于数组的长度;选项C)中,数组名后少了中括号;选项D)中,整型数组不能赋予字符串。(32)A
    【解析】在给p和q数组赋初值时,系统会自动添加字符串结束符,从题目中可以看出数组p和q都有3个字符,所以长度均为3。(33)A
    【解析】函数fun(char *s[],int n)的功能是对字符串数组的元素按照字符串的长度从小到大排序。在主函数中执行fun(ss,5)语句后,*ss[]={"xy", "bcc", "bbcc", "aabcc", "aaaacc"},ss[0],ss[4]的输出结果为xy,aaaacc。(34)C
    【解析】函数int f(int x)是一个递归函数调用,当x的值等于0或1时,函数值等于3,其他情况下y=x2-f(x-2),所以在主函数中执行语句z=f(3)时,y=3*3-f(3-2)=9-f(1)=9-3=6。(35)B
    【解析】考查指向字符串的指针变量。在该题中,指针变量p指向的应该是该字符串中的首地址,p+3指向的是字符串结束标志'\0'的地址,因而*(p+3)的值为0。(36)D
    【解析】本题考查链表的数据结构,必须利用指针变量才能实现,即一个结点中应包含一个指针变量,用它存放下一结点的地址。(37)B
    【解析】以"wt"方式写入的是字符文件,转义字符'\n'被看作两个字符来处理。而"wb"方式写入的是二进制文件,转义字符'\n'是一个字符。(38)A
    【解析】本题考查的是位运算的知识,对于任何二进制数,和1进行异或运算会让其取反,而和0进行异或运算不会产生任何变化。(39)C
    【解析】本题主要考查的是用二维数组首地址和下标来引用二维数组元素的方法。通过分析可知,程序中的双重循环定义了一个如下的二维数组:
0    1    2
2    3    4
4    5    6由于数组的下标是从0开始的,所以二维数组元素a[i][j]表示的是二维数组a的第i+1行、第j+1列对应位置的元素。 (40)A
    【解析】函数的参数不仅可以是整型、实型、字符型等数据,还可以是指针型。它的作用是将一个变量的地址传递到另一个函数中。当数组名作参数时,如果形参数组中的各元素的值发生变化,实参数组元素的值也将随之发生变化。
二、选择题(1)【1】调试
    【解析】软件测试的目标是在精心控制的环境下执行程序,以发现程序中的错误,给出程序可靠性的鉴定;调试也称排错,它是一个与测试既有联系又有区别的概念。具体来说,测试的目的是暴露错误,评价程序的可靠性,而调试的目的是发现错误的位置,并改正错误。(2)【2】19
    【解析】在任意一棵二叉树中,度为0的结点(即叶子结点)总是比度为2的结点多一个。(3)【3】上溢
    【解析】入队运算是指在循环队列的队尾加入一个新元素。这个运算有两个基本操作:首先将队尾指针进一(即rear=rear+1),并当rear=m+1时,置rear=1;然后将新元素插入队尾指针指向的位置。当循环队列非空(s=1)且队尾指针等于队头指针时,说明循环队列已满,不能进行入队运算,这种情况称为"上溢"。(4)【4】关系
    【解析】在关系模型中,把数据看成一个二维表,每一个二维表称为一个关系。表中的每一列称为一个属性,相当于记录中的一个数据项,对属性的命名称为属性名;表中的一行称为一个元组,相当于记录值。(5)【5】操作系统或OS
    【解析】数据库管理系统是数据库的机构,它是一种系统软件,负责数据库中的数据组织、数据操纵、数据维护、控制及保护和数据服务。位于用户和操作系统之间。(6)【6】 a
    【解析】 'z'的ASCII码值为122,经过c-25运算后,得97,以字符形式输出是a。(7)【7】 1,0
    【解析】与运算两边的语句必须同时为真时,结果才为真。当执行完if((++a<0)&&!(b--<=0))时,a,b的值已经发生了变化。(8)【8】 1
3
5
    【解析】本题考查了for循环语句的使用,break语句用在本题中是结束for循环直接跳出循环体外。当i=1时,因为if语句条件不满足,所以直接执行printf("%d\n",i++);输出1，同时i自加1；执行第二次for循环时，i=3;同样的if语句条件不满足，所以直接执行printf("%d\n",i++);输出3，同时i自加1；执行第三次for循环时，i=5,if语句条件满足，所以执行printf("%d\n",i),输出5，然后break语句跳出了for循环。(9)【9】 2
【10】 2 4 6 8
    【解析】在主函数中根据整型数组x[]的定义可知,x[1]的初值等于2。在for循环语句中,当i=0时,p[0]=&x[1],p[0][0]=2; 当i=1时,p[1]=&x[3],p[1][0]=4;当i=2时,p[2]=&x[5],p[2][0]=6;当i=3时,p[3]=&x[7],p[3][0]=8,所以程序输出的结果为2、4、6、8。(10)【11】 35
    【解析】函数swap(int *a,int *b)的功能是实现*a和*b中两个数据的交换,在主函数中调用swap(p,q)后,形参指针变量a和b分别指向i和j,在swap(int *a,int *b)执行完后,指针变量a和b分别指向j和i,而指针变量p,q所指向变量的值没有发生变化,所以输出结果为35。(11)【12】 BCD
CD
D
    【解析】本题考查指向字符串的指针的运算方法。指针变量p首先指向字符串中的第一个字符A,执行p=s+1后,p指向字符串中的第二个字符B,然后输出值"BCD"并换行,依次执行循环语句。(12)【13】 9
    【解析】本题考查函数的综合知识。首先,我们可以利用强制转换类型转换运算符,将一个表达式转换成所需类型。如:(double)a是将a转换成double类型;(int)(x+y)是将x+y的值转换成整型。
本题可按部就班地逐步运算:
fun((int)fun(a+c,b),a-c)
fun((int)fun(10,5),2-8)
fun((int)15.000000,-6)
fun(15,-6)
9(13)【14】 struct aa *lhead,*rchild;
    【解析】结构体对链表的定义。(14)【15】 fseek(文件指针,位移量,起始点)
    【解析】本题考查函数fseek的用法。fseek函数的调用形式为:
fseek(文件指针,位移量,起始点)
"起始点"用0,1或2代替,其中,0代表"文件开始";1为"当前位置";2为"文件末尾"。"位移量"指以"起始点"为基点,向前移动的字节数。ANSI C和大多数C版本要求位移量是long型数据,这样当文件的长度大于64k时不致出现问题。ANSI C标准规定在数字的末尾加一个字母L,就表示long型。
一、选择题
在下列各题的A）、B）、C）、D）四个选项中，只有一个选项是正确的，请将正确的选项涂写在答题卡相应位置上，答在试卷上不得分。（1）程序流程图中带有箭头的线段表示的是
    A)图元关系
    B)数据流
    C)控制流
    D)调用关系（2）下面不属于软件设计原则的是
    A)抽象
    B)模块化
    C)自底向上
    D)信息隐蔽（3）下列选项中，不属于模块间耦合的是
    A)数据耦合
    B)标记耦合
    C)异构耦合
    D)公共耦合（4）下列叙述中，不属于软件需求规格说明书的作用的是
    A)便于用户、开发人员进行理解和交流
    B)反映出用户问题的结构，可以作为软件开发工作的基础和依据
    C)作为确认测试和验收的依据
    D)便于开发人员进行需求分析（5）算法的时间复杂度是指
    A)执行算法程序所需要的时间
    B)算法程序的长度
    C)算法执行过程中所需要的基本运算次数
    D)算法程序中的指令条数（6）已知数据表A中每个元素距其最终位置不远，为节省时间，应采用的算法是
    A)堆排序
    B)直接插入排序
    C)快速排序
    D)B)和C)（7）栈底至栈顶依次存放元素A、B、C、D，在第五个元素E入栈前，栈中元素可以出栈，则出栈序列可能是
    A)ABCED
    B)DCBEA
    C)DBCEA
    D)CDABE（8）数据库设计包括两个方面的设计内容，它们是
    A)概念设计和逻辑设计
    B)模式设计和内模式设计
    C)内模式设计和物理设计
    D)结构特性设计和行为特性设计（9）关系表中的每一横行称为一个
    A)元组
    B)字段
    C)属性
    D)码（10）设有表示学生选课的三张表，学生S(学号，姓名，性别，年龄，身份证号)，课程C(课号，课名)，选课SC(学号，课号，成绩)，则表SC的关键字 (键或码)为
    A)课号，成绩
    B)学号，成绩
    C)学号，课号
    D)学号，姓名，成绩（11）以下不正确的叙述是
    A)在C程序中，逗号运算符的优先级最低
    B)在C程序中，APH和aph是两个不同的变量
    C)若a和b类型相同，在计算了赋值表达式a=b后b中的值将放入a中，而b中的值不变
    D)当从键盘输入数据时，对于整型变量只能输入整型数值，对于实型变量只能输入实型数值（12）请选出可用作C语言用户标识符的是
    A)void,define,WORD
    B)a3_b3,_123,IF
    C)FOR,--abc,Case
    D)2a,Do,Sizeof（13）以下选项中，不能作为合法常量的是
    A)1.234e04
    B)1.234e0.4
    C)1.234e+4
    D)1.234e0（14）在C语言中,运算对象必须是整型数的运算符是
    A)%
    B)\
    C)%和\
    D)**（15）若变量均已正确定义并赋值,以下合法的C语言赋值语句是
    A)x=y==5;
    B)x=n%2.5;
    C)x+n=i;
    D)x=5=4+1; （16）有以下程序段
char ch;    int k;
ch=′a′; k=12;
printf("%c,%d,",ch,ch,k);    printf("k=%d \n",k);
已知字符a的ASCII码值为97,则执行上述程序段后输出结果是
    A)因变量类型与格式描述符的类型不匹配输出无定值
    B)输出项与格式描述符个数不符,输出为零值或不定值
    C)a,97,12k=12
    D)a,97,k=12（17）已知字母A的ASCII代码值为65,若变量kk为char型,以下不能正确判断出kk中的值为大写字母的表达式是
    A)kk>=′A′&& kk<=′Z′
    B)!(kk>=′A′||kk<=′Z′)
    C)(kk+32)>=′a′&&(kk+32)<=′Z′
    D)isalpha(kk)&&(kk<91) （18）当变量c的值不为2、4、6时,值也为"真"的表达式是
    A)(c==2)||(c==4)||(c==6)
    B)(c>=2&& c<=6)||(c!=3)||(c!=5)
    C)(c>=2&&c<=6)&&!(c%2)
    D)(c>=2&& c<=6)&&(c%2!=1)（19）若有条件表达式 (exp)?a++:b--,则以下表达式中能完全等价于表达式(exp)的是
    A)(exp==0)
    B)(exp!=0)
    C)(exp==1)
    D)(exp!=1)（20）以下不正确的定义语句是
    A)double x[5]={2.0,4.0,6.0,8.0,10.0};
    B)int y[5]={0,1,3,5,7,9};
    C)char c1[]={′1′,′2′,′3′,′4′,′5′};
    D)char c2[]={′\x10′, ′xa′, ′\x8′};（21）下列程序执行后的输出结果是
main()
{ int a[3][3], *p,i;
p=&a[0][0];
for(i=1; i<9; i++)p[i]=i+1;
printf("%d\n",a[1][2];)
    A)3
    B)6
    C)9
    D)随机数（22）设有以下程序段
int x=0,s=0;
while(!x!=0)s+=++x;
printf("%d",s);
则
    A)运行程序段后输出0
    B)运行程序段后输出1
    C)程序段中的控制表达式是非法的
    D)程序段执行无限次（23）(23)下面程序段的运行结果是
char *s="abcde";
s+=2;printf("%d",s);
    A)cde
    B)字符′c′
    C)字符′c′的地址
    D)无确定的输出结果（24）阅读下列程序,则执行后的结果为
#include "stdio.h"
main()
{   int c[][4]={1,2,3,4,5,6,7,34,213,56,62,3,23,12,34,56};
printf("%x,%x\n",c[2][2],*(*(c+1)+1));}
    A)3e,6
    B)62,5
    C)56,5
    D)3E,6 （25）下面判断正确的是
    A)char *a="china";等价于 char *a;*a="china";
    B)char str[5]={"china"};等价于char str[]={"china"};
    C)char *s="china";等价于 char *s;s="china";
    D)char c[4]="abc",d[4]="abc";等价于char c[4]=d[4]="abc"; （26）若有定义:int a[2][3];,以下选项中对a数组元素正确引用的是
    A)a[2][!1]
    B)a[2][3]
    C)a[0][3]
    D)a[1>2][!1] （27）有定义语句:char s[10];,若要从终端给s输入5个字符,错误的输入语句是
    A)gets(&s[0]);
    B)scanf("%s",s+1);
    C)gets(s);
    D)scanf("%s",s[1]);（28）有以下程序
#include
#define N 5
#define M N+1
#define f(x) (x*M)
main()
{ int i1,i2;
i1=f(2);
i2=f(1+1);
printf("%d %d\n",i1,i2);
}
程序的运行结果是
    A)12 12
    B)11 7
    C)11 11
    D)12 7（29）若有以下说明和定义
union dt
{ int a; char b; double c;}data;
以下叙述中错误的是
    A)data的每个成员起始地址都相同
    B)变量data所占内存字节数与成员c所占字节数相等
    C)程序段:data.a=5;printf("%f\n",data.c);输出结果为5.000000
    D)data可以作为函数的实参（30）有以下程序
#include
main()
{FILE *fp;int k,n,a[6]={1,2,3,4,5,6};
fp=fopen("d2.dat","w");
fprintf(fp,"%d%d%d\n",a[0],a[1],a[2]);
fprintf(fp,"%d%d%d\n",a[3],a[4],a[5]);
fclose(fp);
fp=fopen("d2.dat","r");
fscanf(fp,"%d%d",&k,&n);printf("%d%d\n",k,n);
fclose(fp);
}
程序运行后的输出结果是
    A)1 2
    B)1 4
    C)123 4
    D)123 456（31）若已定义
int a[]={0,1,2,3,4,5,6,7,8,9}, *p=a,i;
其中则对a数组元素不正确的引用是
    A)a[p-a]
    B)*(&a[i])
    C)p[i]
    D)a[10]（32）有以下程序
#include
void fun(int *s,int n1,int n2)
{ int i,j,t;
i=n1; j=n2;
while(i}
main()
{ int a[10]={1,2,3,4,5,6,7,8,9,0},k;
fun(a,0,3); fun(a,4,9); fun(a,0,9);
for(k=0;k}
程序的运行结果是
    A)0987654321
    B)4321098765
    C)5678901234
    D)0987651234
（33）阅读下列程序,当运行函数时,输入asd af aa z67,则输出为
#include
#include
#include
int fun (char *str)
{ int i,j=0;
for(i=0;str[i]!=′ \0′;i++)
if(str[i]!=′ ′)str[j++]=str[i];
str[j]= ′\0′;
}
main()
{
char str[81];
int n;
printf("Input a string : ");
gets(str);
puts(str);
fun(str);
printf("%s\n",str);
}
    A)asdafaaz67
    B)asd af aa z67
    C)asd
    D)z67（34）有以下程序
int fun(int n)
{if(n==1)return 1;
else
    return(n+fun(n-1));
}
main()
{int x;
    scanf("%d",&x); x=fun(x);printf("%d\n",x)
}
执行程序时,给变量x输入10,程序的输出结果是
    A)55
    B)54
    C)65
    D)45（35）下面程序段中,输出*的个数是
char *s="\ta\018bc";
for(;*s!='\0';s++)printf("*");
    A)9
    B)5
    C)6
    D)7 （36）C语言结构体类型变量在程序运行期间
    A)TC环境在内存中仅仅开辟一个存放结构体变量地址的单元
    B)所有的成员一直驻留在内存中
    C)只有最开始的成员驻留在内存中
    D)部分成员驻留在内存中（37）已知函数的调用形式为fread(buf,size,count,fp),参数buf的含义是
    A)一个整型变量,代表要读入的数据项总数
    B)一个文件指针,指向要读的文件
    C)一个指针,指向要读入数据的存放地址
    D)一个存储区,存放要读的数据项（38）设有以下语句
char x=3,y=6,z;
z=x^y<<2;
则z的二进制值是
    A)00010100
    B)00011011
    C)00011100
    D)00011000（39）在C语言中,只有在使用时才占用内存单元的变量,其存储类型是
    A)auto和register
    B)extern和register
    C)auto和static
    D)static和register（40）设有定义语句int (*f)(int);,则以下叙述正确的是
    A)f是基类型为int的指针变量
    B)f是指向函数的指针变量,该函数具有一个int类型的形参
    C)f是指向int类型一维数组的指针变量
    D)f是函数名,该函数的返回值是基类型为int类型的地址二、填空题
请将每一个空的正确答案写在答题卡序号的横线上，答在试卷上不给分。
（1）测试用例包括输入值集和【1】值集。（2）在树形结构中,树根结点没有   【2】   。（3）数据结构分为逻辑结构与存储结构,线性链表属于   【3】   。（4）一个项目具有一个项目主管,一个项目主管可管理多个项目,则实体"项目主管"与实体"项目"的联系属于【4】的联系。（5）数据库设计分为以下6个设计阶段:需求分析阶段、   【5】   、逻辑设计阶段、物理设计阶段、实施阶段、运行和维护阶段。（6）阅读下面程序段,则执行后输出的结果是【6】。
#include "stdio.h"
main()
{   char fun(char,int);
char a=′A′;
int b=13;
a=fun(a,b);
putchar(a);}
char fun(char a,int b)
{ char k;
k=a+b;
return k;}（7）函数fun的返回值是【7】
fun(char *a,char *b)
{ int num=0,n=0;
while(*(a+num)!='\0')mm++;
while(b[n]){*(a+num)=b[n];num++;n++;}
return num;
}（8）以下程序的功能是:删去一维数组中所有相同的数,使之只剩一个。数组中的数已按由小到大的顺序排列,函数返回删除后数组中数据的个数。
例如,若一维数组中的数据是:
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。
请填空。
#include

全国计算机等级考试二级c语言 4月份计算机等级考试C语言二级 2006年4月全国计算机等级考试二级C 求94年全国计算机等级考试二级C语言笔试试题！全国计算机等级考试二级C 上级考试有几道题全国计算机等级考试二级教程 C语言程序设计全国计算机等级考试二级C语言和江苏计算机等级考试二级C语言考哪个较合适全国计算机等级考试二级考哪几门？ access全国二级计算机等级考试 2006年4月份全国计算机等级考试C语言成绩什么时候可以知道？参加2006年4月1日的全国计算机等级考试二级C的请进哪有2006年4月全国计算机等级考试二级C试题? 想知道刚刚过去的2006年4月全国计算机等级考试二级C的答案全国高等学校计算机等级考试（江西考区）二级c笔试答案全国计算机等级考试模拟软件二级C语言安装程序序列号全国计算机等级考试二级C的重点章节是??? 《全国计算机等级考试二级教程C语言程序设计》书后习题答案有关全国计算机等级考试二级C语言的一些问题。请问2006年9月份的全国计算机等级考试二级还有没有visual fox啊什么时候会取消？？计算机等级考试二级C笔试计算机等级考试二级C笔试计算机等级考试二级c语言计算机等级考试二级C 二级C语言计算机等级考试