全国二级C语言1~10套试题汇编——————编程练习题

第一套：

1.1：修改部分学生成绩

void fun(char  *filename, STU  n)
{
 FILE  *fp;
/**********found**********/
  fp = fopen(filename, "rb+");
/**********found**********/
  fseek(fp, -(long)sizeof(STU), SEEK_END);
/**********found**********/
  fwrite(&n, sizeof(STU), 1, fp);
  fclose(fp);
}

1.2:单链表遍历数据信息

typedef  struct  aa
{ 
 int  data;
 struct  aa  *next;
} NODE;
NODE *Creatlink(int  n, int  m)
{  
NODE  *h=NULL, *p, *s;
   int  i;
/**********found***********/
   p=(NODE *)malloc(sizeof(NODE));
   h=p;
   p->next=NULL;
   for(i=1; i<=n; i++)
   {  s=(NODE *)malloc(sizeof(NODE));
      s->data=rand()%m;      s->next=p->next;
      p->next=s;             p=p->next;
   }
/**********found***********/
   return  h;
}

1.3:统计行式单词的个数：

int fun(char *s)
{
	int i,j=0;
	for(i=0;s[i]!='\0';i++)
		if(s[i]!=' '&&((s[i+1]==' ')||(s[i+1]=='\0')))
			 j++;
  return j;
}

第二套：

2.1：输出大于平均值的数

double fun(double  x[],double  *y)
{ 
int  i,j;    double  av;
/**********found**********/
  av=0.0;
/**********found**********/
  for(i=0; i<N; i++)  
	  av=av+x[i]/N;
  for(i=j=0; i<N; i++)
/**********found**********/
    if(x[i]>av)  y[j++]= x[i];
  y[j]=-1;
  return  av;
}

2.2:计算数学公式

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

2.3:找出最低学生成绩的数据

typedef struct ss
{ 
char num[10]; 
  int s;
} STU;
void fun(STU a[], STU *s)
{
	int i;
	*s=a[0];
	for(i=0;i<N;i++)
		if(s->s>a[i].s)
			*s=a[i];
}

第三套：

3.1：输出小于平均值且最接近平均值的数

double fun(double  x[],double  *av)
{ 
int  i,j;    double  d,s;
  s=0;
  for(i=0; i<N; i++)  s = s +x[i];
/**********found**********/
  *av=s/N;
  d=32767;
  for(i=0; i<N; i++)
    if(x[i]<*av && *av - x[i]<=d){
/**********found**********/
      d=*av-x[i]; 
	  j=i;
	 }
/**********found**********/
  return  x[j];
}

3.2：计算数学公式

float fun(int n)
{
 float A=1.0;int i;
/*************found**************/
  for(i=2;i<=n;i++)
     A=1.0/(1+A);
  return A;
}

3.3：阵部倍值：

void fun(int a[][N], int m)
{
int i,j;
for(i=0;i<N;i++)
	for(j=i;j<N;j++)
		a[i][j]*=m;
}

第四套：

4.1：数值转移(逆序)

double fun(double  *x)
{
 int  i, j;    double  s, av, y[N];
  s=0;
  for(i=0; i<N; i++)  s=s+x[i];
/**********found**********/
  av=s/N;
  for(i=j=0; i<N; i++)
    if( x[i]>av ){
/**********found**********/
      y[j++]=x[i];
	  x[i]=-1;}
  for(i=0; i<N; i++)
/**********found**********/
    if( x[i]!=-1) y[j++]=x[i];
  for(i=0; i<N; i++)x[i] = y[i];
  return  av;
}

4.2:首字母大写

void upfst(char *p)
{
  int k=0;
  for ( ;*p;p++)
     if (k)
        {
         if (*p==' ')  
         	k=0;
        }
     else
        {
			if (*p!=' ')  
			{
				k=1;
				*p=toupper(*p);
			}
		}
}

4.3:边和均值

double fun (int w[][N])
{
	int i,j,n=0;
	double s=0.0,av=0.0;
	for(i=0;i<N;i++)
		for(j=0;j<N;j++)
			if((i==0)||(j==0)||(i==N-1)||(j==N-1))
			{
			  s+=w[i][j];
			  n++;
			}
			av=s/n;
	return av;
}

第五套：

5.1：数值转移(顺序)

double fun(double  *x)
{ 
int  i, j;    double  av, y[N];
  av=0;
  for(i=0; i<N; i++) 
/**********found**********/ 
	av+=x[i]/N;
  for(i=j=0; i<N; i++)
    if( x[i]<av ){
      y[j]=x[i]; x[i]=-1; 
/**********found**********/
	  j++;
	}
  i=0;
  while(i<N)
  {  if( x[i]!= -1 ) y[j++]=x[i];
/**********found**********/
     i++;
  }

5.2：统计元音字母

void fun(char *s, int num[5])
{ 
int k, i=5;
  for(k=0;k<i;k++)
/*************found**************/
      num[k]=0;
  for(;*s;s++)
      { i=-1;
/*************found**************/
        switch(*s)
           { case 'a': case'A':{i=0;break;}
             case 'e': case 'E':{i=1;break;}
             case 'i': case 'I':{i=2;break;}
             case 'o': case 'O':{i=3;break;}
             case 'u': case 'U':{i=4;break;}
           }
       if(i>=0)
       num[i]++;
      }
}

5.3:边和

int fun( int a [M][N])
{
int i,j,s=0;
for(i=0;i<M;i++)
	for(j=0;j<N;j++)
		if((i==0)||(j==0)||(i==M-1)||(j==N-1))
			s+=a[i][j];
return s;
}

第六套：

6.1:串和求值：

long  ctod( char  *s )
{ 
long  d=0;
  while(*s)
    if(isdigit( *s))  {
/**********found**********/
      d=d*10+*s-'0';
/**********found**********/
      s++;  
	 }
  return  d;
}
long  fun( char  *a, char  *b )
{
/**********found**********/
  return  ctod(a)+ctod(b);
}

6.2：分别统计字符串的大小字母个数

void fun ( char *s, int *a, int *b )
{
  while ( *s )
  {  if ( *s >= 'A' && *s <= 'Z' )
/**********found**********/
       *a=*a+1 ;
     if ( *s >= 'a' && *s <= 'z' )
/**********found**********/
        *b=*b+1;
     s++;
  }
}

6.3:—数值保留（两位）—

float fun (float h )
{
	int t;
	t=(int)(h*1000+5)/10;
	return (float)t/100.0;
    
}

第七套：

7.1：完美数组：

void  fun( int  *a)
{
 int  i, x, n=0;
  x=rand()%20;
/**********found**********/
  while (n<N)
  {  for(i=0; i<n; i++ )
/**********found**********/
         if( x==a[i] ) 
		    break;
/**********found**********/
     if( i==n)
		{ a[n]=x; n++; }
     x=rand()%20;
  }
}

7.2:主对角线之和

void fun()
{
 int a[3][3],sum;
 int i,j;
/*************found**************/
 sum=0;
 for (i=0;i<3;i++)
    { for (j=0;j<3;j++)
/*************found**************/
      scanf("%d",&a[i][j]);
    }
 for(i=0;i<3;i++)
     sum=sum+a[i][i];
 printf("Sum=%d\n",sum);
}

7.3:行列互换

void fun (int array[3][3])
{
int i,j,t;
for(i=0;i<3;i++)
	for(j=i+1;j<3;j++)
	{
		t=array[i][j];
		array[i][j]=array[j][i];
		array[j][i]=t;
	}
}

第八套：

8.1：阵列—MAX

fun(x,y);
void fun(int  (*a)[N], int  *b)
{
 int  i,j;
  for(i=0; i<N; i++) {
/**********found**********/
    b[i]=a[0][i];
    for(j=1; j<N; j++)
/**********found**********/
        if(b[i]< a[j][i])
		   b[i]=a[j][i];
  }
}

8.2:交换两个变量的值

void fun(int *x,int *y)
{
 int t;
/*************found**************/
  t=*x;*x=*y;*y=t;
}

8.3:求出小于或等于lim的素数

• 素数：
  素数又称质数，有无限个。质数（素数）定义为在大于1的自然数中，除了1和它本身以外不再有其他因数。

int fun(int lim, int aa[MAX])
{
int i,j,k=0;
for(i=2;i<=lim;i++)
{
	for(j=2;j<i;j++)
		if(i%j==0)
			break;
	if(i==j)
		aa[k++]=i;
}
return k;
}

第九套：

9.1：宝塔方阵（中间凸出）

void fun(int (*a)[N])
{ 
  int  i,j,k,m;
  if(N%2==0) m=N/2 ;
  else       m=N/2+1;
  for(i=0; i<m; i++) {
/**********found**********/
     for(j=i; j<N-i; j++)
        a[i][j]=a[N-i-1][j]=i+1;
     for(k=i+1; k<N-i; k++)
/**********found**********/
        a[k][i]=a[k][N-i-1]=i+1;
  }
}

9.2:—进制转化—

void fun(int m,int k)
{ 
int aa[20], i;
  for(i=0;m;i++)
  {
	/*************found**************/
	aa[i]=m%k;
	m/=k;
  }
  for(;i;i--)
	/*************found**************/
	printf("%d",aa[i-1]);
}

9.3:找出最长字符

char *fun(char (*a)[81], int num, char *max)
{
int i;
max=a[0];
for(i=0;i<num;i++)
	if(strlen(max)<strlen(a[i]))
		max=a[i];
return max;
}

第十套：

10.1：幻方（行，列，主(反)对角线的和都相等）

int fun(int  (*a)[N])
{ 
int  i,j,m1,m2,row,colum;
  m1=m2=0;
  for(i=0; i<N; i++)
  { j=N-i-1;  m1+=a[i][i];  m2+=a[i][j];  }
  if(m1!=m2) return  0;
  for(i=0; i<N; i++) {
/**********found**********/
     row=colum= 0;
     for(j=0; j<N; j++)
     {  row+=a[i][j];  colum+=a[j][i];  }
/**********found**********/
     if( (row!=colum) || (row!=m1) ) return 0;
  }
/**********found**********/
  return  1;
}

10.2:计算数学公式

double fun(int m)
{
  double t=1.0;
  int i;
  for(i=2;i<=m;i++)
/*************found**************/
      t-=1.0/i;
/*************found**************/
  return t;
}

10.3:删除字符串中的所有空格

void fun (char *str)
{
	int i,j=0;
	for(i=0;str[i]!='\0';i++)
		if(str[i]!=' ')
			str[j++]=str[i];
}