1. 高级语言编写的程序需要经过以下（ ）操作，可以生成在计算机上运行的可执行代码。 ○ A. 编辑 ○ B. 保存 ○ C. 调试 ○ D. 编译

答案是 D. 编译。

来，作为教练，我给你打个最形象的比方，把这个过程想象成**“翻译官的工作”**。

1. 我们的角色

• 高级语言（C++/Python等）：就好比是 “中文”。这是写给你（人类）看的，逻辑清晰，咱们读得懂。
• 计算机（CPU）：它是个只懂 “0和1” 的“外星人”。它根本看不懂你写的 if、for、while。

2. 怎么让外星人听懂你的话？

你需要一个专业的翻译官，把你的“中文文章”翻译成“0101的外星语”。 这个翻译的过程，在计算机术语里就叫做 编译 (Compile)。

3. 为什么其他选项不对？

让我们来看看如果不“翻译”，其他步骤在干什么：

• A. 编辑 (Editing)：这相当于你在写文章。你只是把字打在了屏幕上，此时它还是一篇“中文文章”，外星人还是看不懂。
• B. 保存 (Saving)：这相当于你把写好的文章存进抽屉里。文章的内容没变，还是“中文”。
• C. 调试 (Debugging)：这相当于你在检查错别字。就算你把文章检查得再完美，它依然是“中文”，外星人依然一脸懵逼。

4. 关键时刻

只有当你点击了 “编译” (Compile) 按钮，编译器（Compiler，比如 g++）才会开动马力，把你的源代码转换成计算机能直接执行的机器码（也就是可执行文件，如 .exe）。

最终结论

只有 D. 编译 才是那个神奇的“变身”过程。

2. 二进制数 11.01 在十进制下是（ ）。 ○ A. 3.01 ○ B. 3.05 ○ C. 3.125 ○ D. 3.25

答案是 D. 3.25。

来，作为教练，我带你用**“位权展开法”**把这个数拆解得明明白白。别被中间那个小数点吓住了，它两边的规则其实是一脉相承的。

1. 核心心法：记住每个位置的“身价”

二进制的每一位都有固定的价值（权值），以小数点为界：

• 往左走（变大）：1, 2, 4, 8... （2的倍数）
• 往右走（变小）：1/2 (0.5), 1/4 (0.25), 1/8 (0.125)... （每次除以2）

2. 现场拆解 11.01

我们可以画一张简单的表格，把数字填进去：

3. 算总账

现在我们只需要把有“1”的地方的价值加起来：

• 整数部分：

  • 1 个 2 = 2
  • 1 个 1 = 1
  • 合计：$2 + 1 = 3$

• 小数部分：

  • 0 个 0.5 = 0
  • 1 个 0.25 = 0.25
  • 合计：0.25

4. 最终合并

教练提示（避坑指南）

千万不要看到二进制的 .01 就想当然地以为是十进制的 .01！

• 十进制的 .01 是百分之一。
• 二进制的 .01 是四分之一（即 0.25）。

最终答案

D. 3.25

3. 已知大写字符'A'的 ASCII 编码的十六进制表示为 0x41，则字符'F'的 ASCII 编码的十六进制表示为（ ）。 ○ A. 46 ○ B. 47 ○ C. 48 ○ D. 49

答案是 A. 46。

来，我是教练，我带你用最原始但也最稳妥的方法——**“数手指头”**来解决这道题。

1. 核心知识点

在 ASCII 码表中，字母的排列是连续的。这就像大家排队报数一样，谁也不会插队。

2. 开始推演

已知 'A' 住在 41 号房间（十六进制）。 我们要找 'F' 住在几号。

让我们一个个往后数：

• A -> 41
• B -> 42
• C -> 43
• D -> 44
• E -> 45
• F -> 46

3. 数学计算法

或者你可以算偏移量： 从 A 到 F，中间隔了几个？ $F - A = 5$ （因为 A=1, F=6, $6-1=5$）

所以： $41 + 5 = 46$ （注意这里是个位数加法，没有进位，所以十六进制运算和十进制看起来一样）。

最终结论

A. 46

4. 以下哪个不是 C++语言中的运算符？ （ ） ○ A. & ○ B. && ○ C. * ○ D. **

答案是 D。

来，作为教练，我带你一个个“查户口”，看看这四位谁是混进 C++ 家族的冒牌货。

1. 选手 A：&

• 身份：按位与（Bitwise AND）或者 取地址（Address-of）。
• 场景：
  • 算二进制：3 & 5（按位运算，合法）。
  • 找地址：int *p = &a;（取出变量 a 的地址，合法）。
• 结论：是正规军。

2. 选手 B：&&

• 身份：逻辑与（Logical AND）。
• 场景：
  • 写 if 语句时最常用：if (x > 0 && y > 0)（如果 x 大于 0 并且 y 大于 0）。
• 结论：是正规军。

3. 选手 C：*

• 身份：乘法（Multiplication）或者 解引用（Dereference）。
• 场景：
  • 做数学题：3 * 5（等于 15，合法）。
  • 玩指针：*p = 10;（访问指针指向的内存，合法）。
• 结论：是正规军。

4. 选手 D：** （警报响了！）

• 陷阱：很多学过 Python 或者 Fortran 的同学会眼熟它，在那边它是**“幂运算”**（比如 2 ** 3 表示 2 的 3 次方）。
• C++ 的真相：
  • 在 C++ 里，从来没有定义过 ** 这个单独的运算符！
  • 如果你想算幂，必须老老实实调用数学库函数：pow(2, 3)。
  • 疑惑点：有人会问“我看过 int **p 这种写法啊？” —— 请注意，那其实是两个 * 连在一起写，代表“指针的指针”，而不是一个叫 ** 的独立运算符。

最终结论

D. ** 不是 C++ 的运算符，它是隔壁 Python 家跑错片场的。

5. 如果字符串定义为 char str[] = "Hello";，则字符数组 str 的长度为（ ）。 ○ A. 0 ○ B. 5 ○ C. 6 ○ D. 7

答案是 C. 6。

来，作为教练，我带你用“显微镜”看看这个字符串在内存里到底长什么样。这道题是经典的 “隐形尾巴” 陷阱。

1. 肉眼看到的部分

你第一眼看到 "Hello"，于是你开始数手指头：

• 'H'
• 'e'
• 'l'
• 'l'
• 'o' 一共 5 个字母。 很多人看到这里就想选 B，那就掉进坑里了！

2. 计算机看到的真相

在 C/C++ 语言中，双引号括起来的字符串字面量（String Literal），编译器会自动在屁股后面免费赠送一个结束标志：\0（空字符）。 如果没有这个标志，计算机读字符串的时候就会停不下来，一直读到乱码为止。

所以，数组 str 在内存里的真实布局是这样的：

3. 最终清算

• 看得见的字母：5 个
• 看不见的隐形保镖（\0）：1 个
• 数组总长度 = 5 + 1 = 6

教练的口诀

“双引号里数一数，最后别忘加个 0。”

6. 一个数组定义为 double array[3];，则这个数组占用内存的大小为（ ）。 ○ A. 24 ○ B. 12 ○ C. 6 D. 3

答案是 A. 24。

来，教练带你算一笔“房租账”。计算数组的内存大小，其实就是算总面积。

公式非常简单：

总大小 = 单个房间的大小 × 房间数量

1. 第一步：看房型（数据类型）

这道题定义的类型是 double（双精度浮点数）。 在 C++ 的世界里，不同的房型面积是不一样的：

• char（字符）：1 个字节
• int（整数）：4 个字节
• float（单精度）：4 个字节
• double（双精度）：8 个字节 （记住了，它是“大户型”，存得精度高，所以占地大！）

2. 第二步：数房间（数组长度）

定义里写的是 [3]，说明我们要申请 3 个这样的连续房间。

3. 第三步：算总账

• 每个房间 8 字节。
• 一共 3 个房间。
• $8 \times 3 = 24$ 字节。

举一反三（教练的小测验）

如果题目改成 int array[3]; 选什么？

• int 是 4 字节，所以是 $4 \times 3 = 12$。

如果题目改成 char array[3]; 选什么？

• char 是 1 字节，所以是 $1 \times 3 = 3$。

但这题是 double，所以必须是 24！

7. 以下数组定义，符合 C++语言语法的是（ ）。 ○ A. int a[]; ○ B. int b['3']; ○ C. int c[3.0]; ○ D. int[3] d;

答案是 B。

来，作为教练，我带你像“编译器”一样去审核这四份“内存申请单”，看看谁不合规矩。

1. 审核 A：int a[]; —— 驳回！

• 理由：“空头支票”。
  • 你告诉计算机：“我要申请一块地建数组。”
  • 计算机问：“你要多大？”
  • 你说：“不知道，我不写，我也不放东西进去。”
• 教练注解：数组必须知道大小。要么你直接写数字（如 a[10]），要么你立刻塞数据进去让它自己数（如 a[] = {1,2}）。啥都不干是不行的。

2. 审核 C：int c[3.0]; —— 驳回！

• 理由：“非法切割”。
  • 数组的格子必须是整数个。你见过谁买“3.0 个”或者“3.5 个”座位的吗？
  • 3.0 是小数（浮点数），C++ 的数组下标不支持小数。

3. 审核 D：int[3] d; —— 驳回！

• 理由：“方言错误”。
  • 这是 Java 或 C# 语言的写法。
  • 在 C++ 里，方括号 [] 是长在变量名后面的（像尾巴），而不是长在类型名后面的。
  • 正确写法：int d[3];

4. 审核 B：int b['3']; —— 通过！

• 理由：“字符的伪装”。
  • 这看起来很怪，但请回忆我在前面讲过的：char 类型本质上就是整数！
  • '3' 是一个字符常量。在 ASCII 码表中，字符 '3' 对应的整数值是 51。
  • 所以，这句话在编译器眼里就是：int b[51];。
  • 合情合理合法，申请了 51 个整数的空间。

最终结论

只有 B 符合 C++ 的语法规则。

8. 下列关于进制的叙述，不正确的是（ ）。 ○ A. 正整数的二进制表示中只会出现 0 和 1。 ○ B. 10 不是 2 的整数次幂，所以十进制数无法转换为二进制数。 ○ C. 从二进制转换为 8 进制时，可以很方便地由低到高将每 3 位二进制位转换为对应的一位 8 进制位。 ○ D. 从二进制转换为 16 进制时，可以很方便地由低到高将每 4 位二进制位转换为对应的一位 16 进制位。

答案是 B。

作为教练，我必须指出这个选项简直是在**“睁眼说瞎话”**，它是计算机科学里最大的笑话。

1. 为什么 B 是错的？

• 荒谬的结论：选项说“十进制数无法转换为二进制数”。
  • 如果这是真的，那我们现在所有的计算机都得报废！因为我们在键盘上输入数字（比如 100），计算机底层存储的永远是二进制（1100100）。十进制转二进制是计算机工作的基石。
• 错误的逻辑：能不能转换进制，和“基数是不是幂关系”一毛钱关系都没有。任何进制之间都可以互相转换，只是计算麻不麻烦的问题。

2. 为什么其他选项是对的？（顺便复习一下）

• A 对：二进制（Binary）的定义就是逢二进一，只有两个符号：0 和 1。没毛病。
• C 对：8进制和2进制是亲戚。
  • 因为 $2^3 = 8$，所以 3位二进制 正好对应 1位八进制。
  • 例如：二进制 001 010 -> 八进制 12。这是标准技巧。
• D 对：16进制和2进制更是亲兄弟。
  • 因为 $2^4 = 16$，所以 4位二进制 正好对应 1位十六进制。
  • 例如：二进制 1111 0000 -> 十六进制 F0。这也是标准技巧。

最终结论

B 选项 违背了计算机常识，大错特错。

9. 下列关于 C++语言中数组的叙述，不正确的是（ ）。 ○ A. 数组必须先定义后使用。 ○ B. 数组的所有元素在内存中是连续存放的。 ○ C. 除了字符数组，在定义数组时“[]”内必须有常数。 ○ D. 不能对数组赋值，但可以对数组的每个基础类型的元素赋值。

答案是 C。

作为教练，我要帮你把这些概念厘清，我们用排除法来看看每一项到底在说什么。

1. 选项 A：数组必须先定义后使用

这是对的。 在 C++ 里，任何变量（不管是 int 还是数组）都必须有了“出生证明”（定义）才能干活。你不能还没生下来就让他去打酱油。

2. 选项 B：数组的所有元素在内存中是连续存放的

这是对的。 这是数组的灵魂特性！ 数组就像是一列火车，第 1 节车厢后面紧挨着就是第 2 节。绝不会出现“第 1 节在北京，第 2 节在上海”的情况。正因为连续，计算机才能飞快地通过下标算出的内存地址。

3. 选项 D：不能对数组赋值，但可以对元素赋值

这是对的。

• 整体赋值（×）：int a[5], b[5]; a = b; 这是绝对禁止的！C++ 不支持把一个数组像复印文件一样直接赋值给另一个数组。
• 单个赋值（√）：a[0] = b[0]; 这是完全可以的。我们要像蚂蚁搬家一样一个一个搬。

4. 选项 C：除了字符数组，在定义数组时“[]”内必须有常数

这是错的！（所以选它）

这个选项错在**“除了字符数组”**这句话，它以为只有字符数组有特权，其实大家都有特权！

请看下面的代码：

// 字符数组可以省略长度，让编译器自己数
char s[] = "Hello"; 

// 整数数组也可以省略长度呀！编译器也会自己数
int a[] = {1, 2, 3, 4, 5}; 

你看，int 数组同样可以在 [] 里不写常数（前提是你给了初始值，让编译器能自动推断大小）。 所以，这个规则并不只是字符数组的特权，而是所有数组通用的特性。选项 C 强行搞特殊，显然是不对的。

最终结论

C. 除了字符数组，在定义数组时“[]”内必须有常数。 （这句话说错了）

10. 一个 int 类型的值，做以下哪个操作，一定会变回原来的值？ ( ) ○ A. 左移 3 位，再右移 3 位。 ○ B. 右移 3 位，再左移 3 位。 ○ C. 按位或 7，再按位与 -8。 ○ D. 按位异或 7，再按位异或 7。

答案是 D。

来，教练带你玩一个**“时光倒流”**的游戏。这道题考的是：哪个操作是“可逆”的？ 也就是谁能保证把你原来口袋里的糖果一颗不少地还给你。

1. 为什么选 D？（异或的魔法）

请记住异或（XOR, ^）的一个核心特性：同一个数异或两次，等于没做！

• 比喻：异或就像是按开关。
  • 你对某些位异或 7（二进制 111），就相当于把最后 3 个灯泡的开关按了一下（开变关，关变开）。
  • 再异或一次 7，相当于把刚才那 3 个开关又按了一下。
  • 结果呢？灯泡的状态当然完全恢复原样了！
• 数学公式：(x ^ 7) ^ 7 = x ^ (7 ^ 7) = x ^ 0 = x。

2. 为什么不选 A 和 B？（移位的悬崖）

移位操作（<<, >>）最可怕的地方在于：掉下去的数据回不来！

• 看 B 选项（右移再左移）：

  • 假设你有 7 块钱（二进制 ...000111）。
  • 右移 3 位：这就好比把这 3 个 1 推下了悬崖，变成了 0。
  • 左移 3 位：虽然位置挪回来了，但掉下悬崖的 1 已经没了，只能补 0。结果变成了 0。
  • 亏了！ 原来的 7 变成了 0。

• 看 A 选项（左移再右移）：

  • 同样的道理，如果你是一个很大的负数或者很大的正数，左移的时候，高位的数据会掉进悬崖（溢出）。再右移回来时，原来的头都不见了，肯定变不回原样。

3. 为什么不选 C？（强行篡改）

• 按位或 7 (| 7)：这是霸道操作，它会强行把最后 3 位全部变成 1。不管你原来是啥。
• 按位与 -8 (& -8)：-8 的二进制（补码）最后 3 位是 000。这个操作会强行把最后 3 位全部清零。
• 结局：无论你原来是多少，这一套连招下来，你的最后 3 位都会变成 0。这叫“向下取整”，而不是“还原”。

最终结论

只有 D 选项的异或操作是完美可逆的“后悔药”。

11. 如果 a 和 b 均为 int 类型的变量，下列表达式能正确判断“a 等于 b”的是（ ）。 ○ A. ((a / b) == 1) ○ B. ((a & b) == a) ○ C. ((a ^ b) == 0) ○ D. ((a | b) == b)

答案是 C. ((a ^ b) == 0)。

来，我是教练，我把这道题叫做 “找不同” 游戏。我们要用最犀利的眼光去审视每一个选项，看看谁才是真正的“相等检测器”。

1. 核心武器：异或 (^) 的本质

请记住异或运算的一个外号：“找茬机器”。 它的规则是：

• 如果不一祥（一个 0 一个 1）：报警，输出 1。
• 如果一模一样（都是 0 或都是 1）：安静，输出 0。

既然是判断 a 等于 b，那就是要求它们每一位都一模一样，没有任何区别。 如果每一位都没有区别，那么 a ^ b 的结果自然就是全是 0。 所以，C 选项 是绝对正确的真理。

2. 为什么其他选项是“冒牌货”？

我们用简单的反例（Counter-example）就能把它们打回原形。

• 看选项 A：((a / b) == 1)

  • 陷阱：C++ 里的整数除法会丢掉小数部分（向下取整）。
  • 反例：设 a = 3, b = 2。 3 / 2 的结果是 1。 这时候表达式为真，但 3 显然不等于 2！
  • 还有个坑：万一 b = 0，你的程序直接就崩溃了（除零错误）。

• 看选项 B：((a & b) == a)

  • 含义：这表示 a 的所有是 1 的位，在 b 里也必须是 1（a 是 b 的子集）。
  • 反例：设 a = 1 (二进制 01), b = 3 (二进制 11)。 1 & 3 的结果是 1，等于 a。 但是 1 不等于 3。

• 看选项 D：((a | b) == b)

  • 含义：这表示 b 包含 a 所有的 1。其实跟 B 选项是一回事，只是换了个说法。
  • 反例：同样用 a = 1, b = 3。 1 | 3 的结果是 3，等于 b。 但是 1 不等于 3。

最终结论

只有 C 选项利用了异或的特性，能够精准无误地判断两个数是否完全相等。

选 C。

12. 如果 a 为 int 类型的变量，下列哪个表达式可以正确求出满足“小于等于 a 且是 4 的倍数”的整数中最大的？（ ） ○ A. (a & (~3)) ○ B. ((a << 2) >> 2) ○ C. (a ^ 3) ○ D. ((a - 1) | 3) + 1

答案是 A。

来，教练带你用二进制的“透视眼”看穿这道题。这其实是位运算中最经典的**“抹零”**操作。

1. 什么是“4 的倍数”？

我们把数字转成二进制来看看规律：

• 4 (十进制) -> ...0000 0100 (二进制)
• 8 (十进制) -> ...0000 1000 (二进制)
• 12 (十进制) -> ...0000 1100 (二进制)
• 16 (十进制) -> ...0001 0000 (二进制)

发现规律了吗？只要是 4 的倍数，二进制的最后两位一定是 00。

2. 我们的目标

题目要求“小于等于 a”且“最大的 4 的倍数”。 这句话翻译成“二进制语言”就是： “保留 a 高位的所有数字，强行把 a 的最后两位变成 00”。

举个例子，假设 a = 13 (...0000 1101)： 我们想要得到 12 (...0000 1100)。 也就是要把末尾的 01 变成 00。

3. 如何制造“抹零工具”？

我们需要一个掩码（Mask），它的作用是：高位全是 1（保留），低两位全是 0（清空）。

• 第一步：看数字 3 二进制是：...0000 0011
• 第二步：取反 (~3) 把 3 的每一位都翻转，就得到了我们想要的工具： 二进制是：...1111 1100 （你看，前面全是 1，最后两位是 0）

4. 见证奇迹的时刻 (&)

现在用这个工具和 a 做 按位与 (&) 运算：

      a  :  ... ? ? ? ?   ? ? X Y  (任意数)
&    ~3  :  ... 1 1 1 1   1 1 0 0  (工具)
----------------------------------
   结果  :  ... ? ? ? ?   ? ? 0 0

• 前面对齐 1 的部分：a 原来是啥就是啥，没变。
• 最后对齐 0 的部分：不管 a 原来是 0 还是 1，全都被强制清零了。

这就完美实现了“向下取整到 4 的倍数”。

5. 为什么其他的不对？

• B. ((a << 2) >> 2)：这是把左边的高位挤出去再移回来，不仅没清掉低位，反而可能把高位的数据丢了，或者根本变回原样（如果没有溢出）。想清低位应该是 (a >> 2) << 2。
• C. (a ^ 3)：这是把最后两位取反（翻转），比如 4(100) 会变成 7(111)，显然不对。
• D. ((a - 1) | 3) + 1：这是“向上取整”的算法（求大于等于 a 的最小 4 的倍数），方向搞反了。

最终答案

A. (a & (~3))

13. 在下列代码的横线处填写（ ），可以使得输出是“24 12”。 ○ A. a = a ^ b ○ B. b = a ^ b ○ C. a = a + b ○ D. b = a + b

答案是 B. b = a ^ b。

作为教练，我带你用“消消乐”的思维来破解这道经典的 “异或交换律” 题目。

1. 侦察目标

• 初始状态：a = 12, b = 24
• 最终输出：24 12
• 结论：这代码的目的就是把 a 和 b 的值 交换（Swap）。

2. 核心道具：异或 (^) 的魔法

你要记住异或运算的一个核心性质，我称之为 “归零消消乐”：

A ^ B ^ B = A (任何数，异或同一个数两次，那个数就抵消没了，还原成原来的样子。)

3. 破案推理

题目后面两行代码是写死的： 6. a = a ^ b; 7. b = a ^ b;

我们需要填第 5 行。让我们把 选项 B b = a ^ b 代入进去，看看能不能发生奇迹。

假设一开始 a 是 红球, b 是 蓝球。

• 第 5 行（填入选项 B）：b = a ^ b;

  • 现在的 b 变成了 “红球 ^ 蓝球” （这是一个混合态，我们暂且叫它“混合球”）。
  • 现在的 a 还是 红球。

• 第 6 行：a = a ^ b;

  • 计算：红球 ^ 混合球
  • 展开：红球 ^ (红球 ^ 蓝球)
  • 消消乐时间！ 两个 红球 碰到一起抵消了！
  • 结果：a 变成了 蓝球 （也就是 24）。
  • 恭喜！ a 已经成功换成了 b 的值。

• 第 7 行：b = a ^ b;

  • 计算：a(现在的蓝球) ^ b(混合球)
  • 展开：蓝球 ^ (红球 ^ 蓝球)
  • 消消乐时间！ 两个 蓝球 碰到一起抵消了！
  • 结果：b 变成了 红球 （也就是 12）。
  • 恭喜！ b 也成功换成了 a 的值。

4. 总结

经过这一套连招，a 和 b 完美互换。这就是经典的 “不使用第三个变量进行交换” 的算法。 如果我们选 A (a = a ^ b)，顺序就变了，最后会导致 a 换回来了，但 b 还是混合态，无法完成交换。

最终答案

B. b = a ^ b

14. 在下列代码的横线处填写（ ），可以使得输出是“2”。 (原图未显示但根据描述可推断) ○ A. min > array[i] ○ B. min < array[i] ○ C. min == array[i] ○ D. 以上均不对

答案是 D. 以上均不对。

作为教练，我带你像“人肉调试器”一样，一行一行跑一遍代码，你就会发现其中的陷阱。

1. 关键的初始状态

请盯着第 5 行： int min = 0; 这是本题最大的**“坑”**。min 被初始化为了 0。

而我们的数组 array 里的数是：{3, 7, 5, 2, 4}。 注意：这些数全都是正数，每一个都比 0 大。

2. 模拟选项 A：if (min > array[i])

这是标准的“找最小值”逻辑，但是前提是 min 的初始值要很大（比如无穷大）。 在这里，min 是 0。

• 第 1 轮：0 > 3 吗？ 假。不更新。
• 第 2 轮：0 > 7 吗？ 假。不更新。
• ...
• 结果：不管跑多少轮，0 永远不比正数大，min 纹丝不动。
• 输出：0。 （我们需要的是 2，A 淘汰）

3. 模拟选项 B：if (min < array[i])

这是“找最大值”的逻辑。

• 第 1 轮：0 < 3 吗？ 真。min 变成 3。
• 第 2 轮：3 < 7 吗？ 真。min 变成 7。
• 第 3 轮：7 < 5 吗？ 假。保持 7。
• ...
• 结果：这个逻辑是在找最大值。
• 输出：7。 （我们需要的是 2，B 淘汰）

4. 模拟选项 C：if (min == array[i])

• 只有当 min 和数组里的数相等时才更新。min 是 0，数组里没有 0，永远不会触发。
• 输出：0。 （C 淘汰）

5. 真相只有一个

既然 A、B、C 跑出来的结果都不是 2，那答案只能是 D。

💡 教练的“赛后复盘”

如果想让代码输出 2（也就是找到数组里的最小值），这代码该怎么改？ 要把第 5 行的初始化改掉！

• 方法一：int min = 10000; （设一个很大的数）
• 方法二：int min = array[0]; （让它等于数组第一个人，也就是 3）

只要改了这一行，配合选项 A，就能正确输出 2 了。但这题题目里把 min 锁死在 0 了，所以只能选 D。

15. 在下列代码的横线处填写（ ），可以使得输出不是“31”。 ○ A. res = res + array[i] ○ B. res = res & array[i] ○ C. res = res | array[i] ○ D. res = res ^ array[i]

答案是 B。

来，作为教练，我带你一眼看穿这道题的“障眼法”。这道题其实是在考你对 二进制位 的敏感度。

1. 侦察敌情：看数组里的数

请仔细看这个数组：{1, 2, 4, 8, 16}。 这不仅仅是一堆普通的数字，它们是 2的幂。 换成二进制看，它们长这样：

• 1: 00001
• 2: 00010
• 4: 00100
• 8: 01000
• 16: 10000

发现了吗？它们所有的“1”都错开了，互不干涉，没有一个是重叠的。

2. 模拟战场

我们的目标是算出 31。 31 的二进制是 11111。也就是把上面那 5 个位置的“1”全都填满。

现在 res 初始值是 0 (00000)。我们要把这 5 个数一个个作用在 res 上。

• 看 A 选项 (加法 +)： $0 + 1 + 2 + 4 + 8 + 16 = 31$。 结果是 31。

• 看 C 选项 (按位或 |)： “或”运算就是“只要有一个是 1，结果就是 1”。 因为这些数字的 1 位置都不冲突，所以 | 的效果和加法一模一样，就是把对应的灯泡点亮。 最后结果也是 11111 (即 31)。 结果是 31。

• 看 D 选项 (按位异或 ^)： “异或”是“相同为 0，不同为 1”。 因为 res 从 0 开始，且每个数进来的 1 都是新的位置，从来没发生过碰撞，所以效果也等于“填坑”。 最后结果还是 11111 (即 31)。 结果是 31。

• 看 B 选项 (按位与 &)： “与”运算非常苛刻：“两个都是 1，结果才是 1”。 res 初始值是 0。 第 1 轮：0 & 1。因为 0 身上全是 0，不管对方是谁，与完的结果永远是 0。 这就好比用“0”去乘任何数，结果永远躺平，怎么循环都是 0。 结果是 0。

3. 教练总结

题目问的是**“不是 31”**的那个。 A、C、D 殊途同归，最后都拼成了 31。 只有 B，从头到尾都是 0。

最终答案

B. res = res & array[i]

16. 一个算法可以用不同的形式来描述，但要求描述比较规范，因此不能用自然语言描述。 ○ A. 对 ○ B. 错

答案是 B. 错。

作为教练，我用最生活化的例子带你理解什么是“描述算法”。

1. 什么是“自然语言”？

自然语言就是我们平常说的人话（中文、英文等）。

2. 生活中的算法：菜谱

想象一下，你要教朋友做一道“西红柿炒鸡蛋”。你会怎么写？

• 第一步：把西红柿洗净切块。
• 第二步：鸡蛋打散搅拌。
• 第三步：起锅烧油，倒入蛋液……

请问：这是一个算法吗？是！（它是一系列解决问题的明确步骤）。 请问：你用的是 C++ 吗？不是，你用的就是自然语言。

3. 教科书上的定义

在计算机科学中，描述算法通常有四种常见方式：

1. 自然语言（用人话写，简单易懂，虽然容易产生歧义，但绝对是合法的方式）。
2. 流程图（画框框和箭头）。
3. 伪代码（介于人话和代码之间）。
4. 程序设计语言（真代码，如 C++）。

4. 结论

题目说“不能用自然语言描述”，这显然是大错特错的。虽然自然语言有时候不够严谨（比如“少许盐”是多少？），但它绝对是描述算法的一种重要且合法的形式，尤其是在算法设计的初期阶段。

最终答案

B. 错

17. 域名是由一串用点分隔的名字来标识互联网上一个计算机或计算机组的名称，CCF 编程能力等级认证官方网站的域名是 gesp.ccf.org.cn，其中顶级域名是 gesp。 ○ A. 对 ○ B. 错

答案是 B. 错。

作为教练，我要告诉你一个阅读域名的**“倒读法则”。域名系统的层级结构其实是一棵倒过来的树，或者你可以把它想象成写英文地址**的习惯（从小地名写到大地名）。

1. 怎么找“顶级”？看最右边！

域名是从右向左级别越来越低的。

• 最右边的部分才是地位最高的顶级域名 (Top-Level Domain, TLD)。
• 最左边的部分通常是具体的主机名或子域名，级别最低。

2. 解剖 gesp.ccf.org.cn

让我们像剥洋葱一样，从右往左看：

1. .cn —— 这是顶级域名 (TLD)。代表中国（Country Code TLD）。
2. .org —— 这是二级域名。通常代表非营利性组织。
3. .ccf —— 这是三级域名。代表中国计算机学会。
4. gesp —— 这是四级域名（主机名）。代表这个具体的 GESP 项目网站。

3. 教练的总结

题目里说 gesp 是顶级域名，这就好比说在地址“中国上海市南京路100号”里，“100号”是最大的行政区划一样荒谬。

记住：顶级域名在屁股后面（最右边），比如 .com, .cn, .net, .org 等等。

最终结论

B. 错

18. 数据编码方式只有原码、反码、补码三种。 ○ A. 对 ○ B. 错

答案是 B. 错。

作为教练，我要教你识别题目里的**“绝对词陷阱”。只要看到“只有……三种”**这种话，你的警觉雷达就要响起来了。

这道题错在把路走窄了，而且漏掉了一位重要的“隐形成员”。

1. 漏掉的“第四位火枪手”：移码 (Excess Code)

在计算机组成原理的教材里，讲整数表示时，通常是“F4”组合：

• 原码
• 反码
• 补码
• 移码 (Excess Representation)

移码是干什么用的？它经常出现在浮点数（小数）的表示中。 比如你定义一个 float 或 double 类型，计算机内部存储它的指数部分时，用的就是移码（也就是加上一个偏移量）。所以，光是在数值表示领域，就不止三种。

2. “数据”这个词太大了

题目说的是“数据编码”，并没有限定是“有符号整数”。

• 字符是不是数据？它有 ASCII 码、UTF-8 编码。
• 声音是不是数据？它有 PCM 编码。
• 图像是不是数据？它有 RGB 编码。

3. 教练总结

这道题即使仅限制在“计算机数值存储”的范围内，也至少漏掉了移码。 以后看到“只有……几种”这种绝对的说法，只要能找到任何一个反例，就可以大胆打叉！

最终结论

B. 错

19. 在 C++语言中，长度为 n 的数组，合理的下标范围是从 0 到 n，包括 0 和 n。 ○ A. 对 ○ B. 错

答案是 B. 错。

作为教练，我要给你敲个警钟：这是新手最容易犯的 “越界错误” (Off-by-one Error)，在考场上如果不注意，程序会直接崩溃！

我们来做一个简单的“点名游戏”：

1. 举个栗子

假设我们定义了一个长度为 3 的数组：int a[3]; 这意味着我们有 3 个座位。

2. 开始入座

C++ 的规矩是从 0 开始编号的：

• 第 1 个人坐在 ——> a[0]
• 第 2 个人坐在 ——> a[1]
• 第 3 个人坐在 ——> a[2]

好了，座位坐满了！ (一共 3 个人)

3. 如果你去坐 a[3] (下标 n) 会发生什么？

题目里说下标范围包括 n，也就是包括 3。 如果你试图去访问 a[3]，实际上你是在访问数组后面紧挨着的那个内存位置。

• 那个位置不属于你！
• 里面可能是乱码，可能是其他重要变量，甚至可能导致程序直接报错（Segmentation Fault）。

4. 黄金法则

请把这句话刻在脑子里： 长度为 n 的数组，合法下标永远是 0 到 n-1。

见到了下标 n，就是见到了悬崖，千万别踩！

最终结论

B. 错

20. 字符常量 '\0' 常用来表示字符串结束，它和字符常量 '0' 是不同的。 ○ A. 对 ○ B. 错

答案是 A. 对。

作为教练，我来帮你把这两个长得很像的“双胞胎”分辨清楚，我们看它们的**“身份证”（ASCII 码）**就一目了然了。

1. 选手一：'\0' (空字符)

• 身份证号 (ASCII)：0
• 职业：它是字符串的**“隐形刹车片”**。
  • 在 C/C++ 中，字符串（如 "Hello"）的内存里其实存储的是 H-e-l-l-o-\0。
  • 计算机读取字符串时，只要一撞见 \0，就知道“哦，到这里结束了”，然后停止读取。
• 可见性：它是不可见的，印不出来。

2. 选手二：'0' (字符零)

• 身份证号 (ASCII)：48
• 职业：它是我们在屏幕上实实在在看到的数字符号。
  • 它只是一个普通的字符，和其他字母 'A'、'B' 没有本质区别，只是长得像零而已。
• 可见性：完全可见。

3. 总结

虽然它们看起来都有个圈圈，但在计算机眼里：

• 一个是数值 0（结束标志）。
• 一个是数值 48（显示用的符号）。

完全是两码事！

最终结论

A. 对