计算机二级C语言部分（程序填空，程序修改，程序设计）真题

已于 2025-03-30 13:02:17 修改
阅读量245 收藏 1
点赞数 3
文章标签： c语言 开发语言
于 2025-03-11 15:12:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/CYR19Gin/article/details/146179674
版权

int *a[10]是数组指针，int(*a)[10]是指针数组，int*a是指针变量，int a[10]是数组。

65.3请编写一个函数int fun(int A[ ],int m, int B[ ], int n, int C[ ])，使对于从小到大有序数组A和B，返回A和B的交集C，假定A与B长度均不超过100，m是A数组元素个数，n是B数组元素个数，但可能存在重复元素，因此最终生成交集C要注意去重复，并且保持从小到大有序。通过函数值返回交集C中元素个数。

例如：当A数组长度为9，元素值为：1,2,2,3,3,3,5,6,7,

B数组长度为6，元素值为：2,2,3,3,6,8时， 

C数组长度为3，元素值为：2,3,6。

#include<stdio.h>
#define  N   100
int fun(int A[ ], int m, int B[ ], int n, int C[ ])
{
	int i,j,k=0;
	for(i=0;i<m;i++)
	{
		for(j=0;j<n;j++)
		{
			if(A[i]==B[j]&&A[i]!=C[k-1])
			{
				C[k]=A[i];
				k++;
				break;
			}
		}
	}
	return k;
}
main( )
{	int a[N]={1,2,2,3,3,3,5,6,7}, b[N]={2,2,3,3,6,8}, c[N];
	int k,i;
    k = fun(a,9,b,6,c);
	if(k > 0)
	{
		printf("A和B数组交集元素个数：%d\n", k);
        for (i=0; i<k;i++)
			printf("%d ", c[i]);
	}
	else
		printf("A和B数组无交集！\n");

 65.1在整数数组中，如果一个数的出现次数最少，我们就称这个数为"孤独数"。给定一个整数数组，输出其中最小的孤独数。

在给定程序BLANK1.C中，函数fun的功能是求出长度为n的数组a中的孤独数并返回(n最大不会超过100)。

例如：当n为6，a数组为5,3,3,3,2,2时，函数返回值应为5。

#include  <stdio.h>
#define  N   100
int fun(int a[ ], int n)
{   int b[N], c[N]={0};
    int cc = 0;
	int i, j, min;
    for(i=0; i<n; i++)
/******************found*******************/
    {   for(j=0; j<cc; j++) 
           if (a[i] == b[j])
				break;
/******************found*******************/
	    if (j==cc)
		{	b[cc] = a[i];
			c[cc] = 1;
		    cc++;
		}
		else
			c[j]++;
	}
	min = 0;
	for(i=1; i<cc; i++)
	    if (c[i] < c[min])
			min = i;
/******************found*******************/
	return   b[min] ;
}
main( )
{   int a[N] ={5, 3, 3, 3, 2, 2};
	int min_lone;
	min_lone = fun(a, 6);
	printf("min_lone=%d\n", min_lone);
}

 65.2函数fun的功能是从字符串s（长度不超过100）中找出不含有重复字符的最长子串放入t中。若有多个相同长度的不含有重复字符的最长子串，则从左至右取第一个作为最后结果放入t中。

例如：s为“abcabcbb”时，t应为“abc”。

例如：s为“abbccabbccbb”时，t应为“cab”。

例如：s为“bbbbb”时，t应为“b”。

例如：s为“pwwkew”时，t应为“wke”。

#include  <stdio.h>
#include  <string.h>
#define  N   100

void fun(char s[], char t[])
{
    int max_len, len, max_pos, pos, i,j,k;
    max_len = 1;
    max_pos = 0;
	for (i=0; i<strlen(s); i++)
	{
		pos = i;
	/**********************found***********************/
		len = 1;
		for (j=pos+1; j<strlen(s); j++)
		{
			for(k=pos; k<j; k++)
			   if (s[j]==s[k])
			  	  break;
/**********************found***********************/
			if (k==j)
			  len++;
			else
			  break;
		}
/**********************found***********************/
		if (len>max_len)
		{
			max_len = len;
			max_pos = pos;
		}
	}
	for (i=max_pos; i<max_pos+max_len; i++)
		t[i-max_pos] = s[i];
	t[max_len]='\0';
}
main( )
{
    char *str1="abcabcbb", *str2="abbccabbccbb", *str3="bbbbb", *str4="pwwkew",res[N];
	fun(str1,res);
	printf("字符串 %s 中不含有重复字符的最长子串是: %s\n", str1, res);
	fun(str2,res);
	printf("字符串 %s 中不含有重复字符的最长子串是: %s\n", str2, res);
	fun(str3,res);
	printf("字符串 %s 中不含有重复字符的最长子串是: %s\n", str3, res);
	fun(str4,res);
	printf("字符串 %s 中不含有重复字符的最长子串是: %s\n", str4, res);
}

64.1函数fun的功能是删除形参s所指的字符串中末尾的所有空格

#include<stdio.h>
#include <string.h>
void fun(char *s)
{
	int n;
 	char *p;
	n=strlen(s);
 	if(n>0)
 	{
/**********found**********/
	 	p=s+n-1;
	 	while(*p==' ')
/**********found**********/
			p--;
/**********found**********/
		*(p+1)= '\0';
	}
 } 
int main()
{ 
	char s[100];
	gets(s);
	fun(s);
	printf("%s#\n",s);
	return 0;
}

64.2函数fun的功能是将N x N的二维数组，按下面样例所示规律进行赋值，例如:当N=4时，所得二维数组的内容应为:

1 1 1 1

1 2 2 1

1 2 2 1

1 1 1 1

当N=5时，所得二维数组的内容应为:

1 1 1 1 1

1 2 2 2 1

1 2 3 2 1

1 2 2 2 1

1 1 1 1 1

#include <stdio.h>
#define N 8
void fun(int a[N][N])
{
	int i,j,k=1,t;
/**********************found***********************/
	t=0;
	/**********************found***********************/
	while(t<=N/2)
	{
			for(i=t;i<N-t;i++)  
			for(j=t;j<N-t;j++)
	/**********************found***********************/
				a[i][j]=k;
		k++;
		t++;	
	}
}
main()
{
	int i,j;
	int a[N][N]={0};
  	fun(a);
	for(i=0;i<N;i++)
	{
		for(j=0;j<N;j++)
			printf("%5d",a[i][j]);
		printf("\n");
	}
 }

64.3函数fun，其功能是将形参s所指的字符串中的数字字符转换为一个整数并返回。形参s所指的字符串中的第一个字符可以为“+”或“-”，字符串中可以包含字母或数字，当碰到第一个字母时，转换过程结束。例:当s所指的字符串为“-123”时，返回值为-123;当s所指的字符串为“123”时，返回值为 123。

#include <stdio.h>
#include <string.h>

int fun(char *s)
{
	int i=0,flag=1,n=0;
	if(s[0]=='-')
	{
		flag=-1;
		i=1;
	}
	if(s[0]=='+')
	{
		i=1;
	}
	for(;s[i]!='\0';i++)
	{
		if(s[i]>='0'&&s[i]<='9')
		{
			n=n*10+(s[i]-'0');
		}
		else
			break;
	}
	return flag*n;
}

main()
{ 
	char s[100]; 
	int n;
	printf("Enter a string:\n");
	gets(s);
	n=fun(s);
	printf("%d\n",n);
}

50.3 请编写函数fun，其功能是:验证参数n是否可以分解成2个素数相乘，是则返回1，否则返回0，并通过指针变更x、y返回分解后的2个素数值，要求*x < *y。主程序中将打印出分解结果。例如：111=3*37， 当函数fun的参数n为111时，可以分解为2个素数(3和37) 的乘积函数返回值为1。另外，prime函 数验证参数m是否为素数，是则返回1，否则返回0。

#include<stdio.h>
#include<math.h>
int prime(int m)
{
	int k,flag=1;
	for(k=2;k<(int)sqrt((double)m);k++)
		if(m%k==0)
			flag=0;
	return flag;
}
int fun(int n,int *x,int *y)
{
	int k,flag=0;
	int k1;
	k=2;
	do
	{
		k1=n/k;
		if(k*k1==n)
		{
			if(prime(k)&&prime(k1)&&k<k1)
			{
				flag=1;
				*x=k;
				*y=k1;
				break;
			}
		}
		k++;
	}while(k<k1);
    return flag;
}
main()
{
	int a,b;FILE *out ;
	out = fopen("out.dat","w") ;
	if(fun(111,&a,&b)) {
		printf("111=%d*%d\n",a,b);
		fprintf(out, "111=%d*%d\n",a,b);
	}
	if(fun(11111,&a,&b)) {
		printf("11111=%d*%d\n",a,b);
		fprintf(out, "11111=%d*%d\n",a,b);
	}
	if(fun(1111111,&a,&b)) {
		printf("1111111=%d*%d\n",a,b);
		fprintf(out,"1111111=%d*%d\n",a,b);
	}
   fclose(out);
   getchar();

}

法二：

int fun(int n,int *x,int *y)
{
	int k,flag=0, limit = (int)sqrt((double)n);
    for (k = 2; k <= limit; k++) 
    {
        if (n % k == 0) 
        {
            int k1 = n / k;
            if (prime(k) && prime(k1) && k < k1) 
            {
                *x = k;
                *y = k1;
                flag=1;
                return flag;
            }
        }
    }
    return flag;
}

 50.2函数void list (MYDATA *h)的功能是:列出带头结点单链表中所有没有删除标记的数据。调用这个函数时，传给形参h的是指向单链表头结点的指针。例如：当10个结点的数据为1,2,3,4,5,6, 7,8,9, 10时，输出将是:3 4 6 7 8 9 10。其中，各个数据所对应的删除标记是由随机数产生的。

#include<stdio.h>
#include<stdlib.h>
typedef struct dat
{
	char deleted;	//是否删除：0-未删除，1-删除
	int data;
	struct dat* next;
} MYDATA;
void list(MYDATA *h)
{
/******found******/
	MYDATA  *p;
	p=h->next;
	while(p!=NULL)
	{
	/******found******/
		if(p->deleted==0)
		{
			printf("%d  ",p->data);
		}
/******found******/
		p=p->next;
	}
}

void creat(MYDATA *h,int *d,int n)
{
	MYDATA *p, *q;
	int i=0,del;
	q=h;
	while(n>0)
	{
		p=( MYDATA *)malloc(sizeof(MYDATA));
		del=rand()%2;
		p->data=d[i];
		p->deleted=del;
		p->next=q->next;
		q->next=p;
		q=p;
		n--;i++;
	}
}
void main()
{
	MYDATA *head;
	int n=10,dd[]={1,2,3,4,5,6,7,8,9,10};
	head=(MYDATA *)malloc(sizeof(MYDATA));
	head->next=NULL;
	creat(head,dd,n);
	list(head);
}

49.3

请编写函数void fun(int *dp, int n, int upordown)， 其功能是，找出dp所指数组中的最小或最大值，并与其第1个元素交换。形参n为元素的个数，形参upordown为查找标志:值为0时找最小值;值为1时找最大值。

 

#include <stdio.h>
#include <stdlib.h>
#define N 10
#pragma warning (disable:4996)
void NONO(FILE *fp, int pd[], int n);

void fun (int *dp,int n,int upordown)
{
	int i,mom=0,t;
	if(upordown==0)
	{
		for(i=1;i<n;i++)
		{
			if(dp[i]<dp[mom])
				mom=i;
		}
	}
	else
	{
		for(i=1;i<n;i++)
		{
			if(dp[i]>dp[mom])
				mom=i;
		}
	}
	t=dp[0];
	dp[0]=dp[mom];
	dp[mom]=t;
}

void display(int pd[],int n)
{
	int i;
	for(i=0;i<n;i++)
		printf("%4d",pd[i]);
	printf("\n");
}
void main()
{
	int data[N],i,n=N;
	FILE *out ;

    out = fopen("out.dat","w") ;
	for(i=0;i<N;i++)
		data[i]=rand()%90+10;
	for(i=0;i<N-1;i++)
		fun(data+i,n-i,0);
	display(data,n);
	NONO(out, data, n);
	for(i=0;i<N;i++)
		data[i]=rand()%90+10;
	for(i=0;i<N-1;i++)
		fun(data+i,n-i,1);
	display(data,n);
	NONO(out, data, n);
	fclose(out);
}
void NONO(FILE *fp, int pd[], int n)
{
	int i;
	for(i=0;i<n;i++)
		fprintf(fp, "%4d", pd[i]);
	fprintf(fp, "\n");

}

请编写函数fun，其功能是从一行单词字符串数组a中分别提取每个单词尾部的字母组成个新的字符串数组b，并通过实参返回。单词分隔是以一个空格或几个空格进行分隔。

例如:This is a C program           输出:ssaCm

#include <stdio.h>
#include <string.h>
#include <conio.h>

void fun(char a[], char b[])
{
	int i,j=0;
	for(i=0;a[i]!='\0';i++)
	{
		if(a[i]!=' '&&a[i+1]==' ')
		{
			b[j++]=a[i];
		}
	}
	b[j]=a[i-1];//或者写成b[j]=a[strlen(a)-1];
	b[++j]='\0';

}

void main()
{
	char a[]="This is a C program", b[100];

	fun(a,b);
	printf("%s\n",b);
}

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

#include  <stdio.h>
#include  <string.h>
struct student {
  long  sno;
  char  name[10];
  float  score[3];
};
void fun(struct student  a[], int  n)
{
/**********found**********/
 struct student t;
  int  i, j;
/**********found**********/
  for (i=0; i<n-1; i++)
    for (j=i+1; j<n; j++)
/**********found**********/
		if (strcmp(a[i].name,a[j].name) > 0)
      {  t = a[i];   a[i] = a[j];  a[j] = t;  }
}
main()
{ struct student  s[4]={{10001,"ZhangSan", 95, 80, 88},{10002,"LiSi", 85, 70, 78},
                    {10003,"CaoKai", 75, 60, 88}, {10004,"FangFang", 90, 82, 87}};
  int  i, j;
  printf("\n\nThe original data :\n\n");
  for (j=0; j<4; j++)
  {  printf("\nNo: %ld  Name: %-8s      Scores:  ",s[j].sno, s[j].name);
     for (i=0; i<3; i++)  printf("%6.2f ", s[j].score[i]);
     printf("\n");
  }
  fun(s, 4);
  printf("\n\nThe data after sorting :\n\n");
  for (j=0; j<4; j++)
  {  printf("\nNo: %ld  Name: %-8s      Scores:  ",s[j].sno, s[j].name);
     for (i=0; i<3; i++)  printf("%6.2f ", s[j].score[i]);
     printf("\n");
  }
}

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

#include  <stdio.h>
#include  <stdlib.h>
#define    N    5
typedef struct node {
  int  data;
  struct node  *next;
} NODE;
void fun(NODE  *h)
{ NODE  *p, *q, *r;
/**********found**********/
  p = h->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;
}
NODE *creatlist(int  a[])
{  NODE  *h,*p,*q;        int  i;
  h = (NODE *)malloc(sizeof(NODE));
  h->next = NULL;
  for(i=0; i<N; i++)
  {  q=(NODE *)malloc(sizeof(NODE));
     q->data=a[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);
  getchar();
}

假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是:只删除字符串前导和尾部的*号，串中字母之间的*号都不删除。形参n给出了字符串的长度，形参h给出了字符串中前导*号的个数，形参e给出了字符串中最后*号的个数。在编写函数时，不得使用C语言提供的字符串函数。

例如，字符串中的内容为:****A*BC*DEF*G******，删除后，字符串中的内容应当是:A*BC*DEF*G。

#include <stdio.h>
void  fun( char *a, int n,int h,int e )
{
	int i,k=0;
	char *q,*p,b[81];
	p=a+h;
	q=a+n-1-e;
	while(p<=q)
	{
		b[i++]=*p;
		p++;
	}
	b[i]='\0';
	while(b[k]!='\0')
	{
		a[k]=b[k];
		k++;
	}
    a[k]='\0';


}

main()
{  char  s[81],*t,*f;  int m=0, tn=0, fn=0;
   printf("Enter a string:\n");gets(s);
   t=f=s;
   while(*t){t++;m++;}
   t--;
   while(*t=='*'){t--;tn++;}
   while(*f=='*'){f++;fn++;}
   fun( s , m,fn,tn );
   printf("The string after deleted:\n");puts(s);
}

给定程序modi1.c的功能是:读入一个英文文本行，将其中每个单词的第一个字母改成大写，然后输出此文本行（这里的"单词"是指由空格隔开的字符串）。

例如，若输入: I am a student to take the examination.，则应输出:工 Am A Student To Take The Examination.。

#include <ctype.h>
#include <string.h>
#include  <stdio.h>
void upfst ( char  *p )
{  int  k=0;
   for ( ; *p; p++ )
      if ( k )
      {   if ( *p == ' ' )   k = 0;   }
      else  if ( *p != ' ' )
      {   k = 1;   *p = toupper( *p ); }
}

main( )
{   char   chrstr[81];
    printf( "\nPlease enter an English text line: " );   gets( chrstr );
    printf( "\n\nBefore changing:\n  %s", chrstr );
    upfst(  chrstr );
    printf( "\nAfter changing:\n  %s\n", chrstr );
}

请编写函数fun，函数的功能是:判断字符串是否为回文?若是，函数返回1，主函数中输出:YES;否则返回0，主函数中输出NO。回文是指顺读和倒读都一样的字符串。例如，字符串LEVEL是回文，而字符串123312就不是回文。

#include <stdio.h>
#include <string.h>
#define  N  80
int fun(char *str)
{
	char *p=str;
	while(*p)
	{
		p++;
	}
	p--;
	while(str<=p)
	{
		if(*p==*str)
		{
			str++;
			p--;
		}
		else
		{
			return 0;
		}
	}
	return 1;
}

main()
{ char  s[N] ;
  printf("Enter a string: ") ; gets(s) ;
  printf("\n\n") ; puts(s) ;
  if(fun(s)) printf("  YES\n") ;
  else       printf("  NO\n") ;
}

法二：

#include <stdio.h>
#include <string.h>
#define  N  80
int fun(char *str)
{
	int count=strlen(str),i;/*利用strlen()函数计算字符串的长度*/
	for(i=0;i<=count/2;i++)
	{
		if(str[i]!=str[count-i-1])//判断对称点两侧字符是否存在不同
		{
			return 0;
			break;
		}
	}
	return 1;
}

main()
{ char  s[N] ;
  printf("Enter a string: ") ; gets(s) ;
  printf("\n\n") ; puts(s) ;
  if(fun(s)) printf("  YES\n") ;
  else       printf("  NO\n") ;
}

函数fun的功能是:在有n个元素的结构体数组std中，查找有一门或两门不及格科目的学生，找到后输出学生的学号;函数的返回值是有不及格科目的学生人数。例如，主函数中给出了4名学生的数据，则程序运行的结果为;

学号:N1002 学号:N1006

共有2位学生有不及格科目

#include  <stdio.h>
typedef struct
{ char num[8];     /* 学号 */
  double score[2]; /* 两门课成绩 */
} STU ;
int  fun(STU  std[ ], int  n)
{  int  i, k=0;
   for(i=0; i<n; i++)
     if( (std[i].score[0]<60) || (std[i].score[1]<60) ) 
     { k++;     printf("学号：%s ",std[i].num);   }
   return k ;
}
main()
{  STU  std[4]={ "N1001", 76.5,82.0 ,"N1002", 53.5,73.0, 
                "N1005", 80.5,66.0,"N1006", 81.0,56.0 };
  printf( "\n共有%d位学生有不及格科目\n" , fun(std,4) );
}

 根据哥德巴赫猜想，任意一个大偶数都可以分解为两个素数之和。但许多偶数分解为两个素数之和并不是唯一的。请编写函数fun，其功能是:求1000(不包括1000)以内的所有恰好能分解成10组两个素数之和(5+109和109+5被认为是同一组) 的偶数，并依次存入数组a中并在屏幕上打印出来，打印时每个数单独一行，符合条件的个数通过函数值返回。

例如：114=5+109=7+107=11+103=13+101=17+97=31+83=41+73=43+71=47+67=53+61

114恰好可以分解为10组素数之和，因此114是我们要找的偶数。

而116=3+113=7+109=13+103=19+97=37+79=43+73

120=7+113=11+109=13+107=17+103=19+101=23+97=31+89=37+83=41+79=47+73=53+67=59+61

116可以分解为6组素数之和，120可以分解为12组素数之和，因此116和120都不是我们要找的偶数。函数prime用来判断一个数n是否为素数，是则返回1，否则返回0。

#include<stdio.h>
#include<math.h>

int prime(int n)
{	int k,flag=1;
	for (k=2; k<=(int)sqrt((double)n); k++)
		if (n%k == 0)
			flag=0;
	return flag;
}

int fun(int m, int a[])
{ 
  int k, s, count, i=0;
   for(k=6; k<=m; k+=2)
   {   count = 0;
	   /* 请在此处填写代码 */
		for(s=2;s<=k/2;s++)
		{
			if(prime(s)&&prime(k-s))
			{
				count++;
			}
		}
       if (count == 10) {
		   printf("%d\n", k);
		   a[i++] = k;
	   }
   }
   return i;
}
main( )
{	int count, a[100];
	count = fun(999, a);
}

主函数中，将a、b、c三个结点链成一个单向链表，并给各结点的数据域赋值，函数fun()的作用是:累加链表结点数据域中的数据作为函数值返回。

#include  <stdio.h>
typedef  struct  list
{  int  data;
   struct list  *next;
} LIST;
int fun(LIST *h)
{  LIST  *p;
/**********found**********/
   int  t=0;
   p=h;
/**********found**********/
   while( p )
   {
/**********found**********/
      t=t+p->data;//或者写成t=t+(*p).data;
      p=(*p).next;              
   }
   return  t;
}
main()
{  LIST  a, b, c, *h; 
   a.data=34;  b.data=51;  c.data=87;  c.next='\0';
   h=&a;  a.next=&b;  b.next=&c;
   printf("总和 = %d\n",fun( h ));
}

 函数char *fun(char *s1, char *s2，char *r) 的功能是:将两个长

度相等的纯数字字符串当作两个加数，求其代表的数值之和并以字符串的形式存入r所指内存且返回。如: s1是”723”，s2是”567", 则返回的字符串为”1290”。要考虑进位。

#include <stdio.h>
#include <string.h>
char *fun(char * s1,char *s2,char *r)
{
	int len,cy=0,md;
	char *p,*q,*t;
	len=strlen(s1);
	p=s1+len-1;
	q=s2+len-1;
	t=r+len;
/**********************found***********************/
	*(t+1)='\0';
	while(p>=s1)
	{
/**********************found***********************/
		md=*p-'0'+*q-'0'+cy;
		if(md>=10)	cy=1;
		else	cy=0;
		*t=md%10+'0';
		p--;
		q--;
		t--;
	}
/**********************found***********************/
	if(cy==1)     
		*t='1';
	else
	{
		while(*r++=*++t);
	}
	return r;
}
void main()
{
	char s1[100],s2[100],s3[101];
	strcpy(s1,"65743");
	strcpy(s2,"85339");
	fun(s1,s2,s3);
	printf("%s+%s=%s\n",s1,s2,s3);
}

请编写函数fun，其功能是:找出用1、2、3、4四个数字，能组成多少个互不相同且无重复数字的三位数，然后把这些三位数按从小到大的顺序依次存入相应的数组xxx中，符合条件的个数由函数值返回。

#include <stdio.h>
#define max 100

int fun(int xxx[])
{
	int i ,j,k,n=0;
	for(i=1;i<=4;i++)
	{
		for(j=1;j<=4;j++)
		{
			if(i!=j)
			{
				for(k=1;k<=4;k++)
				{
					if(i!=k&&j!=k)
					{
						xxx[n++]=i*100+j*10+k;
					}
				}
			}
		}
	}
	return n;

}
int main()
{
	int xx[max],cnt;cnt = fun(xx);
	printf("符合条件的个数=%d\n", cnt);
	return 0;
}

学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中，请编写函数fun，它的功能是:函数返回指定学号的学生数据，指定的学号在主函数中输入。若没找到指定学号，在结构体变量中给学号置空串，给成绩置-1，作为函数值返回。(用于字符串比较的函数是strcmp)。

#include <stdio.h>
#include <string.h>
#pragma warning (disable:4996)
#define   N   16
typedef  struct
{  char  num[10];
   int   s;
} STREC;
STREC  fun( STREC  *a, char *b )
{
  int i;
  STREC t = {'\0', -1};
  for(i=0;i<N;i++)
  {
	  if(strcmp(a[i].num,b)==0)
	  {
		  strcpy(t.num,a[i].num);
		  t.s=a[i].s;
	  }
  }
  return t;
}

main()
{  STREC  s[N]={{"GA005",85},{"GA003",76},{"GA002",69},{"GA004",85},
		{"GA001",91},{"GA007",72},{"GA008",64},{"GA006",87},
		{"GA015",85},{"GA013",91},{"GA012",64},{"GA014",91},
		{"GA011",77},{"GA017",64},{"GA018",64},{"GA016",72}};
   STREC  h;
   char  m[10];
   int  i;FILE *out ;
   printf("The original data:\n");
   for(i=0; i<N; i++)
   {  if(i%4==0) printf("\n");
      printf("%s %3d  ",s[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("..\\..\\out.dat","w") ;
   h=fun(s,"GA013");
   fprintf(out,"%s  %4d\n",h.num,h.s);
   fclose(out);
   getchar();
}

函数fun的功能是:统计形参str中所出现的大写字母的范围跨度,即按字典序最前面的大写字母与最后面的大写字母ASCII值之差，并传递回主函数输出。若没有大写字母，则函数输出0。例如: 若str的内容为”Baybye!Doom"，其中大写字母为B和D，D与B之 差为2，函数返回2,程序输出2。若str的内容为"M68C9Xaa”，其中字典序最前面的大写字母为C，最后面的大写字母为X，X与C之差为21，函数返回21，程序输出21。

#include <stdio.h>
#include <string.h> 

int fun(char* str) {  
  int k, c0, c1;
  c0 = c1 = -1;
  for (k=0; k<strlen(str); k++) 
    if ( (str[k] >= 'A') && (str[k] <= 'Z') ) 
	{  c0 = c1 = k;
	   break;
	}
  if (c0 == -1)
	  return 0;
/**********************found***********************/
  for (k=0; k<strlen(str); k++) 
  {
/**********************found***********************/
    if ( (str[k] >= 'A') && (str[k] <= 'Z') ) 
    {
      if (str[k] < str[c0])
        c0 = k;
      if (str[k] > str[c1])
        c1 = k;
    }
  }
/**********************found***********************/
  return str[c1] - str[c0];
}

int main()
{ 
  char str[100];
  int l;
  printf("input string:");
  scanf("%s", str);
  l = fun(str);
  printf("span:%d\n", l);
  return 0;
}

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

#include  <stdio.h>
#include  <stdlib.h>
#define    N    5
typedef struct node {
  int  data;
  struct node  *next;
} NODE;
/**********found**********/
struct node * fun(NODE *h)//或者写成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;
}
NODE *creatlist(int  a[])
{  NODE  *h,*p,*q;        int  i;
   h=NULL;
   for(i=0; i<N; i++)
   {  q=(NODE *)malloc(sizeof(NODE));
      q->data=a[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);
   getchar();
}

请编写函数fun，其功能是：给定一个整数n(n<10000)，如果n加上100后是一个完全平方数(所谓“完全平方数”，就是开方后的结果是整数的数)，并且n加上268也是一个完全平方数，则函数值返回1，否则返回0。

#include <stdio.h>
#include <math.h>

int fun(long n)
{
	float a,b;
	a=sqrt(n+100);
	b=sqrt(n+268);
	if((int)a==a&&(int)b==b)
	{
		return 1;
	}
	else
		return 0;
}
int main()
{
    long i;
    FILE *fp = fopen("out.dat", "w");

    for(i=1;i<10000;i++)
    {
        if (fun(i))
        {
            printf("%ld\n", i);
            fprintf(fp, "%ld\n", i);
        }
    }
    return 0;
}

请编写函数fun，其功能是:验证参数n是否可以分解成2个素数相乘，是则返回1，否则返回0，并通过指针变更x、y返回分解后的2个素数值，要求*x < *y。主程序中将打印出分解结果。例如：111=3*37， 当函数fun的参数n为111时，可以分解为2个素数(3和37) 的乘积函数返回值为1。另外，prime函 数验证参数m是否为素数，是则返回1，否则返回0。

#include<stdio.h>
#include<math.h>
int prime(int m)
{
	int k,flag=1;
	for(k=2;k<(int)sqrt((double)m);k++)
		if(m%k==0)
			flag=0;
	return flag;
}
int fun(int n,int *x,int *y)
{
	int k,flag=0;
	int k1;
	k=2;
	do{
		k1=n/k;
		if(k*k1==n)
		{
			if((prime(k))&&(prime(k1))&&(k<k1))
			{
				flag=1;
				*x=k;
				*y=k1;
				break;
			}
		}
		k++;
	}while(k<k1);
    return flag;
}
main()
{
	int a,b;FILE *out ;
	out = fopen("out.dat","w") ;
	if(fun(111,&a,&b)) {
		printf("111=%d*%d\n",a,b);
		fprintf(out, "111=%d*%d\n",a,b);
	}
	if(fun(11111,&a,&b)) {
		printf("11111=%d*%d\n",a,b);
		fprintf(out, "11111=%d*%d\n",a,b);
	}
	if(fun(1111111,&a,&b)) {
		printf("1111111=%d*%d\n",a,b);
		fprintf(out,"1111111=%d*%d\n",a,b);
	}
   fclose(out);
   getchar();

}

函数fun的作用是:参数xx的前10个元素已经按升序排好序，将参数num按升序插入到数组xx中。

#include <stdio.h>

void func(int xx[], int num)
{
	int n1,n2,pos,i,j;
	pos=xx[9];
	if (num > pos)
/**********found**********/
		xx[10] = num;
	else {
		for(i=0;i<10;i++)
		{
			if(xx[i]>num){
				n1=xx[i];
				xx[i]=num;
				for(j=i+1;j<11;j++){
					n2=xx[j];
					xx[j] = n1;
/**********found**********/
					n1=n2;
				}
/**********found**********/
				break;
			}
		}
	}
}

int main()
{
	int xx[11] = {2,5,7,10,17,51,63,73,85,99};
	int i,num;
	printf("original array is:\n");
	for(i=0;i<10;i++) printf("%5d",xx[i]);
	printf("\n");
	printf("insert a new number:");
	scanf("%d", &num);
	func(xx, num);
	for(i=0;i<11;i++) printf("%5d", xx[i]);
	printf("\n");
	return 0;
}

请编写函数fun，其功能是:将a所指数组主对角线上的元素分别乘以2;次对角线上的元素

分别乘以3，依次放入指针p所指的数组中。计算过程中不得修改a所指数组中的数据。

#include <stdio.h>
#define N  3

void fun( int a[N][N],int *p)
{
	int i,k=0;
	for(i=0;i<N;i++)
	{
		p[k++]=a[i][i]*2;
	}
	for(i=0;i<N;i++)
	{
		p[k++]=a[i][N-1-i]*3;
	}
}
main()
 {   int a[N][N]={ 1,5,7,2,6,8,3,4,9};
     int b[2*N],i;
     fun(a,b);
     for(i=0;i<2*N;i++)
            printf("%d,",b[i]);
}

假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是:将字符串尾部的*号全部删除，前面和中间的*号不删除。例如，字符串中的内容为:****A*BC*DEF*G*******，删除后，字符串中的内容应当是:****A*BC*DEF*G。在编写函数时，不得使用C语言提供的字符串函数。

#include <stdio.h>
void  fun( char *a )
{
	char*q=a;
	while(*q!='\0')
	{
		q++;
	}
	q--;
	while(*q=='*')
	{
		q--;
	}
	*(q+1)='\0';
}

main()
{  char  s[81];
   printf("Enter a string:\n");gets(s);
   fun( s );
   printf("The string after deleted:\n");puts(s);
  getchar();
}

请编写一个函数，用来删除字符串中的所有空格。例如，输入"asd af aa z67"，则输出为"asdafaaz67"。

#include <stdio.h>
#include <string.h>

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

main()
{
  char str[81];

  printf("Input a string:") ;
  gets(str);
  puts(str);
  fun(str);
  printf("*** str: %s\n",str);
  getchar();
}

法二：

#include <stdio.h>
#include <string.h>

void fun(char *str)
{
	int k=0;
	char *p=str;
	while(*p!='\0')
	{
		if(*p!=' ')
		{
			str[k++]=*p;
		}
		p++;
	}
	str[k]='\0';
}

main()
{
  char str[81];

  printf("Input a string:") ;
  gets(str);
  puts(str);
  fun(str);
  printf("*** str: %s\n",str);
  getchar();
}

函数fun的功能是:计算形参x所指数组中N个数的平均值（规定所有数均为正数），将所指数组中大于平均值的数据移至数组的前部，小于等于平均值的数据移至x所指数组的后部，平均值作为函数值返回，在主函数中输出平均值和移动后的数据。例如，有10个正数:46 30 3240 6 17 45 15 48 26，平均值为:30.500000移动后的输出为:46 32 40 45 48 30 6 17 15 26

#include  <stdlib.h>
#include  <stdio.h>
#define   N   10
double fun(double  *x)
{ int  i, j;    double  s, av, y[N];
  s=0;
  for(i=0; i<N; i++)  s=s+x[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;
}
main()
{ int  i;     double  x[N]= {46,30,32,40,6,17,45,15,48,26};
  for(i=0; i<N; i++) printf("%4.0f ",x[i]);
  printf("\n");
  printf("\nThe average is: %f\n",fun(x));
  printf("\nThe result :\n",fun(x));
  for(i=0; i<N; i++)  printf("%5.0f ",x[i]);
  printf("\n");
  getchar();
}

函数fun的功能是:在任意给定的N个正整数中，从左到右依次逐个取三个数作为一组，按值大小找出该组数的中值，用该中值替换与该组数对应的原三个数中的中间位置的数。处理后原数列中首尾2个数不变。处理后数列在主函数中输出。例如，有10个正整数如下:初始数列为:6 5 7 23 18 5 8 21 45 38

第1组数为:6 5 7 中值为:6 替换后的数列为:6 6 7 23 18 5 8 21 45 38

第2组数为:5 7 23 中值为:7 替换后的数列为:6 6 7 23 18 5 8 21 45 38

第3组数为:7 23 18中值为:18替换后的数列为: 6 6 7 18 18 5 8 21 45 38

第4组数为:28 18 5中值为:18替换后的数列为:6 6 7 18 18 5 8 21 45 38

第5组数为: 18 5 8中值为:8 替换后的数列为:6 6 7 18 18 8 8 21 45 38

第6组数为: 5 8 21中值为:8 替换后的数列为:6 6 7 18 18 8 8 21 45 88

第7组数为:8 21 45中值为:21替换后的数列为:6 6 7 18 18 8 8 21 45 38

第8组数为:21 45 38中值为:38替换后的数列为: 6 6 7 18 18 8 8 21 38 38

最终结果为:6 6 7 18 18 8 8 21 38 38

#include  <stdio.h>
#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  t;
}
void fun(int  x[])
{  int  i,a,b,c,t[N];
/**********found**********/
   for(i=0;i<N;i++) t[i]=x[i];
   for(i=0;i<N-2;i++)
   {  a=t[i];b=t[i+1];c=t[i+2];
/**********found**********/
      x[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<N; i++)  printf("%d ",x[i]);
   printf("\n");
   fun(x);
   for(i=0; i<N; i++)  printf("%d ",x[i]);
   printf("\n");
  getchar();
}

请编写函数fun，其功能是:编写函数char *fun(char * s0, char *s1, char *s2,char*s3)，要求实现:将s0所指字符串分解成三个字符串，分别存入s1、s2、 s3所指内存中。分解的方法是，s1、 s2、s3从s0中依次顺序每隔3个字符取1个。例如：s0为"abcdefghij"时，分解完成后，s1、s2、s3分别为: "adgj”、 "beh”、 "cfi”。

#include <stdio.h>
#include <string.h>
void fun(char * s0,char *s1,char *s2, char *s3)
{
	int i,k=0,n=0,m=0;
	for(i=0;i<strlen(s0);i=i+3)
	{
		s1[k++]=s0[i];
		if(i+1<strlen(s0))
			s2[n++]=s0[i+1];
		if(i+2<strlen(s0))
			s3[m++]=s0[i+2];
	}
	s1[k]='\0';
	s2[n]='\0';
	s3[m]='\0';

}
void main()
{
	char  s0[100],s1[40],s2[40],s3[40];
	printf("请输入一行字符串\n");
	gets(s0);
	fun(s0,s1,s2,s3);
	puts(s1);
	puts(s2);
	puts(s3);

1.1函数fun的功能是:根据形参c中指定的英文字母，按顺序打印出若干后继相邻字母，输出字母的大小写与形参c一致，数量由形参d指定。若输出字母中有字母Z或z，则应从A或a开始接续，直到输出指定数量的字母。例如: c为'Y’，d为4，则程序输出ZABC; c为’z’，d为2，则程序输出ab。

#include  <stdio.h>
#pragma warning (disable:4996)
void fun(char c, int d) { 
  int i;
  char A[26], a[26], *ptr;
/**********found**********/
  for (i=0; i<26; i++) {
	A[i] = 'A' + i;
	a[i] = 'a' + i;
  }
/**********found**********/
  if ((c >= 'a') && (c <= 'z')) ptr = a;
  else   ptr = A;
/**********found**********/
  for (i=1; i<=d; i++) printf("%c", ptr[(c-ptr[0]+i) % 26] );
}
main( ) { 
  char c; int d;
  printf("please input c & d:\n");
  scanf("%c%d", &c, &d);
  fun(c, d);
}

1.2函数fun的功能是:将字符串a中的所有字符复制到字符串b中，要求每复制三个字符之后插入一个空格。例如，在调用fun函数之前给字符串a输入:ABCDEFGHIJK，调用函数之后，字符串b中的内容则为: ABC DEF GHI JK

#include <stdio.h>
#pragma warning (disable:4996)
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");
   getchar();
}

1.3函数fun，它的功能是:将ss所指字符串中所有下标为奇数位置上的字母转换成大写（若该位置上不是字母，则不转换）。例如，若输入"abc4EFG"，则应输出"aBc4EFG"。

#include <stdio.h>
#include <string.h>
void fun( char *ss )
{
	int i;
	for(i=0;i<strlen(ss);i++)
	{
		if(i%2!=0&&(ss[i]>='a'&&ss[i]<='z'))
			ss[i]=ss[i]-'a'+'A';
	}
}

void main( void )
{
   char tt[51];
   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 );
   getchar();
}

5.2

函数int my_ isalpha (char c) 的功能是返回字符的种类:大写字母返回1，小写字母返回-1，其他字符返回0。函数void a()调用my_ isalpha()， 根据其返回值决定输出:是大写字母则输出*，是小写字母输出#，是其他字符则输出问号?

#include <stdio.h>
#pragma warning (disable:4996)
int my_isalpha(char c)  
{
	if(c>='A'&&c<='Z') return 1;
	else if(c>='a'&&c<='z') return -1;
	else  return 0; 
}
void a( )					 
{
	char ch;
	int sort;
	printf("本程序判断你从键盘上键入字符的种类,请输入字符（串）：\n");
	do
	{
		ch=getchar();
		if(ch!='\n')
		{
			sort= my_isalpha( ch);        
/**********************found***********************/
			switch(sort)		 
			{
			case 1: printf("%c",'*'); break;
/**********************found***********************/
			case -1: printf("%c",'#');break;
			case 0: printf("%c",'?');
			}
		}
/**********************found***********************/
	}while(ch !='\n');
	printf("%c",'\n');
}
void main( )					  
{
	a();
}

18.3函数fun，函数的功能是:统计一行字符串中单词的个数作为函数值返回。一行字符串在主函数中输入，规定所有单词由小写字母组成，单词之间由若干个空格隔开，一行的开始没有空格。

#include <stdio.h>
#include <string.h>
#define    N   80
int  fun( char  *s)
{
	int count=1,i=0;
	while(s[i]!='\0')
	{
		if(s[i]==' '&&(s[i+1]>='a'&&s[i+1]<='z'))
			count++;
		i++;
	}
	return count;
}
main()
{  char  line[N];    int  num=0;
   printf("Enter a string :\n"); gets(line);
   num=fun( line );
   printf("The number of word is  :  %d\n\n",num);
  getchar();
}

碎月拾梦
关注
计算机二级C语言题库（60套真题+刷题软件）2024年新题第二套
sybh的博客
10-08 3万+
1、在数据库的三级模式中,外模式（用户模式或子模式）_____。A. 只有3个B. 只有2个C. 可以有任意多个D. 只有1个本题考查的知识点是数据库设计基础。外模式也称子模式或用户模式。它是用户的数据视图，也就是用户所见到的数据模式，它由概念模式推导而出。概念模式给出了系统全局的数据描述而外模式则给出每个用户的局部数据描述。一个概念模式可以有若干个外模式，每个用户只关心与它有关的模式，这样不仅可以屏蔽大量无关信息而且有利于数据保护。所以本题答案为C。2、在商场购物时,顾客可以购买不同的商品,而同样的商品也
2个月搞定计算机二级C语言——真题（6）解析
weixin_55010563的博客
10-30 524
题目要求将各位上的偶数取出，需要将各位的数取出后再判断该数是否为偶数，偶数可以通过该数除 2 取余的结果来判断，如果结果为 0 则是偶数，为 1 则是奇数。根据题目提供的数组x、整数e和输出结果可以看出是要求数组中能整除e的，也就是整除e的倍数，所以本题的题目描述错了。// t = 8 时符合条件，x = 64 * 10 + 8，则 x 为 648。// t = 4 时符合条件，x = 6 * 10 + 4，则 x 为 64。// t = 6 时符合条件，x = 0 * 10 + 6，则 x 为 6。
计算机二级c语言题库
热门推荐
pyj2017的博客
06-28 1万+
计算机C语言二级考试程序设计
2个月搞定计算机二级C语言——真题（9）解析
恩贝德电子
11-06 1199
本篇我们讲解2个月搞定计算机二级C语言——真题9。
(计算机二级C语言）程序填空题＜79＞
2301_79580018的博客
02-19 390
【代码】(计算机二级C语言）程序填空题＜79＞
计算机二级c语言程序设计（35套）
uoik4的博客
02-28 2165
3.注意：不用再写n++了，因为通过函数的调用n已经赋值为10了。
C程序设计课程-2012电子信息 第十三堂课后作业
weixin_30342209的博客
06-03 209
作业1： 输入一个字符串和一个正整数m，将该字符串中的前m个字符复制到另一个字符串中，再输出后一个字符串。 运行示例 Enter a string: abcdefghijk Enter an integer: 6 The new string is abcdef ----------------------分割线---------------------- 作业2： 编一个函数vo...
计算机二级 C语言程序设计 题库.rar
最新发布
02-08
计算机二级C语言程序设计题库是一套专门针对参加中国计算机技术职业资格与水平考试的二级C语言程序设计考试的考生准备的复习资料。这套题库不仅包含了历年来的真题，还涵盖了考试大纲要求掌握的各项知识点和技能点，...
全国计算机等级考试二级C语言程序设计真题试卷合集
08-16
资源名称：全国计算机等级考试二级C语言程序设计真题试卷合集 资源描述： 该资源包含了一套全国计算机等级考试二级C语言程序设计的真题试卷，具体分为五个部分，每个部分包含不同数量的题目。试卷内容涵盖了C语言...
全国计算机二级C语言试题与答案.pdf
03-23
### 全国计算机二级C语言试题与答案解析 #### 一、选择题解析 ##### 2.1 C语言的特点 **正确答案:** C - **选项解析:** - **A**: "C语言比其他语言高级"。这种表述不准确。编程语言的“高级”与否并不是绝对的...
全国计算机等级考试二级C语言程序设计真题详解及考前密押试卷参考答案与解析
08-16
全国计算机等级考试二级C语言程序设计真题详解及考前密押试卷参考答案与解析 资源描述： 本资源是一本专为全国计算机等级考试二级C语言程序设计的考生准备的真题详解及考前密押试卷的参考答案与解析手册。该手册...
运用结构体数组与输入函数进行存放学生的学号姓名等数据
03-15
学习使用C语言，并熟练掌握其操作过程。用数组和结构体实现保存文件，录入内容为所有同学的学号、姓名、语文成绩和数学成绩。
计算机二级C语言考试题库--程序填空题
03-31
该文档为计算机二级C语言考试的程序填空题部分，该文档内的程序填空题均为计算机二级C语言题库中题目，本人与同学合作亲自从计算机二级C语言题库中截屏所得，该文档内容包括三部分：程序填空题的题目、程序（含空）以及答案。本人将计算机二级C语言题库中的程序填空题、程序修改题、程序设计题分别截屏至三个文档中，本次上传为”程序填空题”。题库程序文档可参考：https://download.youkuaiyun.com/download/qq_41900772/11243757（计算机二级C语言程序设计题库程序）
c语言考试 程序填空题,【经典题整理】计算机二级C语言考试程序填空题.docx
weixin_28724319的博客
05-17 1315
程序填空题(共15题)1、在考生文件夹下，给定程序FILL.C的功能是：求二分之一的圆面积，函数通过形参得到圆的半径，函数返回二分之一的圆面积(注意：圆面积公式为：S=3.14159*r*r，在程序中定义的变量名要与公式的变量相同)。例如，输入圆的半径值：2.5，输出为s=9.817469。#include /************found************/double fun ( f...
计算机二级C语言程序填空题+答案解析+源代码（一）
Miracle1203的博客
02-08 6278
题目 1.使用vc++2010打开考生文件夹下的blank1中的解决方案，此解决方案中包括一个源文件blank1.c。程序通过定义学生结构体变量，存储了学生的学号，姓名，和三门课的成绩。所有学生数据都以二进制方式输入到文件中。函数fun的功能是重写filename所指文件中最后一个学生的数据，即用新的学生数据覆盖原来学生的数据，其他学生数据不变。请在程序下划线处填入正确的答案并把下划线删掉，使得程...
计算机二级-C语言-程序填空题-190117记录-对文件的处理，复制两个文件，往新文件中写入数据。...
weixin_30379911的博客
01-17 654
//给定程序的功能是，调用函数fun将指定源文件中的内容赋值到指定目标文件中，复制成功时函数返回1，失败时返回0，把复制的内容输出到终端屏幕。主函数中源文件名放在变量sfname中，目标文件名放在变量tfname中。 //重难点：对文件的处理。如何判断文件是否达到末尾，如何往文件中写入数据。 1 #include <stdio.h> 2 #include &l...
结构体数组存放学生信息并排序输出
XueRui
04-10 3230
使用选择法进行排序，代码： #include using namespace std; struct Students { int num; char name[20]; char sex; int score; }; int main() { struct Students su[5
计算机二级考试c语言程序填空题,计算机二级C语言真题填空题
weixin_35410816的博客
05-17 627
{ if(x[m]>i) {i=x[m]; p0=m;}else if(x[m]}t=x[p0]; x[p0]=x[n-1]; x[n-1]=t;t=x[p1];x[p1]= _[14]_______; _[15]_______=t;}main(){ int a[10],u;for(u=0;u<10;u++) scanf("%d",&a);f(a,10);for(u=0;u&l...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值