GESP C++ 2023年9月二级真题卷

一、单选题（每题 2 分，共 30 分）

第 1 题 我国第一台大型通用电子计算机使用的逻辑部件是（ ）。

A. 集成电路

B. 大规模集成电路

C. 晶体管

D. 电子管

答案：D

解析：

计算机发展历史：

第一代：真空管（电子管）计算机

电脑的前身是一种叫"加法器"的东西，是由法国的一位数学家"布莱士·帕斯卡"所发明后来又渐渐改良...可以做加减乘除的四则运算的"差分机"。

第二代：晶体管计算机

晶体管的发明，在计算机领域引来一场晶体管革命，它以尺寸小、重量轻、寿命长、效率高、发热少、功耗低等优点改变了电子管元件运行时产生的热量太多、可靠性较差、运算速度不快、价格昂贵、体积庞大这些缺陷，从此大步跨进了第二代的门槛。

第三代：集成电路计算机

1958年德州仪器的工程师Jack Kilby发明了集成电路(IC)，将三种电子元件结合到一片小小的硅片上。更多的元件集成到单一的半导体芯片上，计算机变得更小，功耗更低，速度更快。这一时期的发展还包括使用了操作系统，使得计算机在中心程序的控制协调下可以同时运行许多不同的程序。

第四代：超大规模集成电路计算机

1967年和1977年分别出现了大规模和超大规模集成电路。第四代计算机是指从1970年以后采用大规模集成电路（LSI）和超大规模集成电路（VLSI）为主要电子器件制成的计算机。例如80386微处理器，在面积约为10mm X l0mm的单个芯片上，可以集成大约32万个晶体管。

第 2 题 下列流程图的输出结果是（ ）？

A. 5 12

B. 12 5

C. 5 5

D. 12 12

答案：B

解析：根据流程图，将x，y的数值按从大到小排列

第 3 题 如果要找出整数 a 、 b 中较大一个，通常要用下面哪种程序结构？（ ）。

A. 顺序结构

B. 循环结构

C. 分支结构

D. 跳转结构

答案：C

解析：参考题2

第 4 题 以下不是 C++ 关键字的是（ ）。

A. continue

B. cout

C. break

D. goto

答案：B

解析：略

第 5 题 C++ 表达式 int(-123.123 / 10) 的值是（ ）。

A. -124

B. -123

C. -13

D. -12

答案：D

解析：在C++中，对一个浮点数进行整数除法时，会进行截断而不是四舍五入。因此，对于表达式 int(-123.123 / 10)，先进行除法运算，得到 -12.3123，然后进行截断取整，结果是 -12。

第 6 题 以下 C++ 代码实现从大到小的顺序输出 N 的所有因子。例如，输入 N = 18 时，输出 18 9 6 3 2 1 ，横线处应填入（ ）。

A. ; ;

B. int i = 1; i < N; i++

C. int i = N; i > 0; i--

D. int i = N; i > 1; i--

答案：B

解析：代码 如果N除以i的余数等于0，那么输出i，所以在横线位置遍历i从1到N，只有选项B符合要求。

第 7 题 如下图所示，输出 N 行 N 列的矩阵，对角线为 1 ，横线处应填入（ ）。

A. i = j

B. j != j

C. i >= j

D. i == j

答案：D

解析：观察图片发现，只有（ i == j ）处，输出的是1，其他位置都是0.

第 8 题 下面 C++ 代码用于判断 N 是否为质数（素数），约定输入 N 为大于等于 2 的正整数，请在横线处填入合适的代码（ ）。

A. break

B. continue

C. exit

D. return

答案：A

解析：

质数：除了1和本身没有其他因数的数

在 C++ 中，break 和 continue 是两个控制语句，用于在循环中控制程序流程。

1. break 语句： break 语句用于立即终止当前所在的循环（for、while 或 do-while 循环），然后跳出循环体，继续执行循环后面的代码。使用 break 可以提前跳出循环，而不必等到循环条件不满足才结束。
2. continue 语句： continue 语句用于立即跳过当前循环体中的剩余代码，然后继续执行下一次循环迭代。使用 continue 可以在满足某个条件时，跳过本次循环的剩余部分，而不终止整个循环。
3. 横线处需要填写一个终止当前循环语句，所以答案A符合

第 9 题 下面 C++ 代码执行后的输出是（ ）。

A. 1#0

B. 1#

C. 1#1#1#1#1#1

D. 1#1#1#1#1#1#0

答案：D

解析：条件语句中的条件N除以i的余数不等于0时，输出1#；所以当i=2,4,5,6,7,8时，一共有6个数字符合条件，所以答案选D

第 10 题 下面 C++ 代码执行后的输出是（ ）。

A. 16

B. 28

C. 35

D. 36

答案：A

解析：

这是因为，外层循环从1到8循环，内层循环从1开始，每次增加2，直到小于外层循环的计数器i。因此，内层循环的迭代次数如下：

• i = 1: 0次
• i = 2: 1次（j=1）
• i = 3: 1次
• i = 4: 2次（j=1，3）
• i = 5: 2次
• i = 6: 3次（j=1，3，5）
• i = 7: 3次
• i = 8: 4次（j=1，3，5，7）

因此，总共有16次迭代，cnt的值增加了16次，最终的值为16。

第 11 题 下面 C++ 代码执行后的输出是（ ）。

A. 1

B. 3

C. 15

D. 没有输出

答案：B

解析：

外层循环 for (int i = 1; i < 13; i += 3) 每次增加3，内层循环 for (int j = 1; j < i; j += 2) 每次增加2。然后，对于每个内层循环，检查 if (i * j % 2 == 0) 是否成立，如果成立就执行 break 中断内层循环，否则增加 cnt 的值。

现在我们逐步分析内层循环的执行：

1. 当 i = 1 时，内层循环没有执行，因为 j < i 不满足条件。
2. 当 i = 4 时，内层循环执行一次，j = 1，i * j 是偶数，因此执行 break 中断内层循环。
3. 当 i = 7 时，内层循环执行两次，j = 1，3，5三次都不满足 i * j % 2 == 0 条件，所以 cnt 值增加3。
4. 当 i = 10 时，内层循环执行三次，j = 1，i * j 是偶数满足条件，所以 break。

最后，将 cnt 的值输出，即 cout << cnt;，得到的结果是 3。

第 12 题 下面 C++ 代码执行后的输出是（ ）。

A. 1

B. 3,9,11

C. 3,6,9,10

D. 1,5,7,11,13,15
答案：B

解析：

1. 初始时，x 的值为 1。
2. 进入 while 循环，首先检查 if (!(x % 3))，如果 x 是3的倍数，输出 x 的值并在后面加上逗号。在这个阶段，x 的值为 1，因此不满足条件，不执行这个分支。
3. 接下来，进入 else if (x / 10) 分支。这个条件会在 x 超过等于 10 时成立。此时 x 为 1，所以条件不成立，不执行 break，继续执行 x += 2;。
4. 循环继续，此时 x 变为 3。再次进入 if (!(x % 3)) 分支，因为 3 是 3 的倍数，所以输出 3。
5. 循环继续，x 变为 5，然后 7，9，11。在x是9的时候，9是3的倍数，所以输出3。
6. 在 x 变为 11 时，再次进入 else if (x / 10) 分支，因为此时 x 除以 10 的结果为 1（整数除法），条件成立，执行 break，跳出循环。
7. 最后，输出循环结束时的 x 的值，即 11。

第 13 题 下面图形每一行从字母 A 开始，以 ABC 方式重复。行数为输入的整数。请在 C++ 代码段横线处填入合适代码 （ ）。

A. 'A' + j / 3

B. (char)('A' + j / 3)

C. 'A' + j % 3

D. (char)('A' + j % 3)

答案：D

解析：分析程序，两层循环嵌套

1.外层循环控制行数，一共7行

2.内存循环输出每行的个数，个数和行数相等，例如第1行只输出A，第二行输出AB，第三行输出ABC

3.每行输出的字母“以ABC方式重复”，所以只有答案D符合要求

第 14 题 输入行数，约定1<=lineCount<=9 ，输出以下图形。应在C++ 代码横线处填入（ ）。

A. (lineCount - i - 1) * 2

B. (lineCount - i) * 2

C. lineCount - i - 1

D. lineCount - i

答案：A                

解析：通过分析图片，发现1前面有16个空格，2前面有12个空格...1前面0个空格

只有选项A符合题意

第 15 题 某班级人数不知，连续输入成绩直到输入负数停止，输入结束后求出平均成绩。在以下 C++ 代码横线处应 填入是（ ）。

A. true

B. false

C. True

D. False

答案：A                

解析：

1.在C++中，True 不是一个合法的标识符。C++是区分大小写的，所以True会被认为是一个未声明的标识符，从而导致编译错误。

2.bool值只有两个值，false和true。

3.如果你想要一个一直循环的程序可以使用while（true）和for（；；），直到遇到break或者return语句

二、判断题（每题2分，共20分）

第 1 题 我们常说的互联网（ Internet ）是一个覆盖全球的广域网络，它不属于任何一个国家。

答案：正确

解析：略

第 2 题 神威 · 太湖之光超级计算机是中国自主研制的超级计算机，在全球超级计算机 TOP500 排行榜中多次荣膺榜首。

答案：正确

解析：略

第 3 题 C++ 表达式 7.8 / 2 的值为 3.9 ，类型为 float 。

答案：错误

解析：

在C++中，表达式 7.8 / 2 的值为 3.9，一般默认类型为 double。如果需要将其转换为 float 类型，可以使用强制类型转换运算符

第 4 题 C++ 表达式 (2 * 3) || (2 + 5) 的值为 67 。

答案：错误

解析：在C++中，表达式 (2 * 3) || (2 + 5) 的值为 1。这是因为 || 运算符表示逻辑或，只要其中一个操作数为真，整个表达式的结果就为真。在这个表达式中，(2 * 3) 的结果为 6，而 (2 + 5) 的结果为 7，它们都被视为真。因此，整个表达式的结果为真，即 1。

第 5 题 如果 m 和 n 为 int 类型变量，则执行 for (m = 0, n = 1; n < 9; ) n = ((m = 3 * n, m + 1), m -

1); 之后 n 的值为偶数。

答案：正确

解析：

1、逗号表达式

C++中的逗号表达式是一种特殊的运算符，它可以将多个表达式组合在一起，并按顺序执行。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。从本质上讲，逗号的作用是导致一系列运算被顺序执行。最右边的那个表达式的值将作为整个逗号表达式的值，其他表达式的值会被丢弃。

逗号表达式的一般形式为：表达式1, 表达式2。求解过程是：先求解表达式1，再求解表达式2。整个逗号表达式的值是表达式2的值。

int a = 1, b = 2, c = 3;
int d = (a++, b++, c++);

在这个例子中，d 的值将为 3，因为整个逗号表达式的值是 c++，即 3。在求解过程中，a++ 和 b++ 的值都会被计算，但是它们的值都会被丢弃，因为它们不是整个逗号表达式的最后一个表达式。

请注意，逗号表达式的优先级非常低，因此在使用逗号表达式时，应该使用括号来明确优先级。例如

int a = 1, b = 2, c = 3;
int d = ((a++, b++), c++);

在这个例子中，d 的值将为 4，因为整个逗号表达式的值是 c++，即 3。但是，在求解过程中，a++ 和 b++ 的值都会被计算，因为它们被括在一对括号中，这样它们就可以在整个逗号表达式之前被计算。

2、分析题目

让我们来分析这个 for 循环的执行过程：

for (m = 0, n = 1; n < 9; ) {
    n = ((m = 3 * n, m + 1), m - 1);
}

首先，初始化语句为 m = 0, n = 1;，然后进入循环。条件是 n < 9。

循环体内的语句是 n = ((m = 3 * n, m + 1), m - 1);。这是一个逗号表达式，逗号表达式会依次执行其中的表达式，并返回最后一个表达式的值。

1. m = 3 * n：计算 3 * n 的值，将其赋给 m。
2. m + 1：将 m 的值加1。
3. ,：逗号操作符，返回表达式序列中的最后一个表达式的值。
4. m - 1：将 m 的值减1，并将结果赋给 n。

所以，每次循环都会更新 m 和 n 的值。现在我们来迭代执行这个循环：

1. 第一次循环：

   • 初始值：m = 0, n = 1
   • 计算：m = 3 * 1 = 3，m + 1 = 4，m - 1 = 3 - 1 = 2
   • 最终：n = 2

2. 第二次循环：

   • 初始值：m = 3, n = 2
   • 计算：m = 3 * 2 = 6，m + 1 = 7，m - 1 = 6 - 1 = 5
   • 最终：n = 5

3. 第三次循环：

   • 初始值：m = 6, n = 5
   • 计算：m = 3 * 5 = 15，m + 1 = 16，m - 1 = 15 - 1 = 14
   • 最终：n = 14

第 6 题 如果 a 为 int 类型的变量，则表达式 (a >= 5 && a <= 10) 与 (5 <= a <= 10) 的值总是相同的。

答案：错误

解析：

正确的方式是使用逻辑与运算符 && 来组合两个比较表达式，如 (a >= 5 && a <= 10)。这样可以确保 a 的值在区间 [5, 10] 内。

第 7 题 下面 C++ 代码执行后的输出为 10 。

答案：错误

解析：

1.使用了一个 for 循环，并在循环体内对计数器 cnt 进行了增加和对循环变量 i 进行了增加。由于 i += 1 会在每次迭代时执行，因此实际上相当于 i 每次增加了2。
2.这个代码片段中的循环会从 i = 1 开始，每次迭代都会执行 cnt += 1;，然后 i 增加2。由于循环条件是 i < 10，因此循环将执行5次（i 分别为 1、3、5、7、9）。所以，cnt 的最终值是5。

第 8 题 执行以下 C++ 代码后的输出为 0 。

答案：错误

解析：这个代码片段中的循环将从 i = -100 开始，每次迭代 i 都会增加2，循环条件是 i < 100。在每次迭代中，rst 累加了当前的 i 的值。

i从 -100 到 98（不包括 100），这是一个等差数列。你可以使用等差数列求和的公式，或者直接计算出这个范围内的偶数和。

使用等差数列求和公式：Sn=(a1+an)*n/2 

项数 n：【98−(−100)】/2+1=100（加1是因为包括了0），首项 a1​ 为 -100，末项 an​ 为 98。

S=100​*(−100+98)/2=-100

第 9 题 执行以下 C++ 代码后的输出为 30 。

答案：错误

解析：rst是i的累加之和，i从0开始，直到<10，i=i+2，i每次增加2，所以i=0,2,4,5,6,8，rst=2+4+6+8=20

第 10 题 C++ 是一种高级程序设计语言。

答案：正确

解析：略

三、编程题（每题 25 分，共 50 分）

编程题 1

试题编号 ： 2023-09-23-02-C-01

试题名称 ：小杨的 X 字矩阵

时间限制 ： 1.0 s

内存限制 ： 128.0 MB 3.1.1

问题描述

小杨想要构造一个 N*N的 X 字矩阵（N 为奇数），这个矩阵的两条对角线都是半角加号 + ，其余都是半角减号 - 。例如，一个 5*5的 X 字矩阵如下：

请你帮小杨根据给定的 打印出对应的 “X 字矩阵 ” 。

3.1.2 输入描述

一行一个整数 N（ 5<=N<=49，保证 N为奇数）。

3.1.3 输出描述

输出对应的 “X 字矩阵 ” 。

请严格按格式要求输出，不要擅自添加任何空格、标点、空行等任何符号。你应该恰好输出N 行，每行除了换行符外恰好包含 N个字符，这些字符要么是 + ，要么是 - 。

3.1.4 特别提醒

在常规程序中，输入、输出时提供提示是好习惯。但在本场考试中，由于系统限定，请不要在输入、输出中附带任何提示信息。

3.1.5 样例输入 1

3.1.6 样例输出 1

3.1.7 样例输入 2

3.1.8 样例输出 2

3.1.9 参考程序

#include 
using namespace std;

int main() {
    // 从用户输入中获取矩阵的大小
    int n;
    cin >> n;

    // 外层循环控制行数
    for (int i = 0; i < n; i++) {
        // 内层循环控制列数
        for (int j = 0; j < n; j++) {
            // 如果当前元素位于主对角线或副对角线上，输出"+"
            if (i == j || i + j == n - 1)
                cout << "+";
            else
                // 否则输出"-"
                cout << "-";
        }
        // 换行，表示当前行输出结束
        cout << endl;
    }

    // 程序结束
    return 0;
}

编程题 2

试题编号 ： 2023-09-23-02-C-02

试题名称 ：数字黑洞

时间限制 ： 1.0 s

内存限制 ： 128.0 MB

3.2.1

问题描述

给定一个三位数，要求各位不能相同。例如， 352是符合要求的，112是不符合要求的。将这个三位数的三个数字重 新排列，得到的最大的数，减去得到的最小的数，形成一个新的三位数。对这个新的三位数可以重复上述过程。神奇的是，最终一定会得到495！

试试看，重新排列 352，得到的最大数为532，最小数是235，它们的差是297；变换297，得到972-279=693；变换693,963-369=594,954-459=495。因此，352经过4次变换得到了495。 现在，输入的三位数，你能通过编程得出，这个三位数经过多少次变换能够得到 495 吗？

3.2.2 输入描述

输入一行，包含一个符合要求的三位数N 。

3.2.3 输出描述

输出一行，包含一个整数G ，表示经过G 次变换得到495。

3.2.4 样例输入 1

3.2.5 样例输出 1

3.2.6 参考程序

官方给的参考答案有点麻烦，根据当前学生的水平，我做了一点简化

#include
using namespace std;
int main() {
    int n;
    cin >> n;
    
    int t = 0;  // 初始化计数器

    // 交换确保 mg 是最大的，mb 是最小的
    while (n != 495) {
        int mg = n % 10, ms = n / 10 % 10, mb = n / 100;
        if (mg < ms) swap(mg, ms);
        if (mg < mb) swap(mg, mb);
        if (ms < mb) swap(ms, mb);
        int max=mg*100+ms*10+mb;
        int min=mb*100+ms*10+mg;
        n=max-min;
        t++;
    }
    
    cout << t << endl;  // 输出循环次数
    
    return 0;
}

官方给的参考答案：

#include 
using namespace std;

int main() {
    int n = 0;
    cin >> n;

    for (int t = 0; ; t++) {
        // 如果 n 等于 495，输出循环次数并退出循环
        if (n == 495) {
            cout << t << endl;
            break;
        }

        // 将三位数的各个位拆分为个位、十位和百位
        int m0 = n % 10, m1 = n / 10 % 10, m2 = n / 100;

        // 初始化最大值和最小值
        int tmax = 0, tmin = 0;

        // 根据不同的位数大小关系，生成最大值和最小值
        if (m0 >= m1 && m1 >= m2) {
            tmax = m0 * 100 + m1 * 10 + m2;
            tmin = m2 * 100 + m1 * 10 + m0;
        } else if (m0 >= m2 && m2 >= m1) {
            tmax = m0 * 100 + m2 * 10 + m1;
            tmin = m1 * 100 + m2 * 10 + m0;
        } else if (m1 >= m0 && m0 >= m2) {
            tmax = m1 * 100 + m0 * 10 + m2;
            tmin = m2 * 100 + m0 * 10 + m1;
        } else if (m1 >= m2 && m2 >= m0) {
            tmax = m1 * 100 + m2 * 10 + m0;
            tmin = m0 * 100 + m2 * 10 + m1;
        } else if (m2 >= m0 && m0 >= m1) {
            tmax = m2 * 100 + m0 * 10 + m1;
            tmin = m1 * 100 + m0 * 10 + m2;
        } else { // m2 >= m1 && m1 >= m0
            tmax = m2 * 100 + m1 * 10 + m0;
            tmin = m0 * 100 + m1 * 10 + m2;
        }

        // 更新 n 为最大值和最小值的差值
        n = tmax - tmin;
    }

    return 0;
}