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

第三十一套：

31.1：计算数学公式

double fun(int  n)
{
  int  i, k;    double  s, t;
  s=0;
/**********found**********/
  k=1;
  for(i=1; i<=n; i++) {
/**********found**********/
    t=2*i;
    s=s+k*(2*i-1)*(2*i+1)/(t*t);
/**********found**********/
    k=k*(-1);
  }
  return  s;
}

31.2:判断素数

int fun(int m)
{
  int k=2;
  while (k<=m&&(m%k))
/*************found**************/
        k++ ; 
/*************found**************/
  if(m==k)
       return 1;
  else return 0;
}

31.3:找出序列中最大数及其下标

void fun(int a[],int n, int *max, int *d)
{
	int i,m,k;
	m=a[0];
	for(i=1;i<n;i++)
		if(a[i]>m)
		{
			m=a[i];
			k=i;
		}
	*max=m;
	*d=k;
}

第三十二套：

32.1：计算数学公式

double fun(double  e)
{
 int  i;    double  s, x;
/**********found**********/
  s=0;  i=0;
  x=1.0;
  while(x>e){
/**********found**********/
    i++;
/**********found**********/
    x=(2.0*i-1)/((2.0*i)*(2.0*i));
    s=s+x;
  }
  return  s;
}

32.2:拼接字符串的正反串形成新串

void fun (char  *s, char  *t)
{
  int   i, d;
  d = strlen(s);
  for (i = 0; i<d; i++)  t[i] = s[i];
  for (i = 0; i<d; i++)  t[d+i] = s[d-1-i];
/************found************/
  t[2*d] = '\0';
}

32.3:删除字符串中的部分字符

void fun(char *s, char t[])
{
	int i,j=0;
	for(i=0;s[i]!='\0';i++)
		if((i%2)&&(s[i]%2))
			t[j++]=s[i];
	t[j]='\0';
}

第三十三套：

33.1：在数字字符后添加‘*’

void fun(char  *s)
{ 
   int  i, j, n;
   for(i=0; s[i]!='\0'; i++)
/**********found**********/
     if(s[i]>='0' && s[i]<='9')
     {  n=0;
/**********found**********/
        while(s[i+1+n]!= '\0')  n++;
        for(j=i+n+1; j>i; j--)
/**********found**********/
           s[j+1]= s[j];
        s[j+1]='*';
        i=i+1;
     }
}

33.2:计算数学公式

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

33.3:矩阵及其转置矩阵的和

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]=a[j][i]+a[i][j];
}

第三十四套：

34.1：逆置单链表中的数据

typedef struct node 
{
  int  data;
  struct node  *next;
} NODE;
/**********found**********/
NODE * 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->next;
    q->next = p;
    p = q;
/**********found**********/
    q = r ;
  }
  return  p;
}

34.2:按要求重组新串

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[j]='\0';
}

34.3:按列存贮二维数组

void fun (int (*s)[10], int *b, int *n,int mm, int nn)
{
	int i,j,k=0;
	for(j=0;j<nn;j++)
		for(i=0;i<mm;i++)
			b[k++]=s[i][j];
	*n=k;
}

第三十五套：

35.1：修改形参a中的数据

struct student {
  long  sno;
  char  name[10];
  float  score[3];
};
/**********found**********/
struct student fun(struct  student  a)
{ 
  int  i;
  a.sno = 10002;
/**********found**********/
  strcpy(a.name, "LiSi");
/**********found**********/
  for (i=0; i<3; i++) a.score[i] += 1;
  return  a;
}

35.2:删除数列中的指定元素

int fun(int *a,int n,int x)
{ 
    int p=0,i;
    a[n]=x;
    while( x!=a[p] )
	p=p+1;
/**********found**********/
    if(p==n) return -1;
    else
    { for(i=p;i<n-1;i++)
/**********found**********/
	  a[i]=a[i+1];
      return n-1;
    }
}

35.3:合成新数

void fun(int a, int b, long *c)
{
*c=(b/10)*1000+(a%10)*100+(b%10)*10+a/10;
}

第三十六套：

36.1：逆置单链表中的数据2.0

typedef struct node {
  int  data;
  struct node  *next;
} NODE;
void fun(NODE  *h)
{
 NODE  *p, *q, *r;
/**********found**********/
  p = h->next;
/**********found**********/
  if (p==NULL)  return;
  q = p->next;
  p->next = NULL;
  while (q)
  {  r = q->next;    q->next = p;
/**********found**********/
     p = q;          
	 q = r;
  }
  h->next = p;
}

36.2:—在大字符串中查找小字符串—

int fun(char *s,char *t)
{ 
  int n;
  char *p, *r;
  n=0;
  /*************found**************/
  r=t;
  while ( *s )
  {
	  p = s;
      while ( *r )
	  {
        if ( *r == *p )
        {
			r++;
			p++;
		}
        else
			break;
        if ( *r == '\0' )
			n++;
	  }
	  /*************found**************/
	  r=t;
      s++;
  }
  return  n;
}

36.3：—将小组的字符串组成大组—

void fun(char a[M][N],char *b)
{
	int i,j,k=0;
	for(i=0;i<M;i++)
		for(j=0;a[i][j]!='\0';j++)
			b[k++]=a[i][j];
	b[k]='\0';
  
}

第三十七套：

37.1：—取出奇数递增字符并排序—

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<n-2; i=i+2) {
/**********found**********/
      t=i;
/**********found**********/
      for(j=i+2 ; j<n; j=j+2)
        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<n; i=i+2, j++)  p[j]=s[i];
/**********found**********/
   p[j]='\0';
}

37.2:计算数学公式（求π）

float fun ( float num )
{
    int s ;
    float n, t, pi ;

    t = 1 ; pi = 0 ; n = 1 ;  s = 1 ;
/**************found**************/
    while(fabs(t) >= num)
    {
        pi = pi + t ;
        n = n + 2 ;
        s = -s ;
/**************found**************/
        t = s / n ;
    }
    pi = pi * 4 ;
    return pi ;
}

37.3:删除串中指定下标的字符

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

第三十八套：

38.1：顺置单链表中的数据

typedef struct node {
  int  data;
  struct node  *next;
} NODE;
void fun(NODE  *h)
{ 
NODE  *p, *q;    int  t;
  p = h;
  while (p) {
/**********found**********/
     q = p->next ;
/**********found**********/
     while ( q )
     {  if (p->data > q->data)
       {  t = p->data;  p->data = q->data;  q->data = t;  }
       q = q->next;
    }
/**********found**********/
    p = p->next  ;
  }
}

38.2:后续化字符转换

void fun(char *s)
{
/*************found**************/
 while(*s!= '\0')
   { 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++;
   }
}

38.3:—平移数组中的部分数字—

void  fun(int  *w, int  p, int  n)
{
	int i,j,t;
	for(i=0;i<=p;i++)
	{
		t=w[0];
		for(j=1;j<n;j++)
			w[j-1]=w[j];
		w[n-1]=t;
	}
}

第三十九套：

39.1：—读入文本并显示—

void fun(char  *s, int  a, double  f)
{
/**********found**********/
  FILE* 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(fp)) 
{
/**********found**********/
    putchar(ch); 
	ch = fgetc(fp);  
}
    putchar('\n');
    fclose(fp);
}

39.2:取出数字字符组成新串

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';
}

39.3:按列存贮二维数组2.0

void fun(char (*s)[N],char *b)
{
	int i,j,k=0;
	for(i=0;i<N;i++)
		for(j=0;j<M;j++)
			b[k++]=s[j][i];
	b[k]='\0';
}

第四十套：

40.1：寻找相同字符，并插入同字符

void fun(char  *s, char  c)
{  
  int  i, j, n;
/**********found**********/
  for(i=0; s[i]!='\0' ; i++)
     if(s[i]==c)
     {
/**********found**********/
        n=0 ;
        while(s[i+1+n]!='\0')  n++;
        for(j=i+n+1; j>i; j--)  s[j+1]=s[j];
/**********found**********/
        s[j+1]=c;//这里用c好过s[i]!!!
        i=i+1;
     }
}

40.2:计算数组中正数的平均值

double fun ( int x[])
{
/************found************/
  double 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;
}

40.3:计算数学公式

float fun(int  n)
{
	int i;
	float sum=0.0,s=0.0;
	for(i=1;i<=n;i++)
	{
		s+=i;
		sum+=1.0/s;
	}
	return sum;
}