GESP Level 2 · 2025-12

客观题逐题讲义

15 道单选 + 10 道判断。每题按“题干 → 自己想 → 答案 → 知识点 → 分步推导 → 易错点”组织,适合课堂讲评和课后复习。

25客观题总数
15单选题
10判断题
50总分

一、GESP 二级大纲知识点回顾

二级不是背零散概念,而是把知识整理成一棵树:先认清计算机和程序语言,再掌握 C++ 表达式、分支循环,最后能稳定手推代码输出。

GESP 二级一棵知识树,四条主干
计算机基础存储、网络、语言分类
C++ 表达式ASCII、类型转换、运算真假
程序结构流程图、分支、循环嵌套
代码阅读画表、追变量、看输出格式
基础概念

1. 计算机存储与网络

RAMROMCacheLAN/MAN/WAN
  • RAM:运行时临时存储,速度快,断电会丢。
  • ROM:只读或固化内容,常用于保存固定程序。
  • Cache:CPU 附近的高速缓存,用来加快访问。
  • 网络范围:PAN 个人,LAN 局域,MAN 城域,WAN 广域。

常考:教学楼、机房、家庭内网一般看作 LAN;“执行判断”通常不是传感器,而是处理器。

记忆线:存储看“掉不掉电”,网络看“覆盖范围”。

语言与环境

2. 程序设计语言与翻译

机器语言汇编语言高级语言编译器
  • 机器语言:计算机最直接能识别,离硬件最近。
  • 汇编语言:用助记符表示机器指令。
  • 高级语言:C++、Python,更接近人的表达。
  • 编译器负责翻译源程序;操作系统负责管理资源和运行环境。

常考:不要把“操作系统能运行程序”误认为“操作系统负责把源代码编译成目标程序”。

记忆线:写代码的是源程序,翻译代码的是编译器,管理电脑的是操作系统。

程序结构

3. 流程图与三大结构

顺序分支循环判断框
  • 顺序结构:从上到下依次执行。
  • 分支结构:根据条件走不同路径,如 `if`、`if...else`、`switch`。
  • 循环结构:条件满足时重复执行,如 `for`、`while`、`do...while`。
  • 流程图判断框通常有“是 / 否”两条出口。

常考:流程图和代码互相对应,读图时先找入口、判断条件、循环变量更新和出口。

记忆线:顺序看方向,分支看真假,循环看“什么时候停”。

字符编码

4. ASCII 与字符计算

空格 32'0' 48'A' 65'a' 97
  • 数字字符连续:`'0'` 到 `'9'`。
  • 大写字母连续:`'A'` 到 `'Z'`。
  • 小写字母连续:`'a'` 到 `'z'`。
  • 字符能参与减法,本质是在用编码值相减。

常考:`'Z' - 'A' = 25`,`'5' - '0' = 5`;大小写编码不同,不能混算成同一段。

记忆线:空格 32,0 是 48,A 是 65,a 是 97。

表达式

5. 类型转换、运算符与真假

/ 商% 余数0 假非 0 真
  • 整数 `/`:得到商,`1 / 3 = 0`。
  • 取模 `%`:得到余数,常用于奇偶、循环节、拆位。
  • 隐式转换:表达式自动转换类型;强制转换:程序员明确指定类型。
  • 关系表达式结果是真或假,输出到整数语境常表现为 1 或 0。

常考:`if (x)` 不是判断 x 是否等于 1,而是判断 x 是否非 0。

记忆线:`/` 看商,`%` 看余;0 假,非 0 真。

控制语句

6. 多层分支与多层循环

ifswitchforwhilebreak/continue
  • 多层分支:先看条件顺序,再看哪一支被执行。
  • `for` 顺序:初始化一次 → 判断 → 循环体 → 更新 → 再判断。
  • `while`:先判断再执行;`do...while`:先执行一次再判断。
  • `continue` 跳到下一轮;`break` 跳出当前循环。

常考:嵌套循环中,`break` 和 `continue` 只影响它所在的那一层循环。

记忆线:for 看四件事:初值、条件、循环体、更新。

库函数

7. 常用数学函数

abssqrtmaxminrand/srand
  • `abs(x)`:绝对值。
  • `sqrt(x)`:平方根。
  • `max(a,b)` / `min(a,b)`:两个数的较大值 / 较小值。
  • `rand()` 产生随机数,`srand()` 设置随机种子。

常考:维护最大值、最小值不一定要排序;读入时边比较边更新即可。

记忆线:函数题先问“它返回什么”,再问“变量是否每轮重置”。

做题方法

8. 代码阅读通用草稿法

圈初值画表追输出核格式
  1. 先圈:输入、初值、循环条件、变量更新、输出语句位置。
  2. 再画表:轮次、关键变量、条件真假、本轮输出、累计输出。
  3. 嵌套循环:先算每个外层值对应的内层次数。
  4. 图形输出:逐行写“空格数 + 字符数 + 换行”。
  5. 最后核对:空格、`#`、换行、输出是否在循环外。

常考:不是算不出,而是漏看 `continue`、`break`、循环后单独的 `if`、输出位置。

记忆线:圈代码、画表格、追输出、查格式。

二、单选题逐题讲评

单选题 · 1

第 1 题(单选题)

#
计算机硬件组成处理器功能

近日,空中客车公司表示,约6000架空客A320系列飞机需要紧急更换一种易受太阳辐射影响的飞行控制软件。空客表示,在对一起飞行事故分析后的结果显示,强烈的太阳辐射可能会损坏飞行控制系统所需的关键数据,导致判断失误,进而引发飞行异常。那这里的飞行控制系统执行判断的部件最可能是下面的()。

A.辐射传感器
B.处理器
C.内存单元
D.输出设备
展开:答案、思考步骤与易错点
正确答案B

知识点讲解

计算机硬件组成;处理器功能

先这样想

按输入、处理、存储、输出四类功能分工,不按设备名字猜。

分步推导

  1. 飞行控制系统中的“判断”本质上是对输入数据进行运算并作出控制决策,这一工作由处理器完成。
  2. 传感器负责采集外界信息,内存单元负责存放数据,输出设备负责把结果显示或执行出去,所以只有 B 符合题意。

解题检查法

把候选部件按功能归类:传感器负责采集,内存负责存放,输出设备负责呈现或执行,处理器负责运算和判断。题干出现“执行判断”,就对应处理器。

易错点

容易把“接收数据”的传感器误当成“做判断”的核心部件。

单选题 · 2

第 2 题(单选题)

#
计算机网络分类局域网

小明最近为了备考 GESP,开始看 B 站上关于网络知识的视频。其中提到计算机网络系统有不同的划分标准,那他平时上学所在的教学楼内的网络是一个()。

A.PAN
B.LAN
C.MAN
D.WAN
展开:答案、思考步骤与易错点
正确答案B

知识点讲解

计算机网络分类;局域网

先这样想

抓覆盖范围:个人、本地、城市、广域,范围越大名称越靠后。

分步推导

  1. 教学楼内部覆盖范围小,连接的是同一建筑内的设备,属于局域网 LAN。
  2. PAN 是个人范围网络,MAN 是城域网,WAN 是广域网,范围都与题目描述不符,所以答案选 B。

解题检查法

按覆盖范围从小到大写一行:PAN、LAN、MAN、WAN。题目说“教学楼内”,范围小且在同一局部区域,所以落在 LAN。

易错点

容易把“学校里用的网络”直接联想到更大的城域网或广域网。

单选题 · 3

第 3 题(单选题)

#
标识符命名规则关键字

下面有关C++变量的说法,正确的是()。

A.不可以用 for 作为变量名,因为 for 是C++的关键字(保留字)。
B._tnt 不可以是变量名,因为变量名的第一个字符必须是英文字母。
C._tnt_ 不可以是变量名,因为最后一个字符容易与减号混淆。
D.可以用 printf 作为变量名,因为 printf 是关键字,但这不是好习惯,因为 printf 有约定的功能与含义。
展开:答案、思考步骤与易错点
正确答案A

知识点讲解

标识符命名规则;关键字

先这样想

先圈关键词,再排除与题意不匹配的选项。

分步推导

  1. `for` 是 C++ 关键字,不能拿来当变量名,所以 A 正确。
  2. 变量名首字符既可以是字母,也可以是下划线,因此 `_tnt` 合法;
  3. 末尾下划线不会因为“像减号”而非法;
  4. `printf` 不是关键字,D 错在把它说成了关键字。

解题检查法

变量名先过三条规则:首字符能否合法、后续字符能否合法、是否撞上关键字。`for` 卡在“关键字”这一条;下划线开头本身不是错误;库函数名和关键字不是一回事。

易错点

容易把“关键字不能作变量名”和“库函数名最好别重名”混成一条规则。

单选题 · 4

第 4 题(单选题)

#
循环小数规律取模运算

一个小数是0.123123123……无限循环,其小数点后1位是1,后2位是2,依此类推,求第N位的值。横线处应填入的代码是( )。

int N;
cin >> N;
remainder = ___;

if (remainder == 0)
    cout << 1;
else if (remainder == 1)
    cout << 2;
else
    cout << 3;
A.N % 3
B.(N - 1) % 3
C.N / 3
D.(N - 1) / 3
展开:答案、思考步骤与易错点
正确答案B

知识点讲解

循环小数规律;取模运算

先这样想

先列变量每轮变化,再看输出语句是否真的执行。

分步推导

  1. 小数部分按 `1,2,3` 三个数字循环出现,第 1 位对应 1,第 2 位对应 2,第 3 位对应 3。
  2. 为了把第 N 位映射到下标 0、1、2,应先把 N 变成从 0 开始计数,所以用 `(N - 1) % 3`。
  3. 这样余数为 0、1、2 时正好分别输出 1、2、3。

考场手写验证法

只测 `N=1,2,3,4` 就够。正确映射必须让第 1 位得到余数 0,第 2 位得到余数 1,第 3 位得到余数 2,第 4 位重新回到余数 0。

N循环节应输出N % 3(N - 1) % 3是否对上代码分支
1110(N - 1) % 3 对
2221(N - 1) % 3 对
3302(N - 1) % 3 对
4110重新回到第 1 个
所以横线应填 `(N - 1) % 3`。

易错点

容易直接写成 `N % 3`,这样第 1 位会被错判到余数 1。

单选题 · 5

第 5 题(单选题)

#
格式化输出`printf` 的 `%g`

某同学执行C++代码时 `printf("%g\n", (3 + 3.1415926535));` 输出 6.14159,其原因最可能是()。

A.C++中整数和浮点数相加时,整数会被转换为浮点数,而某些十进制小数无法精确表示为二进制小数,从而产生某些舍入误差。
B.C++的 `printf` 函数在输出浮点数时根据格式有默认小数点位数,因此输出了较少的位数。
C.3.1415926535 是一个无限循环小数,在计算机中无法精确表示。
D.由于计算机CPU的运算错误导致。
展开:答案、思考步骤与易错点
正确答案B

知识点讲解

格式化输出;`printf` 的 `%g`

先这样想

先确定除法的商和余数分别代表什么,再代入小样例检查。

分步推导

  1. 这里看到的 `6.14159` 主要是输出格式造成的,而不是 CPU 算错。
  2. `%g` 会按照默认精度输出有效数字,必要时自动省去多余位数,所以结果没有把更多小数位全部显示出来。
  3. A 说的是浮点表示误差,但题目现象的直接原因是输出格式;
  4. C 把有限小数说成无限循环小数,明显错误。

考场手写验证法

这题不是追循环,而是对比“真实数值”和“显示结果”。显示少了,优先检查格式串 `%g` 的默认有效数字。

检查项手写内容说明
计算值3 + 3.1415926535 = 6.1415926535数值本身有更多位
屏幕显示6.14159只显示了有限有效数字
格式串%g按默认精度输出有效数字
直接原因是输出格式,不是 CPU 算错。

易错点

容易把“显示得少”误判成“计算过程出错”。

单选题 · 6

第 6 题(单选题)

#
整数除法取模运算

某单位工号的编码规则:编码总长5位,均为数字,前4位依次整除以3其值累加之和除以10的余数为第5位数字。如某工号为76587,前4位分别整除以3后,商分别为2、2、1、2,其累加之和为7,除以10的余数为7,故第5位为7。下面代码依次输入前4位后,两个横线处分别应填的是( )。

int rst = 0, N;
for (int i = 0; i < 4; i++) {
    cin >> N;
    rst += _____; // L1
}
cout << _____; // L2
A.1 | N % 3 2 | rst / 10
B.1 | N % 3 2 | rst % 10
C.1 | N / 3 2 | rst / 10
D.1 | N / 3 2 | rst % 10
展开:答案、思考步骤与易错点
正确答案D

知识点讲解

整数除法;取模运算

先这样想

先确定除法的商和余数分别代表什么,再代入小样例检查。

分步推导

  1. 题目要求把前 4 位“分别整除以 3 后的商”累加,所以 L1 应写 `N / 3`,不能写成 `N % 3`。
  2. 累加完成后,第 5 位要取“除以 10 的余数”,所以 L2 应写 `rst % 10`。
  3. 两空组合起来正好对应 D。

考场手写验证法

直接用题目样例 `7658` 验证两空。表格一画出来,就能同时看清正确的商、错误的余数和 `rst` 的变化。

读入第几位N正确:N / 3若误用:N % 3rst 变化
17210 + 2 = 2
26202 + 2 = 4
35124 + 1 = 5
48225 + 2 = 7
最后输出 `rst % 10 = 7 % 10 = 7`,所以 L1 是 `N / 3`,L2 是 `rst % 10`。

易错点

容易把“整除以 3 后的商”和“除以 3 的余数”混淆。

单选题 · 7

第 7 题(单选题)

#
`for` 循环条件判断取模

下面的 C++ 代码执行后的输出 is()。

for (int i = -2; i < 2; i++)
    if (i % 2)
        printf("%d#", i);
A.-1#1#
B.-1#0#1#
C.-2#-1#1#
D.-2#-1#1#2#
展开:答案、思考步骤与易错点
正确答案A

知识点讲解

`for` 循环;条件判断;取模

先这样想

先列变量每轮变化,再看输出语句是否真的执行。

分步推导

  1. 循环中 `i` 依次取 `-2,-1,0,1`。
  2. 只有当 `i % 2` 的结果非 0 时才会执行 `printf`,因此 `-2` 和 `0` 不输出,`-1` 和 `1` 会输出,结果是 `-1#1#`,对应 A。

考场手写验证法

列出循环变量的每一个取值。注意 C++ 的 `if` 里只有 0 是假,非 0 都是真。

ii < 2?i % 2if 是否进入累计输出
-20
-1-1-1#
00-1#
11-1#1#
2-停止-1#1#
最终输出 `-1#1#`。

易错点

容易把 `if (i % 2)` 误看成“偶数时成立”,实际上非 0 才成立。

单选题 · 8

第 8 题(单选题)

#
嵌套循环累加计数

下面的C++代码执行后其输出是()。

int cnt = 0, N;
for (int i = 1; i < 10; i += 2)
    for (int j = 0; j < i; j++)
        cnt += 1;
cout << cnt;
A.100
B.55
C.45
D.25
展开:答案、思考步骤与易错点
正确答案D

知识点讲解

嵌套循环;累加计数

先这样想

先列变量每轮变化,再看输出语句是否真的执行。

分步推导

  1. 外层循环的 `i` 依次为 `1,3,5,7,9`。
  2. 每次内层循环执行 `i` 次,所以 `cnt` 的总增加次数是 `1 + 3 + 5 + 7 + 9 = 25`。
  3. 程序最后输出 25,因此选 D。

考场手写验证法

嵌套循环计数题先算“每个外层值让内层跑几次”,不用把每一个 `j` 都展开。

外层 ij 的范围内层次数cnt 累计
1011
30,1,234
50..459
70..6716
90..8925
`cout` 在两个循环外面,所以只输出一次 `25`。

易错点

容易只看外层循环执行 5 次,就忽略了内层循环次数随 `i` 变化。

单选题 · 9

第 9 题(单选题)

#
`continue` 与 `break`循环执行过程

下面C++代码执行后其输出是()。

int i,j;
for (i = 1; i < 12; i++) {
    if (i % 2 == 0)
        continue;
    for (j = 0; j < i; j++)
        if (i * j % 2 == 0)
            break;
    if (j >= i)
        cout << i * j << " ";
}
if (i >= 12)
    cout << (i * j);
A.0 0
B.11
C.0
D.0 11
展开:答案、思考步骤与易错点
正确答案C

知识点讲解

`continue` 与 `break`;循环执行过程

先这样想

先列变量每轮变化,再看输出语句是否真的执行。

分步推导

  1. 外层只处理奇数 `i`。
  2. 对任意奇数 `i`,内层从 `j = 0` 开始检查,而 `i * 0 % 2 == 0` 立即成立,所以立刻 `break`,此时 `j = 0`,`j >= i` 不成立,循环体里不会输出任何内容。
  3. 外层结束后 `i` 已变成 12,`j` 仍为 0,因此最后输出 `12 * 0 = 0`,对应 C。

考场手写验证法

这题关键是分清 `continue` 和 `break`。偶数外层直接跳过;奇数进入内层后第一轮 `j=0` 就会 `break`。

外层 i外层判断内层第一步j >= i?循环体内输出
1奇数,进入内层j=0,i*j%2=0,break0 >= 1 为假
2偶数,continue不进入-
3,5,7,9,11奇数,进入内层都在 j=0 处 break都为假
12i < 12 为假,退出最后 j 仍为 0-循环后输出 12*0
最终只输出 `0`。

易错点

容易忽略 `j` 从 0 开始,导致一开始就触发 `break`。

单选题 · 10

第 10 题(单选题)

#
`for` 与 `while` 等价改写循环顺序

与下面 C++ 输出效果不一致的代码是()。

int i;
for (i = 0; i < 10; i++)
    cout << i;
A.int i = 0; while (i < 10){ cout << i; i += 1; }
B.int i = 0; while (i < 10){ i += 1; cout << i; }
C.int i = 0; while (true){ cout << i; i += 1; if (i >= 10) break; }
D.int i = 0; while (true){ if (i >= 10) break; cout << i; i += 1; }
展开:答案、思考步骤与易错点
正确答案B

知识点讲解

`for` 与 `while` 等价改写;循环顺序

先这样想

先列变量每轮变化,再看输出语句是否真的执行。

分步推导

  1. 原代码输出的是 `0123456789`。
  2. A 先输出再加 1,结果一致;
  3. C 和 D 都是在每次输出后把 `i` 增加到下一个值,也会得到同样的序列。
  4. 只有 B 先执行 `i += 1`,再输出 `i`,所以输出会从 1 开始,到 10 结束,与原效果不一致。

考场手写验证法

检查等价改写时,只比“第一次输出”和“最后一次输出”通常就能抓住顺序错误。

代码第一轮先做什么第一次输出最后一次输出是否等价
原 for先输出,再 i++09基准
A先输出,再 i += 109等价
B先 i += 1,再输出110不等价
C / D输出后再改变 i,或先判断再输出09等价
不一致的是 B。

易错点

容易只看循环条件相同,却忽略“先自增还是先输出”的顺序差异。

单选题 · 11

第 11 题(单选题)

#
`while` 循环`continue` 语句

下面C++代码执行后输出是()。

int num = 0;
while (num <= 5){
    num += 1;
    if (num % 3)
        continue;
    printf("%d#",num);
}
if(num > 5)
    printf("%d",num);
A.3#6#
B.3#6#6
C.1#2#3#4#5#6#
D.1#2#3#4#5#6#6
展开:答案、思考步骤与易错点
正确答案B

知识点讲解

`while` 循环;`continue` 语句

先这样想

先列变量每轮变化,再看输出语句是否真的执行。

分步推导

  1. `num` 从 0 开始,在循环里先自增,所以依次变成 1 到 6。
  2. `num % 3` 不为 0 时直接 `continue`,只有 `num = 3` 和 `num = 6` 时会执行 `printf("%d#", num)`,输出 `3#6#`。
  3. 循环结束后 `num` 已经是 6,满足 `num > 5`,还会再输出一次 `6`,因此结果是 `3#6#6`。

考场手写验证法

`num` 在循环体开头先加 1,再判断是否 `continue`。表格最后必须单独补一行“循环后的 if”。

轮次num 加 1 后num % 3是否 continue累计输出
111
222
3303#
4413#
5523#
6603#6#
循环后 `num=6`,满足 `num > 5`,再输出 `6`,结果是 `3#6#6`。

易错点

容易漏掉循环结束后还有一个单独的 `if` 会再输出一次 `num`。

单选题 · 12

第 12 题(单选题)

#
嵌套循环求和计数

下面 C++ 代码执行后,其输出是()。

int cnt = 0;
for (int i = 0; i < 5; i++)
    for (int j = i; j < 4; j++)
        cnt += 1;
cout << cnt;
A.9
B.10
C.14
D.20
展开:答案、思考步骤与易错点
正确答案B

知识点讲解

嵌套循环;求和计数

先这样想

先列变量每轮变化,再看输出语句是否真的执行。

分步推导

  1. 当 `i = 0,1,2,3,4` 时,内层循环 `j = i` 到 `3`,执行次数分别是 `4,3,2,1,0`。
  2. 所以 `cnt` 最终为 `4 + 3 + 2 + 1 + 0 = 10`,程序输出 10,对应 B。

考场手写验证法

这类题不要猜总次数,直接列每个外层 `i` 对应的 `j` 范围。

外层 ij 从几到几内层次数cnt 累计
00,1,2,344
11,2,337
22,329
33110
4无,4 < 4 为假010
最终输出 `10`。

易错点

容易把内层上界 `j < 4` 看成固定执行 4 次。

单选题 · 13

第 13 题(单选题)

#
循环中变量更新保存原始数据

漂亮数的定义是:如果N能被M整除,或者某位是M,或者N的每位数之和能被M整除,则说N是M的漂亮数。如果三个条件都满足,则是完整漂亮数。123是3的完整漂亮数,因为123能被3整除,也含有3,其每位数之和为6也能被3整除。下面的代码用于判断N是否为M的完整漂亮数并输出。相关说法正确的是( )。

int N, M, Flag, Sum, num;
cout << "请输入N,不等于0的正整数:";
cin >> N;
cout << "请输入M:M必须大于1小于9:";
cin >> M;
Sum = 0; // 记录各位数之和
Flag = 0; // 假设记录N不含有M

while (N != 0){
    num = N % 10;
    Sum += num;
    if (num == M)
        Flag = 1;
    N /= 10;
}
if ((N % M == 0) && (Flag == 1) && (Sum % M == 0)) // L1
    printf("%d 是 %d 的完整漂亮数", N, M);
else
    printf("%d 不是 %d 的完整漂亮数", N, M);
A.代码能完成题目设定目标。
B.在 while 循环中 N 最终将变成 0,因此 L1 行代码中 N % M 将总是满足条件,可以在 while 前增加一行代码 int old_num = N;并将 L1 开始这 4 行代码中的 N 都改为 old_num 就可以做出正确的判定。
C.while 循环中 if 判断语句可以增加 else 子句,其内容为 Flag = 0。
D.如果先后输入 0 和 3,则肯定会输出 0 是 3 的完整漂亮数。
展开:答案、思考步骤与易错点
正确答案B

知识点讲解

循环中变量更新;保存原始数据

先这样想

先列变量每轮变化,再看输出语句是否真的执行。

分步推导

  1. 程序在 `while` 循环里不断执行 `N /= 10`,循环结束后 `N` 一定变成 0。
  2. 这样 L1 里的 `N % M == 0` 就失去了“原数是否能被 M 整除”的意义,因此要先把原始的 `N` 保存下来,再在最终判断和输出时使用保存的值。
  3. B 正是指出了这个关键问题;
  4. C 如果把 `Flag` 重新置 0,会把前面已经找到过数字 M 的事实抹掉。

考场手写验证法

拿 `N=123, M=3` 画拆位表。表一画完就能看到:循环结束后 `N` 已经不是原数,而是 0。

循环前 Nnum = N % 10SumFlagN /= 10 后
12333112
122511
11610
循环结束后 `N=0`,若还要判断原数 123,必须提前保存 `old_num`。

易错点

容易在循环里直接改写原变量,最后却还想拿它表示原始输入值。

单选题 · 14

第 14 题(单选题)

#
嵌套循环字符图形输出

阅读下面的 C++ 代码。执行后如输入 5,其输出的字符图形是()。

int n,i,j,k;
cin >> n;
for (i = 0; i < n; i++) {
    for (j = 0; j < n - i - 1; j++)
        cout << " ";
    for (k = 0; k < 2 * i + 1; k++)
        cout << "*";
    cout << endl;
}
A.***** **** *** ** *
B.* *** ***** ******* *********
C.* ** *** **** *****
D.* ** *** **** *****
展开:答案、思考步骤与易错点
正确答案B

知识点讲解

嵌套循环;字符图形输出

先这样想

先列变量每轮变化,再看输出语句是否真的执行。

分步推导

  1. 外层循环执行 5 次,`i` 从 0 到 4。
  2. 每一行第二个循环都会输出 `2 * i + 1` 个 `*`,所以 5 行分别输出 `1,3,5,7,9` 个星号。
  3. 对应的图形是逐行按奇数递增的三角形,因此选 B。

考场手写验证法

字符图形题按“每行空格数 + 星号数”验证,不要凭感觉看形状。

行号 i空格数 n-i-1星号数 2*i+1本行形态
041 *
133 ***
225 *****
317 *******
409*********
所以是居中的奇数星号三角形,选 B。

易错点

容易忽略 `2 * i + 1` 这一项,误以为每行只比上一行多 1 个星号。

单选题 · 15

第 15 题(单选题)

#
最大值最小值更新复合赋值

某学校举办“十佳歌手大奖赛”,经过选拔最终参赛选手有25人,评委10人,最终计分规则去掉一个最高分去掉一个最低分作为该参赛选手的最终得分,并输出该得分。如果单个评委可给满分为10分,则相关说法正确的是()。

float total_score, max_score, min_score, now_score;
for (int i = 0; i < 25; i++) {
    max_score = 0; // 记录最高分
    min_score = 10; // 记录最低分
    total_score = 0; // 记录总分
    for (int j = 0; j < 10; j++) {
        cin >> now_score; // 录入评委打分
        max_score = max(max_score, now_score); // L1
        min_score = min(min_score, now_score); // L2
        total_score += now_score;
    }
    cout << (total_score - max_score - min_score);
}
A.程序总体逻辑错误。因为要去掉最高分和最低分,需要排序,而程序没有相关代码。
B.内层循环和外层循环之间的三行代码也就是 max_score = 0 开始的三行代码应该移动到外层循环外。
C.L1和L2标记的两行代码可以分别改为简单的 if 语句或?:语句。
D.total_score += now_score 不可以更改为 total_score = total_score + now_score。
展开:答案、思考步骤与易错点
正确答案C

知识点讲解

最大值最小值更新;复合赋值

先这样想

先圈关键词,再排除与题意不匹配的选项。

分步推导

  1. 程序不需要排序,只要在读入 10 个分数的过程中同步维护最大值、最小值和总分,最后再减去一个最高分和一个最低分即可,所以 A 错。
  2. 每位选手都要重新统计自己的最高分、最低分和总分,因此这三行初始化必须放在外层循环内部,B 错。
  3. `max` 和 `min` 的功能完全可以用 `if` 语句或三目运算符改写,所以 C 正确;
  4. `a += b` 与 `a = a + b` 等价,D 错。

考场手写验证法

只手推一个选手的前几次输入就能判断逻辑。下面以连续读到 `8,9,6` 为例。

读入 now_scoretotal_scoremax_scoremin_score说明
初始化0010每位选手都重新开始
8888同时更新三项
91798最高分变 9
62396最低分变 6
边读边维护最大/最小即可,不需要排序;初始化必须放在每位选手内部。

易错点

容易以为“去掉最高分和最低分”一定先排序,其实单次扫描就能完成。

三、判断题逐题讲评

判断题 · 1

第 1 题(判断题)

#
操作系统编译程序

鸿蒙是华为公司开发的一款操作系统,那么它能够将正确的源程序翻译成目标程序,并运行。()

判断本题结论:先独立判断,再展开答案。正确答案是 错误
展开:答案、思考步骤与易错点
正确答案错误

知识点讲解

操作系统;编译程序

先这样想

把题干拆成两半:事实是否正确,结论是否被事实支持。

分步推导

  1. 鸿蒙是操作系统,负责管理硬件资源并为程序提供运行环境;
  2. 把源程序翻译成目标程序的是编译器等翻译程序,不是操作系统本身。
  3. 所以题干把两个概念混在了一起,结论错误。

解题检查法

把“翻译源程序”和“运行程序”分开。编译器负责把源代码翻译成目标程序;操作系统提供运行环境和资源管理。题干把这两个角色合并,就应判错。

易错点

容易把“程序运行在操作系统上”误当成“操作系统负责把源代码翻译成可执行程序”。

判断题 · 2

第 2 题(判断题)

#
逻辑运算布尔值转换

C++表达式 5 < 10 && 20 对应的逻辑值为 true。()

判断本题结论:先独立判断,再展开答案。正确答案是 正确
展开:答案、思考步骤与易错点
正确答案正确

知识点讲解

逻辑运算;布尔值转换

先这样想

把题干拆成两半:事实是否正确,结论是否被事实支持。

分步推导

  1. 先算 `5 < 10`,结果为 `true`。
  2. 在逻辑与运算里,非 0 整数都会被当成 `true`,所以 `20` 也是真。
  3. 于是表达式等价于 `true && true`,最终结果就是 `true`,题干说法正确。

考场手写验证法

逻辑表达式要先算关系运算,再把数字转换成真假。

步骤表达式结果理由
15 < 10true关系判断成立
220true非 0 整数当作真
3true && truetrue两边都真
题干说法正确。

易错点

容易误以为 `&&` 两边必须都写成显式的布尔表达式。

判断题 · 3

第 3 题(判断题)

#
整数除法表达式求值

C++表达式 10 / 0.333333 == 10 / (1 / 3) 的值为 true。()

判断本题结论:先独立判断,再展开答案。正确答案是 错误
展开:答案、思考步骤与易错点
正确答案错误

知识点讲解

整数除法;表达式求值

先这样想

把题干拆成两半:事实是否正确,结论是否被事实支持。

分步推导

  1. 左边 `10 / 0.333333` 是浮点除法,结果约为 30。
  2. 右边先算括号里的 `1 / 3`,这里是整数除法,结果为 0,接下来就变成 `10 / 0`,该表达式没有合法的真值结果,更不可能稳妥地等于左边。
  3. 所以题干说它的值为 `true` 是错误的。

考场手写验证法

等号两边分开算。看到括号里有整数除法,要先处理括号。

一边先算什么得到什么结论
左边10 / 0.333333约 30浮点除法
右边括号1 / 30整数除法
右边整体10 / (1 / 3)10 / 0不是正常可比较结果
不能判为 true,题干错误。

易错点

容易忽略 `1 / 3` 在整数环境下先算出 0。

判断题 · 4

第 4 题(判断题)

#
整数除法`while` 循环

下面C++代码中N是整数,执行时无论输入负整数、0或正整数,其输出都将是 0。()

cin >> N;
while (N)
    N /= 10;
cout << N;
判断本题结论:先独立判断,再展开答案。正确答案是 正确
展开:答案、思考步骤与易错点
正确答案正确

知识点讲解

整数除法;`while` 循环

先这样想

先列变量每轮变化,再看输出语句是否真的执行。

分步推导

  1. 如果输入是 0,`while (N)` 一开始就不进入循环,直接输出 0。
  2. 若输入是正整数或负整数,每次执行 `N /= 10` 都会把绝对值缩小,C++ 的整数除法会向 0 截断,因此经过有限次循环后 `N` 一定变成 0,最后输出仍然是 0,所以题干正确。

考场手写验证法

用三个代表值覆盖 0、正数、负数。C++ 整数除以 10 会向 0 截断。

输入 N循环变化是否停在 0最终输出
0一开始 `while(N)` 为假0
123123 -> 12 -> 1 -> 00
-123-123 -> -12 -> -1 -> 00
无论负整数、0、正整数,最后都输出 0。

易错点

容易只验证正整数,忽略负整数整除 10 也会逐步逼近 0。

判断题 · 5

第 5 题(判断题)

#
关系表达式布尔值的整数表示

下面的C++代码执行后,其输出是 4 0。()

int a, b;
a = 4;
b = a == 5;
cout << a << ' ' << b;
判断本题结论:先独立判断,再展开答案。正确答案是 正确
展开:答案、思考步骤与易错点
正确答案正确

知识点讲解

关系表达式;布尔值的整数表示

先这样想

把题干拆成两半:事实是否正确,结论是否被事实支持。

分步推导

  1. 先执行 `a = 4`。
  2. 表达式 `a == 5` 的结果是 `false`,赋给整型变量 `b` 后会变成 0,所以最后输出的是 `a` 的值 4 和 `b` 的值 0,也就是 `4 0`。
  3. 题干判断正确。

考场手写验证法

赋值语句逐句画变量表,尤其注意 `b = a == 5` 是先算右边的比较。

语句ab说明
int a, b;未定未定只声明
a = 4;4未定给 a 赋值
b = a == 5;40`a == 5` 为假,整型中为 0
cout40中间输出一个空格
完整输出是 `4 0`。

易错点

容易把 `b = a == 5` 看成先给 `b` 赋 5,再和 `a` 比较。

判断题 · 6

第 6 题(判断题)

#
字符编码关系运算

C++代码中对表达式('Z' - 'A')<('z' - 'A')的结果输出为 0。()

判断本题结论:先独立判断,再展开答案。正确答案是 错误
展开:答案、思考步骤与易错点
正确答案错误

知识点讲解

字符编码;关系运算

先这样想

把字符先换成编码或相对差值,再比较大小。

分步推导

  1. `'Z' - 'A' = 25`,而 `'z' - 'A' = 122 - 65 = 57`。
  2. 因此比较式 `25 < 57` 的结果为真。
  3. 如果把这个布尔结果直接输出,通常会得到 1,而不是 0,所以题干错误。

考场手写验证法

先写常用 ASCII,再算两边差值。不要把大小写字母当成同一段。

项目数值计算结果
'A'65--
'Z'90'Z' - 'A' = 90 - 6525
'z'122'z' - 'A' = 122 - 6557
比较-25 < 57true
真值输出通常是 1,不是 0,所以题干错误。

易错点

容易只看两个字母都是 z/Z,就忽略了大小写字符编码不同。

判断题 · 7

第 7 题(判断题)

#
位数判断循环与乘法扩展

下面的C++代码可以用于判断正整数N的位数(即几位数,如123是3位数,12为2位数)。()

int N, N10, i;
cin >> N;
N10 = 10, i = 1;
while (1) {
    if (N % N10 == N) {
        printf("%d 是 %d 位数", N, i);
        break;
    }
    i++, N10 *= 10;
}
判断本题结论:先独立判断,再展开答案。正确答案是 正确
展开:答案、思考步骤与易错点
正确答案正确

知识点讲解

位数判断;循环与乘法扩展

先这样想

先列变量每轮变化,再看输出语句是否真的执行。

分步推导

  1. `N10` 依次取 10、100、1000……,`i` 同步记录当前判断的是几位数。
  2. 当第一次满足 `N % N10 == N` 时,说明 `N < N10`,也就是 N 的位数正好是当前的 `i`。
  3. 例如 `N = 123` 时,先后比较 123 与 10、100、1000,直到 `123 < 1000`,输出 3 位数,因此题干正确。

考场手写验证法

拿 `N=123` 画表。`N10` 每次乘 10,就是在检查“一位、两位、三位”的范围。

轮次N10iN % N10是否等于 N
11013
2100223
310003123是,break
第一次相等时输出 `123 是 3 位数`,题干正确。

易错点

容易看懂判断条件,却忽略 `N10` 必须每轮乘 10 才能扩大位数范围。

判断题 · 8

第 8 题(判断题)

#
符号翻转赋值语句

计算交叉加减的结果,形如 1-2+3-4+5-…… 。下面C++代码中的变量都是整型,则将 Flag = -Flag 改为 Flag -= Flag 效果相同。()

cin >> N;
Flag = -1;
tnt = 0;
for (i = 1; i < N + 1; i++) {
    Flag = -Flag;
    tnt += Flag * i;
}
cout << tnt;
判断本题结论:先独立判断,再展开答案。正确答案是 错误
展开:答案、思考步骤与易错点
正确答案错误

知识点讲解

符号翻转;赋值语句

先这样想

把题干拆成两半:事实是否正确,结论是否被事实支持。

分步推导

  1. `Flag = -Flag` 的作用是把 1 和 -1 来回切换,这样才能实现“加一项、减一项、再加一项”的交替。
  2. 若改成 `Flag -= Flag`,第一次执行后 `Flag` 就变成 0,之后每次仍然是 0,`tnt += Flag * i` 就再也不会正常累加,所以两者效果完全不同,题干错误。

考场手写验证法

并排比较两种写法的前两轮。只要第 1 轮不同,就能判断“效果不相同”。

轮次原写法 Flag = -Flag原写法加上的项改成 Flag -= Flag改写后加上的项
初始-1--1-
i=111 * 100 * 1
i=2-1-1 * 200 * 2
`Flag -= Flag` 会把 Flag 变成 0,不是符号翻转。

易错点

容易把“变号”误当成“减去自己”这种表面上也有减号的写法。

判断题 · 9

第 9 题(判断题)

#
嵌套循环等差求和

下列C++代码段执行后将输出 55。()

int cnt = 0;
for (int i = 0; i < 10; i++)
    for (int j = i; j < 10; j++)
        cnt += 1;
cout << cnt;
判断本题结论:先独立判断,再展开答案。正确答案是 正确
展开:答案、思考步骤与易错点
正确答案正确

知识点讲解

嵌套循环;等差求和

先这样想

先列变量每轮变化,再看输出语句是否真的执行。

分步推导

  1. 当 `i = 0,1,2,...,9` 时,内层循环执行次数分别为 `10,9,8,...,1`。
  2. 所以 `cnt` 最终增加 `10 + 9 + ... + 1 = 55` 次,而 `cout << cnt` 在两个循环结束后执行一次,输出的正是 55,因此题干正确。

考场手写验证法

只算内层次数,再看 `cout` 的位置。`cout` 在两个循环之后,所以最终只输出一次总数。

外层 ij 的范围内层次数cnt 累计
00..91010
11..9919
22..9827
............
99155
合计 `10+9+...+1=55`,题干正确。

易错点

容易被缩进迷惑,以为 `cout` 在外层循环里会输出很多次。

判断题 · 10

第 10 题(判断题)

#
格式化输出换行控制

下面C++代码执行后输出如下,因为代码 printf("\n") 没有任何可读内容,删除不影响输出效果。()

1 | 1  2  3  4  5  6  7  8  9
2 | 2  4  6  8 10 12 14 16 18
3 | 3  6  9 12 15 18 21 24 27
4 | 4  8 12 16 20 24 28 32 36
5 | 5 10 15 20 25 30 35 40 45
6 | 6 12 18 24 30 36 42 48 54
7 | 7 14 21 28 35 42 49 56 63
8 | 8 16 24 32 40 48 56 64 72
9 | 9 18 27 36 45 54 63 72 81
for (int i = 1; i < 10; i++) {
    for(int j = 1; j < 10; j++)
        printf("%3d", i * j);
    printf("\n");
}
判断本题结论:先独立判断,再展开答案。正确答案是 错误
展开:答案、思考步骤与易错点
正确答案错误

知识点讲解

格式化输出;换行控制

先这样想

把题干拆成两半:事实是否正确,结论是否被事实支持。

分步推导

  1. `printf("\n")` 虽然不显示可见字符,但它会输出换行符,把每一行乘法结果分到新的一行。
  2. 若删除这一句,所有数字都会连在同一行里,乘法表的版式就被破坏了,因此“删除不影响输出效果”的说法错误。

考场手写验证法

只手推外层 `i=1` 和下一轮开头,就能看出换行语句有没有作用。

执行位置输出动作保留 printf("\n")删除 printf("\n")
i=1 内层连续输出 1 到 9 的乘积第一行横向排开第一行横向排开
i=1 内层结束printf("\n")换到下一行不换行
i=2 开始继续输出 2 的乘积从第二行开始接在第一行后面
删除换行会破坏乘法表版式,所以题干错误。

易错点

容易把“没有可见字符”误当成“对输出结果没有作用”。