GESP C++一级 2026年6月真题精讲

💡 学习建议：先自己做一遍，再对照解析查漏补缺。每道题的解析都用通俗语言写成，确保你能看懂！

学校组织到未来农场参观，小明听讲解员介绍，在智能温室中，湿度传感器可以连续检测土壤的湿度变化，并将检测到的湿度数据实时发送给中央控制器。中央控制器根据这些数据判断是否开启灌溉系统。请问，这里的湿度传感器所发挥的作用，类似于计算机系统中的哪一类组件？（ ）

A. 处理器

B. 存储器

C. 输入设备 ✓

D. 输出设备

解析：湿度传感器负责"检测土壤湿度"并"把数据发送给控制器"——它的工作就是把外面的信息送进系统里，这和计算机的输入设备（如键盘、鼠标）作用完全一样：把外部信息输入给计算机处理。

🌰 小比喻：传感器就像人的"皮肤触觉"，感受到温度变化后告诉大脑——这就是"输入"！

在使用某集成开发环境（比如 Dev-C++）来编辑源代码文件时，程序员经常需要在编辑区中对代码进行各种修改。以下关于在编辑区中执行的操作描述不正确的是（ ）。

A. 可以将变量名 count 统一修改为 number

B. 可以连续撤销最近输入的内容

C. 可以调整代码行的缩进（如按 Tab 键）

D. 在注释文本中间不能混用中英文 ✗（不正确）

解析：本题选"不正确"的描述。逐一分析： A ✓ 正确——IDE（如 Dev-C++）有"查找替换"功能（Ctrl+F / Ctrl+H），可以把代码中所有 count 统一替换为 number。 B ✓ 正确——IDE 都支持 Ctrl+Z 连续撤销，可以多次回退到更早的编辑状态。 C ✓ 正确——按 Tab 键可以增加缩进，Shift+Tab 可以减少缩进，这是编辑器基本功能。 D ✗ 不正确——这就是答案！C++ 编译器在预处理阶段会直接忽略注释内容（// 单行注释和 /* */ 多行注释都是如此），注释里写中文、英文、甚至中英混排，完全不影响编译和运行。例如 // 输出 hello 世界、/* score 成绩 */ 都是合法的。💡 小提示：注释里混用中英文虽然不影响编译，但为了代码可读性，建议保持注释风格统一。

有关如下 C++ 代码的说法，正确的是（ ）。

float a = 3 + 3.5;cout << a;

A. 代码执行将报错。如果将 a=3+3.5 改为 a=3+3+1/2 将能正常执行。

B. 代码执行将报错。如果将 a=3+3.5 改为 a=3.6+3.5 将能正常执行。

C. 代码能正常执行，将输出 6。

D. 代码能正常执行，将输出 6.5 ✓

解析：float a = 3 + 3.5; 中，3 是整数，3.5 是浮点数，整数 3 会自动转换为浮点数 3.0，然后 3.0 + 3.5 = 6.5，存入 float 变量 a，输出 6.5。代码完全可以正常执行！⚠️ 为什么 A 错？ a=3+3+1/2 中，1/2 是整数除法，结果为 0（不是 0.5！），所以 a=6+0=6，虽然能执行但结果不是 6.5。⚠️ 为什么 B 错？ 原代码本身就不会报错，不需要修改。⚠️ 为什么 C 错？ 3.0 + 3.5 = 6.5，不是 6。

下列 C++ 表达式与 -2 * 2 % 4 的值不同的是（ ）。

A. -(2 * 2) % 4

B. (-2 * 2) % 4

C. -2 * (2 % 4) ✓

D. (2 * 2) % -4

解析：先算原式：-2 * 2 % 4，乘法和取模同级，从左到右： = (-2) × 2 = -4，然后 -4 % 4 = 0 逐个验证： A. -(2×2) % 4 = -(4) % 4 = -4 % 4 = 0 ✓ 相同 B. (-2×2) % 4 = (-4) % 4 = 0 ✓ 相同 C. -2 × (2%4) = -2 × 2 = -4 ✗ 不同！ D. (2×2) % (-4) = 4 % (-4) = 0 ✓ 相同💡 关键：C 加了括号改变了运算顺序，2%4=2，然后 -2×2=-4，结果变成了 -4，和其他选项不同！

执行如下 C++ 代码片段，其输出是（ ）。

int a = 3;int b = a;a = 4;printf("%d %d", a, b);

A. 3 3

B. 4 3 ✓

C. 4 4

D. 3 4

解析：一步步跟踪： ① a = 3 → a 的值是 3 ② b = a → b 被赋值为 a 当前的值，即 b = 3（这是复制，不是"绑定"！） ③ a = 4 → a 变成了 4，但 b 不受影响，b 仍然是 3 ④ 输出 a 和 b → 4 3🌰 小比喻：b = a 就像"拍照"，b 拍下了 a 当时的样子（3），后来 a 变了（变成4），照片（b）不会跟着变！

如下 C++ 代码执行时输入 2026-6-27，下列说法正确的是（ ）。

int N;cin >> N;cout << N;

A. 输入失败，不允许输入减号，没有输出

B. 允许输入，输出 1993

C. 允许输入并原样输出 2026-6-27

D. 允许输入并输出 2026 ✓

解析：cin >> N 中 N 是 int 类型。当你输入 2026-6-27 时，cin 会从左到右读取数字字符： ① 读到 2, 0, 2, 6 → 组成数字 2026 ② 遇到 -（减号）→ 不是数字，停止读取 ③ 输出 N → 2026 后面的 -6-27 还留在输入缓冲区里，但没有被读取。所以输出是 2026。💡 知识点：cin 读整数时，遇到非数字字符就会"停下来"，只读取它能识别的部分。

如下 C++ 代码执行时，其说法错误的是（ ）。

int N, M;cin >> N >> M;if (N > M)    cout << "A " << (N - M);else    cout << "B " << (M - N);

A. 如果输入 4 3，将输出 A 1

B. 如果输入 3 4，将输出 B 1

C. 如果输入 3 3，将输出 A 0 ✗（错误）

D. 如果输入 4 4，将输出 B 0

解析：逐个验证： A. N=4 > M=3 ✓ → 输出 "A " 和 4-3=1 → "A 1" ✓ B. N=3 > M=4 ✗ → else → 输出 "B " 和 4-3=1 → "B 1" ✓ C. N=3 > M=3 ✗（3 不大于 3！）→ else → 输出 "B " 和 3-3=0 → "B 0"，而不是 "A 0" ✗ D. N=4 > M=4 ✗ → else → 输出 "B " 和 4-4=0 → "B 0" ✓⚠️ 易错点：N > M 是严格大于，当 N=M 时条件为假，走 else 分支！

阅读如下 C++ 代码，下列说法错误的是（ ）。

int cnt = 0;for (int i = 0; i < 5; i++)    cnt += 1;cout << cnt;

A. 将 cnt += 1 修改为 cnt = cnt + 1，执行效果相同

B. 将 cnt += 1 修改为 cnt = 1 + cnt，执行效果相同

C. 将 cnt += 1 修改为 cnt =+ 1，执行效果相同 ✗（错误）

D. 将 cnt += 1 修改为 cnt = +1 + cnt，执行效果相同

解析：原代码循环5次，每次 cnt 加 1，最终 cnt = 5。逐个分析修改： A. cnt = cnt + 1 → 等价于 cnt += 1 ✓ B. cnt = 1 + cnt → 加法交换律，结果一样 ✓ C. cnt =+ 1 → 这实际上是 cnt = (+1)，即每次循环都把 cnt 赋值为 1！最终 cnt = 1，不是 5 ✗ D. cnt = +1 + cnt → 等价于 cnt = 1 + cnt ✓⚠️ 易错点：=+ 和 += 完全不同！cnt =+ 1 是赋值（cnt 永远变成 1），cnt += 1 是累加！

如下 C++ 代码执行后输出是 1 2 3 4 5 6 7 8 9 10 11 5 6 7 8 9 10 11 5 6 7 8 9 10 11 5 6 7 8 9 10 11 5 6 7（共35个数）。横线处应该先后依次填入的运算符是（ ）。

int num = 1;for (int i = 0; i < 35; i++) {    printf("%d ", num);    if (num _______ 10)        _______    else        num _______ 1;}

A. >, /=, += ✓

B. >=, %=, +=

C. >, %=, +=

D. >, /=, =+

解析：观察输出规律：1~11 之后重复出现 5~11 的循环。还原代码逻辑：if (num > 10)  num /= 10;  // 超过10就除以10（11→1）else  num += 1;  // 否则加1 验证过程： • num=1~9：不大于10，每次 +1 • num=10：不大于10，+1 → 11 • num=11：大于10，11/10=1（整数除法！）→ 回到 1 • 然后 1→2→3→4→5→6→7→8→9→10→11→1→... 形成 1~11 的循环！而输出中第一组是1~11（11个数），后面每次从5开始（因为总循环35次，前11个用完后剩余24个按 5~11 的节奏输出）。💡 关键技巧：/= 是整除赋值，11/10=1（不是1.1！），这就是让数字"回绕"的妙用。

如下 C++ 代码可以执行，其输出是（ ）。

int i;for (i = 1; i < 5; i++)    if (i % 2 == 0) {        continue;    }    cout << i << "#";cout << i << "END#";

A. 5END# ✓

B. 5#END

C. 1#3#4#END

D. 1#3#4 END#

解析：关键陷阱：cout << i << "#" 在 if 的花括号内部，而 continue 在它的前面！所以当 i 为偶数时，执行到 continue 就直接跳过本次循环剩余部分，cout 永远不会执行。 逐次跟踪 i=1,2,3,4： • i=1：1%2=1≠0 → if 条件为假 → 花括号内代码全部跳过 • i=2：2%2=0 → if 条件为真 → 执行 continue → 跳过 cout → 进入下一轮 • i=3：3%2=1≠0 → if 条件为假 → 跳过 • i=4：4%2=0 → if 条件为真 → continue → 跳过 cout 循环结束后 i=5（4+1=5，5<5 为假退出循环）。 最后执行循环外的 cout << i << "END#" → 输出 5END#💡 重点：continue 会跳过本次循环剩余的所有代码。这里的 cout 在 continue 后面，所以永远不会执行！循环结束后 i 的值是 5（不是4！），因为 for 循环的 i++ 在每轮结束后还会执行一次。

如下 C++ 代码执行时，下列说法正确的是（ ）。

int N, i;cin >> N;for (i = 2; i < N; i++)    if (N % i == 0) {        cout << "1#";        break;    } else        cout << "0#";

A. 如果输入 2，将输出 1#

B. 如果输入 15，将输出 0#1# ✓

C. 如果输入 1，将输出 0#

D. 如果输入 3，将输出 1#

解析：逐个分析：A. N=2：循环条件 i<2，i 从 2 开始，2<2 为假，循环不执行，没有任何输出 ✗B. N=15：i=2 时 15%2≠0 → else → 输出 "0#"；i=3 时 15%3==0 → if → 输出 "1#" → break 结束循环。最终输出 "0#1#" ✓C. N=1：循环条件 i<1，2<1 为假，不执行，没有输出，不是 "0#" ✗D. N=3：i=2 时 3%2≠0 → else → 输出 "0#"；i=3 时 3<3 为假，循环结束。输出 "0#"，不是 "1#" ✗💡 关键：这段代码的逻辑是从 2 开始逐个试除，如果找到因子就输出 "1#" 并 break，否则每试一个数就输出 "0#"。注意 else 分支每次没有找到因子时都会输出 "0#"！

有关如下 C++ 代码，下列说法中错误的是（ ）。

int i, tot;i = 0, tot = 0;while (0 <= i && i < 10) {    i += 1;    tot += 1;    cout << tot;}

A. 如果调整 0<=i && i<10 为 1<=i && i<10，输出同样为 45，因为加上 0 不影响结果 ✗（错误）

B. 如果将 i=0 和 tot=0 合并为 i=tot=0，执行结果与修改前相同

C. 将 tot+=1 与 i+=1 交换顺序，执行结果与修改前相同

D. 将 i=0 与 tot=0 交换顺序，执行结果与修改前相同

解析：原代码中 i 和 tot 初始值都是 0，每次循环都先 i+=1 再 tot+=1，它们始终相等。循环执行 10 次（i 从 0 到 9），输出 12345678910（1到10拼接在一起）。 题目要求找出错误的说法：A ✗ 错误说法（即答案）：改为 1<=i && i<10 后，初始 i=0 不满足条件 1<=0（为 false），循环一次都不执行！根本没有输出，更不存在"输出同样为 45"。这个说法完全错误。 B ✓ i=tot=0 是 C++ 合法的连续赋值，效果等同于分别赋 0，执行结果不变。 C ✓ 交换后先 tot+=1 再 i+=1，由于两者初始都是 0 且每次循环都加 1，始终相等，输出结果不变。 D ✓ 初始化顺序交换不影响结果，最终 i 和 tot 都是 0。💡 关键：循环条件中 0<=i 看起来多余（i 从 0 开始只会越来越大），但改成 1<=i 就直接让循环在第一次判断时就失败了！审题时一定要仔细对比每个条件的细微差别。

以下 C++ 代码可以找出千位、百位、十位和个位满足特定条件的四位数（例如"四叶玫瑰数"），横线处应该填入的是（ ）。

int count = 0;for (int n = 1000; n <= 9999; n++) {    int a = n / 1000;       // 千位    int b = (n / 100) % 10;  // 百位    _________________________  // L1：求十位    int d = n % 10;          // 个位    if (a*a*a*a + b*b*b*b + c*c*c*c + d*d*d*d == n)        count++;}

A. int c = (n / 10) / 10;

B. int c = (n / 10) % 10; ✓

C. int c = (n % 10) / 10;

D. int c = (n % 10) % 10;

解析：提取各位数字的通用方法： • 千位 = n / 1000 • 百位 = (n / 100) % 10 • 十位 = (n / 10) % 10 ← 规律：先除以 10 去掉个位，再 % 10 取最后一位 • 个位 = n % 10 以 n=1234 为例： B. (1234 / 10) % 10 = 123 % 10 = 3 ✓ 十位确实是 3 A. (1234 / 10) / 10 = 123 / 10 = 12 ✗ 这不是十位数字！ C. (1234 % 10) / 10 = 4 / 10 = 0 ✗ D. (1234 % 10) % 10 = 4 % 10 = 4 ✗💡 记忆口诀："先除后取"——除去掉高位，% 10 取末位！

下面的 C++ 代码用于计算经过 n 秒后的秒针位置，两处横线处分别应填入的代码是（ ）。

int start, n, pos;cout << "当前秒数(0-59): ";cin >> start;cout << "经过多少秒: ";cin >> n;pos = ____________;  // L1if (____________)    // L2    cout << n << "秒后回到12点方向" << endl;else    cout << n << "秒后指向" << pos << "秒刻度" << endl;

A. (start + n) / 60 和 pos == 0

B. (start + n) % 60 和 pos == 0 ✓

C. (start + n) / 60 和 pos <= 0

D. (start + n) % 60 和 pos = 0

解析：时钟是60秒一圈的"循环"！L1：当前在 start 秒位置，经过 n 秒后，新位置 = (start + n) % 60（取余运算实现"回绕"）。比如从第 50 秒经过 15 秒 → (50+15)%60 = 65%60 = 5 → 指向第 5 秒刻度。不能用 / 60（那是算"走了几圈"）。L2：什么时候"回到12点方向"？当 pos == 0 时（指向 0 秒刻度 = 12点方向）。注意 pos = 0 是赋值，pos == 0 才是比较！💡 生活经验：就像钟表一样，55秒再过10秒不是65秒，而是回到第 5 秒！这就是 % 60 的妙用。

如果正整数 N 只能被 1 和它本身整除，则它是一个质数（素数）。下面的 C++ 代码用于判断正整数 N 是否为质数。若 N 是质数，输出 YES，否则输出 NO。横线处不应填入的代码是（ ）。

int N, i;cin >> N;if (N <= 1) {    cout << "NO";    return 0;}for (i = 2; ______; i++) {    if (N % i == 0) {        cout << "NO";        return 0;    }}cout << "YES";

A. i < N

B. i <= N ✗（不应填入）

C. i <= N / 2

D. i * i <= N

解析：质数判断的核心：从 2 开始试除，如果有因子就不是质数。循环条件的关键是不能包含 N 本身！ A. i < N：检查 2 到 N-1，正确 ✓ B. i <= N：会检查到 N！而 N%N 永远等于 0，所以任何数都会被判定为"有因子"，全部输出 NO！质数也会被误判 ✗ C. i <= N/2：因子最大不超过 N/2，正确且更高效 ✓ D. i*i <= N：数学优化，因子最大不超过 √N，正确且最快 ✓⚠️ 易错点：i <= N 会让循环检查到 N 本身，而任何数都能被自己整除（N%N=0），所以所有数都会被判为"不是质数"——这是严重的逻辑错误！

又到期末考试周，小明发现这次许多闭卷考试不仅禁止携带手机、平板电脑，还有最近比较时髦的各类 AI 眼镜（也有叫智能眼镜）也同样不允许带入考场。这些 AI 眼镜应该也是内置了操作系统并可能支持 Wi-Fi 或蓝牙连接。

解析：AI 眼镜（如 Meta Ray-Ban 等）确实是小型智能设备，内置操作系统（如 Android 定制系统），支持 Wi-Fi 和蓝牙连接，可以拍照、录音、联网、甚至使用 AI 功能。在闭卷考试中，这些功能都可能被用来作弊，所以禁止带入是合理的。💡 知识点：凡是能存储信息、联网通信的智能设备，都不能带入闭卷考场！

如果 n 为大于 9 的整数，则 C++ 表达式 (n / 10) % 10 与 (n % 100) / 10 的结果相同。

解析：两个表达式都是在提取 n 的十位数字！ 以 n=1234 为例： • (1234 / 10) % 10 = 123 % 10 = 3 • (1234 % 100) / 10 = 34 / 10 = 3 以 n=5678 为例： • (5678 / 10) % 10 = 567 % 10 = 7 • (5678 % 100) / 10 = 78 / 10 = 7 两种方法的思路不同但结果相同： 方法一：先去掉个位（/10），再取最后一位（%10） 方法二：先取后两位（%100），再去掉个位（/10）💡 技巧：提取数字某一位，核心就是"先除后取"或"先取后除"！

下面 C++ 代码执行后将输出 19。

int i;for (i = 0; i < 20; i += 3)    cout << i;if (i % 3 != 0) break;

解析：循环中 i 从 0 开始，每次加 3： i = 0, 3, 6, 9, 12, 15, 18（都小于 20） 输出：0369121518（这些数字拼接在一起） 当 i=18 时输出后，i+=3 变为 21，21<20 为假，循环结束。 然后 if (i % 3 != 0)：21 % 3 = 0，条件为假，break 不执行。 实际输出是 0369121518，不是 19！⚠️ 注意：cout << i 输出的是一串连续的数字字符，不是数学上的"加和"！

在数学中，N! 称之为 N 的阶乘，其含义是 1 到 N 之积，包括 N。如 3! = 1×2×3 = 6。如下 C++ 代码能输出 N! 的结果。

int N;cin >> N;int rst = 0;for (int i = 1; i < N + 1; i++)    rst *= i;cout << rst;

解析：代码有一个致命错误：rst = 0！ 阶乘需要累乘，初始值必须是 1，而不是 0。因为任何数乘以 0 都等于 0！ • rst 初始为 0 • 第 1 轮：rst = 0 × 1 = 0 • 第 2 轮：rst = 0 × 2 = 0 • ... • 最终输出永远是 0正确写法：int rst = 1;（累乘初始值必须是 1！）🌰 小比喻：就像算"3×4×5"，如果你一开始拿的是 0 个苹果，无论乘多少倍都还是 0！

如下 C++ 代码能实现输出正整数 N 的各位数字。

int N;cin >> N;while (N > 0) {    cout << (N % 10) << endl;    N = N / 10;}

解析：这是经典的"逐位提取"算法！以 N=123 为例： 第 1 轮：123 % 10 = 3（个位），N = 123/10 = 12 第 2 轮：12 % 10 = 2（十位），N = 12/10 = 1 第 3 轮：1 % 10 = 1（百位），N = 1/10 = 0 循环结束。 输出：3, 2, 1（从低位到高位，即逆序输出各位数字）。💡 方法总结：% 10 取最后一位，/ 10 去掉最后一位，循环执行就能逐位提取！

将如下 C++ 代码中的 printf("\n") 更换为 printf("%c", '\n')，输出效果相同。

for (int i = 0; i < 100; i++) {    if (i % 5 == 0)        printf("\n");    printf("%2d ", i);}

解析：两种写法的本质都是输出一个换行符： • printf("\n")：直接输出字符串中的换行符 • printf("%c", '\n')：用 %c 格式输出字符 '\n'（即换行符，ASCII 码 10） 两者输出的内容完全一样——都是一个换行符。区别只是"方式不同"，但"效果相同"。💡 知识点：\n 是转义字符，代表换行。无论是直接输出还是通过 %c 输出，结果都是换行。

C++ 代码 cout << (2.5 % 2) 能够生成可执行代码，但执行时将报错，因为 % 只能适用于正整数。

解析：这句话说"能够生成可执行代码"——这本身就是错误的！ 在 C++ 中，%（取模运算符）只能用于整数类型。2.5 是 double（浮点数），2.5 % 2 会在编译阶段就报错，根本无法生成可执行代码！ 题目说"能生成可执行代码，但执行时报错"——实际上连编译都通不过，何来"执行时"报错？💡 正确做法：如果要对浮点数取余，需要用 fmod() 函数（需要 #include <cmath>）。

下面的 C++ 代码执行后将输出 24。

int total;for (int n = 1; n <= 4; n++) {    total *= n;}cout << total;

解析：代码的问题和判断题第4题一样：total 没有初始化！int total; 声明后，total 的值是未定义的（一个随机垃圾值），不是 0 也不是 1。用未定义的值做乘法，结果是未定义的，不可能保证输出 24。正确写法：int total = 1;（累乘初始值必须是1！） • total = 1 × 1 = 1 • total = 1 × 2 = 2 • total = 2 × 3 = 6 • total = 6 × 4 = 24 ✓⚠️ 记住：变量声明后一定要初始化！否则它就是一个"未知数"！

如果 a 是 C++ 的整型变量，值为 4，则表达式 (a % 2 == 0) + (a / 2) 的值为 4。

解析：逐步计算（a = 4）： • a % 2 == 0 → 4 % 2 = 0，0 == 0 为真 → 在 C++ 中，"真"的值是 1 • a / 2 → 4 / 2 = 2 • 整个表达式：1 + 2 = 3 结果是 3，不是 4！💡 知识点：在 C++ 中，布尔值 true 参与运算时等于 1，false 等于 0。所以 (a % 2 == 0) 这个比较表达式的结果是 1（真）或 0（假），不是 4 也不是其他数字！

删除下面 C++ 代码中的 continue 后，其输出与原来相同。

int x = 0;while (x < 4) {    x++;    if (x == 2) continue;    cout << x << ",";}

解析：分析原代码执行过程： • x=0 → x++→x=1 → 1≠2 → 输出 "1," • x=1 → x++→x=2 → 2==2 → continue（跳过输出）→ 不输出 • x=2 → x++→x=3 → 3≠2 → 输出 "3," • x=3 → x++→x=4 → 4≠2 → 输出 "4,"原输出：1,3,4, 删除 continue 后： • x=0→x=1 → 输出 "1," • x=1→x=2 → if 条件为真但无 continue → 输出 "2," • x=2→x=3 → 输出 "3," • x=3→x=4 → 输出 "4,"删除后输出：1,2,3,4,1,3,4, ≠ 1,2,3,4,，输出不同！💡 continue 的作用：跳过本次循环剩余的代码，直接进入下一次循环。这里它让 x=2 时"跳过了输出"。

题目描述：

小杨同学住在 A 市，旅行目的地是 B 市。前往目的地有三种方案：

方案 1：从 A 市直飞 B 市

方案 2：从 A 市坐高铁到 C 市，然后坐飞机到 B 市

方案 3：从 A 市坐高铁到 C 市，然后坐高铁到 B 市

请帮小杨同学求出最便宜的出行方案的价格。

输入：4 行，每行一个正整数

第 1 行：直飞价格

第 2 行：A→C 高铁价格

第 3 行：C→B 飞机价格

第 4 行：C→B 高铁价格

输出：一个正整数，最便宜的价格

样例 1：

输入：999 / 105 / 699 / 588

输出：693

解释：方案1=999，方案2=105+699=804，方案3=105+588=693（最便宜！）

#include <iostream> using namespace std; int main() {     int a, b, c, d;     cin >> a >> b >> c >> d; // 读入4个价格     int x = a;       // 方案1：直飞     int y = b + c;   // 方案2：高铁+飞机     int z = b + d;   // 方案3：全程高铁if (x <= y && x <= z) // x 最小         cout << x;else if (y <= x && y <= z) // y 最小         cout << y;else// z 最小         cout << z;     cout << endl;     return 0; }

⚠️ 易错点提醒：

1. 方案2 和方案3 都包含"从 A 到 C 的高铁费用 b"，别忘了加上！ 2. 三个方案要全部计算完再比较，不能只比前两个。 3. 用 <= 而不是 <，保证相等的情况也能正确输出。

题目描述：

根据国家税收相关规定，劳务报酬需要按月预交个税，预交税率如下：

规则 1：劳务报酬 不超过 800 元的，不需要预交个税；

规则 2：劳务报酬 超过 800 元的，仅超过 800 的部分按照 20%（即 0.2）税率预交个税。

例如：月劳务报酬为 1000.0 元，则需预交 (1000.0 - 800.0) × 20% = 40.00 元。

现在给定小杨同学 12 个月的月度劳务报酬，请计算这 12 个月应预交个税的总和。

输入：12 行，每行一个浮点数（恰好一位小数），表示每月劳务报酬

输出：1 行，一个浮点数，保留两位小数，表示 12 个月应预交个税总和

样例 1（部分）：

输入：932.0, 1634.3, 1790.4, 2172.9, 378.1, 283.4, 2761.9, 3583.5, 10.1, 2324.9, 1111.6, 3812.3

输出：2584.76

#include <iostream> #include <cstdio> using namespace std; int main() {     double ans = 0.0; // 累计总税额     for (int i = 0; i < 12; ++i) {         double a;         cin >> a; // 读入本月劳务报酬         if (a <= 800.0) {             ans += 0.0; // 不超过800，不交税         } else {             ans += (a - 800.0) * 0.2; // 超过部分×20%         }     }     printf("%.2f\n", ans); // 保留两位小数     return 0; }

⚠️ 易错点提醒：

1. 税率只针对超过 800 的部分，不是全部收入！例如收入 1000 元，只有 200 元要交税。 2. 使用 double 类型而不是 int，因为输入是浮点数。 3. 输出必须保留两位小数，用 printf("%.2f\n", ans)。 4. 别忘了用循环读入 12 个月的数据，不能只处理一个月！

📊 本次考点分布：

• 计算机基础：输入/输出设备概念（第1题）

• 数据类型与运算：float 隐式转换、取模运算、运算符优先级（第3、4、8题）

• 输入输出：cin 读取规则、printf 格式（第6、9题）

• 选择结构：if-else 判断、边界条件（第7、11题）

• 循环结构：for 循环、continue、while（第9、10、11、12题）

• 数字处理：提取各位数字（第13题、判断5）

• 综合应用：取模回绕（第14题）、质数判断（第15题）

💪 学习建议：

1. 打牢基础：变量、运算符优先级、类型转换是"地基"，一定要熟练！

2. 多练手：循环和分支是核心，多做"读程序写输出"的练习。

3. 细心审题：很多题考的是"边界情况"（如 = 和 == 的区别，> 和 >= 的区别）。

4. 编程题：学会把文字描述转化为代码逻辑，先理清思路再写代码。

5. 养成好习惯：变量一定要初始化！注释要写清楚！