前言

最近计算机二级的c语言快要考试了，我从网上摘抄了一些c语言二级的原题，并利用gpt做了一些解析来理解这些问题，以便大家能够更好的学习。

同时，我将问题答案设置为白色（只需要选中就可以查看），大家可以在理解问题的同时进行练习。

资料相关

1. Dotcpp——里面有C语言原题以及众多高校试卷，可以用来练习
2. 计算机二级考试官网——没有报名的同学千万别忘了
   
3. 资源绑定里面有c语言计算机二级的考纲（2023版）

程序题 一（字符串）

给定程序中，函数fun的功能是：在形参s所指字符串中寻找与参数c相同的字符，并在其后插入一个与之相同的字符，若找不到相同的字符则函数不做任何处理。

例如，s所指字符串为：baacda，c中的字符为：a，执行后s所指字符串为：baaaacdaa。

请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。

注意：源程序存放在考生文件夹下的BLANK1.C中。

不得增行或删行，也不得更改程序的结构！

#include<stdio.h>
void fun(char *s, char c)
{
    int i, j, n;
    for(i=0; s[i]!=___1___ ; i++)
    if(s[i]==c)
    {
        n=___2___ ;
        while(s[i+1+n]!='\0') n++;
        for(j=i+n+1; j>i; j--) s[j+1]=s[j];
        s[j+1]=___3___ ;
        i=i+1;
    }
}
int 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);
	return 0;
}

1. 正确答案： ‘\0’
2. 正确答案： 0
3. 正确答案： c

• fun 函数接受一个字符串 s 和一个字符 c 作为参数。

• for 循环遍历字符串 s 直到遇到字符串结束符 \0。

• 在循环中，如果当前字符与目标字符 c相等，就执行以下操作：

  • 初始化变量 n 为 0。
  • 使用 while 循环找到目标字符后的子串的长度，即 n。
  • 从字符串末尾开始，将原字符串中的字符向后移动一个位置，为插入字符 c 空出位置。
  • 在原字符位置插入字符 c。
    更新循环变量 i，以跳过刚刚插入的字符，避免重复处理。

• main 函数中声明一个字符串 s 并初始化为 "baacda"，然后接受用户输入的字符 c。

  • 调用 fun 函数对字符串进行处理。最后打印处理后的字符串。

所以，如果用户输入字符 a，程序将在字符串中找到每个 a，并在其后插入一个额外的 a，最终输出结果为 “baaaacdaa”。

程序题 二（数组）

在主函数中从键盘输入若干个数放入数组中，用0结束输入并放在最后一个元素中。给定程序MODI1.C中函数fun的功能是：计算数组元素中值为正数的平均值（不包括0）。

例如：数组中元素中的值依次为：39,-47,21,2,-8,15,0，则程序的运行结果为：19.250000。

请改正程序中的错误，使它能得出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！

#include<stdio.h>
double fun ( int x[])
{
    ____1____
    int c=0, i=0;
    while (x[i] != 0)
    {
        if (x[i] > 0)
        {
            sum += x[i]; c++;
        }
        i++;
    }
    ____2____
    return sum;
}
int 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 ));
    return 0;
}

1. 正确答案： double sum=0;
2. 正确答案： sum /= c;

• 函数 fun：

  • double fun(int x[]): 这是一个函数原型，接受一个整数数组 x 作为参数，返回一个双精度浮点数（double）表示正数的平均值。
  • double sum = 0.0;: 在函数内部声明一个 sum 变量并初始化为0.0，用于存储正数的总和。
  • int c = 0, i = 0;: 声明两个整数变量 c 和 i，其中 c 用于计数正数的个数，i 用于迭代数组元素。
  • while (x[i] != 0): 进入一个 while 循环，循环条件是数组元素不等于0。这是因为输入的数组以0作为结束标志。
  • if (x[i] > 0) { sum += x[i]; c++; }: 如果当前数组元素为正数，则将其加到 sum 中，并增加正数计数器 c。
  • i++;: 增加迭代器 i，移动到下一个数组元素。
  • sum /= c;: 计算正数的平均值，将总和 sum 除以正数的个数 c。
  • return sum;: 返回计算得到的正数平均值。

• 主函数 main：

  • int x[1000];: 在主函数中声明一个大小为1000的整数数组 x。
  • int i = 0;: 声明整数变量 i，用于迭代数组元素的索引。
  • printf("\nPlease enter some data (end with 0): ");: 打印提示信息，要求用户输入数据，直到输入0为止。
  • do { scanf("%d", &x[i]); } while (x[i++] != 0);: 使用 do-while 循环从键盘读取整数，将它们存储到数组中，直到输入0为止。注意，这里使用 i++ 来实现读取下一个数组元素，并检查该元素是否为0来决定是否继续循环。
  • printf("%f\n", fun(x));: 调用 fun 函数计算数组中正数的平均值，并使用 printf 打印结果。

程序题 三（基础）

编写函数fun，函数的功能是：根据以下公式计算s，计算结果作为函数值返回；n通过形参传入。

$$S=1+\frac{1}{1+2}+\frac{1}{1+2+3}+\dots +\frac{1}{1+2+3+\dots +n}$$

例如：若n的值为11时，函数的值为：1.833333

注意：部分源程序在文件PROG1.C中。

请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。

给定源程序：

#include<stdio.h>
float fun(int n)
{
    ____1____
    ____2____
    for(____3____)
    {
        ____4____
        for(____5____)
        t+=j;
        ____6____
    }
    return s;
}
main()
{
    int n;
    float s;
    printf("\nPlease enter N:");
    scanf("%d", &n);
    s = fun(n);
    printf("the result is: %f\n", s);
}

1. 正确答案： int i, j, t;
2. 正确答案： float s=0;
3. 正确答案： i=1;i<=n;i++
4. 正确答案： t=0;
5. 正确答案： j=1;j<=i;j++
6. 正确答案： s=s+1./t;

• 变量声明：int i, j, t; float s = 0; 在fun函数开始处，声明了三个整型变量 i、j 和 t，以及一个浮点型变量 s。这些变量用于循环和计算。

• 循环

  • 外部循环：for (i = 1; i <= n; i++)，使用 for 循环，变量 i 从1开始递增，直到达到传入的 n 的值。

  • 内部循环：for (j = 1; j <= i; j++);在外部循环中，使用 for 循环，变量 j 从1开始递增，直到达到 i 的值。这个内部循环用于计算公式中的分母部分的和。

    • 内部循环中的累加：t += j; 在内部循环中，变量 t 用于累加 j 的值，即计算公式中的分母部分的和。

  • 计算公式中的分数部分：s += 1.0 / t; 在每次外部循环结束时，通过将1除以 t 的值，得到公式中的分数部分，然后将其累加到变量 s 中。

• 返回最终结果：return s; 函数 fun 返回计算得到的 s 的值。

• 用户输入和输出：

  int main()
  {
      // ...
  
      printf("\nPlease enter N:");
      scanf("%d", &n);
  
      s = fun(n);
  
      printf("The result is: %f\n", s);
  
      // ...
  }
  

  主函数负责接收用户输入的 n，调用 fun 函数计算结果，并输出最终的计算结果。

程序题 四（结构体）

给定程序BLANK1.C中，函数fun的功能是在数组中找出两科成绩之和最高的学生并返回其在数组中的下标。对所给函数int fun（STU*d，int n），主函数传给形参d的是学生数组名，而传给形参n的是该数组中学生的个数。

例如，若学生数组数据为：
2016500301李清水83 92
2016500336 刘世才85 94
2016500371王子晨88 88

则调用该函数后，程序输出为：2016500336刘世才85 94

请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。

注意：不得增行或删行，也不得更改程序的结构！

#include<stdio.h>
typedef struct stu
{
    char ID[30];
    char name[20];
    int score[2];
} STU;
int fun(STU *d,int n)
{
    int i,m;
    /******found******/
    ______(1)______;
    for(i=1;i<n;i++)
    /******found******/
        if(d[i].score[0]+d[i].score[1]>________(2)________)
            m=i;
    /******found******/
    ______(3)______;
}
 
void main()
{
    STU a[10]={ "2016500301","李清水",83,92,"2016500336","刘世才",85,94,"2016500371","王子晨",88,88};
    int i,n=3;
    i=fun(a,n);
    printf("%30s%20s%4d%4d",a[i].ID,a[i].name,a[i].score[0],a[i].score[1]);
    printf("\n");
}

1. 正确答案： m=0
2. 正确答案： d[m].score[0]+d[m].score[1]
3. 正确答案： return m

• 结构体定义：

  typedef struct stu
  {
      char ID[30];
      char name[20];
      int score[2];
  } STU;
  

  定义了一个结构体 stu，用于存储学生的信息，包括学号（ID）、姓名（name）和两科成绩（score）。

• 函数定义：

  int fun(STU *d, int n)
  {
      int i, m;
      /******found******/
      m = 0; // 初始化 m 为数组的第一个学生的下标
      for (i = 1; i < n; i++)
      /******found******/
          if (d[i].score[0] + d[i].score[1] > d[m].score[0]+d[m].score[1])
              m = i; // 更新 m 为当前学生的下标，如果其成绩之和更高
      /******found******/
      return m; // 返回最终找到的学生的下标
  }
  

  函数 fun 接收一个指向学生数组的指针 d 和数组中学生的个数 n。函数通过遍历数组找到两科成绩之和最高的学生，并返回其在数组中的下标。

• 主函数中的调用和输出：

  void main()
  {
      STU a[10] = { "2016500301", "李清水", 83, 92, "2016500336", "刘世才", 85, 94, "2016500371", "王子晨", 88, 88 };
      int i, n = 3;
      i = fun(a, n);
      printf("%30s%20s%4d%4d", a[i].ID, a[i].name, a[i].score[0], a[i].score[1]);
      printf("\n");
  }
  

  在主函数中，定义了一个包含三个学生信息的数组 a，然后调用了 fun 函数，得到两科成绩之和最高的学生的下标，最后输出该学生的信息。

程序题 五（结构体）

给定程序MODI1.C中，函数void list（MYDATA *h）的功能是：列出带头结点单链表中所有没有删除标记的数据。调用这个函数时，传给形参h的是指向单链表头结点的指针。

例如，当10个结点的数据为1,2,3,4,5,6,7,8,9,10时，输出将是：3 4 6 7 8 9 10

其中，各个数据所对应的删除标记是由随机数产生的。

请改正函数list中指定部位的错误，使它能得出正确的结果。

注意：不要改动main函数和creat函数，不得增行或删行

#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->data==0)
        {
            printf("%d  ",p->data);
        }
/******found******/
        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);
}

1. 正确答案： MYDATA *p;
2. 正确答案： if(p->deleted==0)
3. 正确答案： p=p->next;

• 函数定义：void list(MYDATA *h){ /* ... */} 函数 list 的目标是列出带头结点单链表中没有删除标记的数据。

• 局部变量声明：MYDATA *p; p=h->next; 在函数内部声明了一个 MYDATA 类型的结构指针变量 p，并将其初始化为链表的第一个结点。

• 遍历链表：while(p!=NULL){ /* ... */ } 使用 while 循环遍历链表，访问每个结点的数据。

• 判断删除标记：if(p->deleted==0) { printf("%d ",p->data); } 在循环中，如果当前结点的数据没有删除标记，就输出该数据。

• 移动到下一个结点：p=p->next;移动到链表中的下一个结点。这里应该使用 p=p->next; 来正确更新 p。

• 主函数中的调用和输出：list(head);在主函数中调用 list 函数，输出链表中没有删除标记的数据。

程序题 六（基础）

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

注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其他函数中的任何内容，仅在函数fun的花括号中填入所编写的若干语句。

#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 temp=0;
    int i=0;
    temp=*dp;
    if(upordown==0)
   {
    for(i=1;i<n;i++)
    {
        if(dp[i]<temp)
        {
            dp[0]=dp[i];
            dp[i]=temp;
            temp=dp[0];
        }
      }
    }
    else if(/******found******/)
   {
    for(/******found******/)
    {
        if(/******found******/)
        {
            /******found******/
            /******found******/
            /******found******/
        }
    }
}
*dp=temp;
 
}
 
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");
 
}

1. 正确答案： upordown==1
2. 正确答案： i=1;i<n;i++
3. 正确答案： dp[i]>temp
4. 正确答案： dp[0]=dp[i];
5. 正确答案： dp[i]=temp;
6. 正确答案： temp=dp[0];

• 函数定义：void fun(int *dp, int n, int upordown) { /* ... */ } 函数 fun 接收一个整型指针 dp，表示数组的首地址，整数 n 表示数组元素的个数，整数 upordown 表示查找标志，值为0时找最小值，值为1时找最大值。

• 局部变量声明：int temp = 0; int i = 0; 在函数内部声明了两个整型变量 temp 和 i，temp 用于保存当前数组元素的值，i 用于循环计数。

• 初始化 temp：temp = *dp; 将 temp 初始化为数组的第一个元素的值。

• 查找最小值的逻辑：

  if (upordown == 0)
  {
      for (i = 1; i < n; i++)
      {
          if (dp[i] < temp)
          {
              dp[0] = dp[i];
              dp[i] = temp;
              temp = dp[0];
          }
      }
  }
  

  • 如果upordown 为0，表示查找最小值。在循环中，如果当前元素小于 temp，则交换它们，并更新 temp 的值。

• 查找最大值的逻辑：

  else if (upordown == 1)
  {
      for (i = 1; i < n; i++)
      {
          if (dp[i] > temp)
          {
              dp[0] = dp[i];
              dp[i] = temp;
              temp = dp[0];
          }
      }
  }
  

  • 如果 upordown 为1，表示查找最大值。在循环中，如果当前元素大于 temp，则交换它们，并更新 temp 的值。

• 将最小或最大值赋给第一个元素：*dp = temp;最终，将最小或最大值赋给数组的第一个元素。

• 主函数中的调用和输出：

  for (i = 0; i < N - 1; i++)
      fun(data + i, n - i, 0);
  
  display(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);
  

  • 主函数通过调用 fun 函数两次，一次查找最小值，一次查找最大值，然后输出结果。这样可以看到数组中最小值和最大值的位置发生了交换。