Appearance
第9章 编程题实战与综合应用
🎯 本章学习目标
读完本章，你将能够：
- ✅ 掌握编程题"四步法"：读题 → 想思路 → 写代码 → 测试
- ✅ 写出完整规范的 C++ 程序框架（头文件 + 命名空间 + main）
- ✅ 熟练掌握"累加求和"编程套路（sum 初始为 0，循环累加）
- ✅ 熟练掌握"计数统计"编程套路（count 初始为 0，满足条件就加 1）
- ✅ 掌握"数位拆分"技巧（%10 取个位，/10 去个位）
- ✅ 掌握"打擂台找最大/最小值"的方法
- ✅ 能独立完成奇偶判断、闰年判断、成绩等级等分支类编程题
- ✅ 学会自己构造边界测试数据（0、1、最大值）
- ✅ 理解输出格式的严格性（严格照抄样例，不加多余文字）
- ✅ 建立"变量清单"的审题习惯，理清每个变量的作用
🗺️ 本章知识图谱
第9章 编程题实战
├── 一、编程题四步法
│ ├── 读题：明确输入输出
│ ├── 想思路：顺序/分支/循环怎么搭
│ ├── 写代码：框架+输入+处理+输出
│ └── 测试：样例+边界+特殊数据
├── 二、经典题型
│ ├── 累加求和（sum=0, sum+=x）
│ ├── 计数统计（count=0, count++）
│ ├── 数位拆分（%10取位, /10去位）
│ ├── 打擂台（找最大/最小值）
│ ├── 分支判断（奇偶/闰年/成绩等级）
│ └── 平均数（注意整数除法截断）
└── 三、易错点
├── 变量未初始化（垃圾值）
├── long long防溢出
├── 输出格式不符
└── 边界条件遗漏📖 引言
这是本书的最后一章，也是把前面各章知识"总装出厂"的一章。
前面各章里，我们认识了计算机的基础知识，记住了编程规范里的一条条"交通规则"，学会了标识符、关键字、变量与基本数据类型，掌握了顺序、分支、循环三大基本结构，练熟了各种运算符，还能熟练地包含头文件、用 cin / cout 处理输入输出。零件都备齐了，今天就是"总装出厂"的日子——独立面对一道编程题，从读题到写出能运行、能得分的完整代码。
一、编程题通关四步法
拿到一道编程题，千万不要急着敲代码！就像做数学应用题要先审题，编程题也有标准的"四步走"：
① 读题 → ② 想思路 → ③ 写代码 → ④ 测试
（看懂） （搭积木） （敲出来） （自己验）第①步：读题——明确"输入什么、输出什么"
拿到题目，先拿笔圈出两句话：
- 输入：程序要读进来几个数？是整数还是小数？先读一个 n 再读 n 个数，还是直接读若干个数？
- 输出：程序最后要打印什么？打印几个数？要不要换行？数字之间用空格还是各占一行？
🔥 高频考点：GESP 编程题的评分是机器自动判分——你的输出和标准答案一个字符都不能差。题目样例怎么换行你就怎么换行，样例数字之间有空格你就输出空格，千万不要自作主张加"请输入：""结果是："这类提示文字，多加一个字都会被判错！同时需要注意大小写，尤其是Yes 和 YES，No和NO等。
第②步：想思路——用顺序/分支/循环怎么搭
问自己三个小问题：
- 这件事要不要重复做？要 → 用循环（
for或while）； - 要不要看情况做选择？要 → 用
if/else； - 要不要边做边攒？（求和、计数、找最大）要 → 准备好"累加器""计数器""擂台变量"。
思路在草稿纸上写两三行"人话"就行，比如："读入 n → 循环 n 次，每次读一个数加进 sum → 输出 sum"。
第③步：写代码——框架 + 输入 + 处理 + 输出
一级所有程序都可以套这个"四段式骨架"：
cpp
#include <iostream> // 框架：包含头文件
using namespace std; // 框架：使用标准命名空间
int main() { // 框架：主函数
// —— 输入：把题目给的数据读进变量 ——
// —— 处理：循环、判断、累加…… ——
// —— 输出：按题目要求打印结果 ——
return 0; // 框架：主函数结束
}💡 小建议：上考场先把这 5 行框架敲好，再往里面填内容。框架在，程序的"房子"就盖好了一半。
第④步：测试——自己造数据验证
代码写完不是结束，一定要自己运行几组数据！除了题目给的样例，还要专门造三类"边界数据"：
| 测试类型 | 造什么数据 | 为什么 |
|---|---|---|
| 正常数据 | 题目样例 | 验证基本逻辑对不对 |
| 边界数据 | 0、1、最大值（如 n=1、成绩=60、数字=0） | 边界最容易出 bug，比如"刚好及格""只有一个数" |
| 特殊数据 | 1000、999 这类"整"数 | 验证循环次数、数位拆分对不对 |
⚠️ 易错点：很多同学代码只跑样例，样例一过就交卷。可考官判分时用的数据千奇百怪——样例对了不代表程序对了，自己多造两组数据，花 2 分钟可能救回 25 分。
四步法还有一个帮你"想思路"的小工具——变量清单：动笔编码前，先在草稿纸写出这道题需要几个"小盒子"。比如成绩统计题：
| 变量名 | 类型 | 装什么 | 初始值 |
|---|---|---|---|
i | int | 循环计数器 | 1 |
score | int | 每次读入的成绩 | 无（循环里读） |
pass | int | 及格人数 | 0 |
maxScore | int | 最高分擂台 | 0 |
变量清单一列，"谁清零、谁在循环里变化、最后输出谁"清清楚楚，代码自然水到渠成。
二、一级编程题七大高频套路（附模板代码）
刷过真题你会发现，一级编程题翻来覆去就是五个"脸谱"。先上一张总览表，再逐个拆模板：
| 套路 | 题目里的"暗号" | 核心变量 | 核心语句 |
|---|---|---|---|
| ① 累加求和 | 求和、总和、一共 | sum 初始 0 | sum += x; |
| ② 计数统计 | 统计……个数、有多少 | count 初始 0 | if(条件) count++; |
| ③ 数位拆分 | 各位数字、几位数 | n、个位 n%10 | while(n>0){ n/=10; } |
| ④ 找最值 | 最大、最小、最高 | maxVal/minVal | 打擂台比较更新 |
| ⑤ 分支判断 | 判断、分类、等级 | 条件表达式 | if / else if / else |
把下面五套模板背熟，考场上就是"换数字游戏"。
套路一：累加求和 🔥🔥🔥
标志：题目里出现"求和""总和""一共多少"。
口诀：sum 清零站门前，循环里面 sum += x。
cpp
// 模板A：1 到 n 求和
int n;
cin >> n;
long long sum = 0; // 累加器：开门前是 0
for (int i = 1; i <= n; i++) { // i 从 1 数到 n
sum += i; // 等价于 sum = sum + i，把 i 攒进去
}
cout << sum << endl;cpp
// 模板B：读入 n 个数求和
int n;
cin >> n;
long long sum = 0;
for (int i = 1; i <= n; i++) {
int x;
cin >> x; // 每圈读一个数
sum += x; // 攒进总和
}
cout << sum << endl;🔥 高频考点：累加器
sum必须在循环前初始化为 0！写在循环里面就会每圈被清零，永远攒不起来——就像小猪存钱罐每存一枚就倒空，最后还是空罐子。
套路二：计数统计 🔥🔥🔥
标志：题目里出现"统计……的个数""有多少个……"。
口诀：count 清零站门前，满足条件 count++。
cpp
// 模板：统计 n 个数中奇数的个数
int n;
cin >> n;
int count = 0; // 计数器：一开始一个都没数到
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x % 2 != 0) { // 除以 2 余数不为 0 → 奇数
count++; // 数到一个，计数器加 1
}
}
cout << count << endl;⚠️ 易错点：判断奇数推荐写
x % 2 != 0（余数不等于 0），而不是x % 2 == 1。如果输入数据一定为非负整数，== 1也可；但!= 0更通用，负奇数也不会漏。求和与计数是"亲兄弟"：一个攒数值，一个数个数，都要先清零。
套路三：数位拆分 🔥🔥🔥
标志：题目里出现"各位数字""数位""个位/十位/百位""数字之和""几位数"。
两大法宝：
| 操作 | 写法 | 比喻 |
|---|---|---|
| 取出个位 | n % 10 | 掰下最右边那一颗"糖葫芦" |
| 去掉个位 | n / 10 | 把最右边那颗"吃掉" |
| 循环条件 | while (n > 0) | 还有数字就继续掰 |
cpp
// 模板：求一个整数各位数字之和
int n;
cin >> n;
int sum = 0;
while (n > 0) {
sum += n % 10; // 掰下个位，加进总和
n = n / 10; // 去掉个位，继续处理剩下的
}
cout << sum << endl;以 n = 123 为例，循环过程一目了然：
| 圈数 | n 进入循环时 | n % 10（个位） | sum | n / 10 后 |
|---|---|---|---|---|
| 第1圈 | 123 | 3 | 3 | 12 |
| 第2圈 | 12 | 2 | 5 | 1 |
| 第3圈 | 1 | 1 | 6 | 0 |
| 结束 | n=0，0 > 0 为假，循环停止 | — | 答案 6 ✅ | — |
⚠️ 易错点（边界！）：如果输入是
0，循环一次都不执行。求"各位数字之和"时sum刚好是 0，歪打正着；但如果求"几位数"，0 会被错误地数成 0 位（0 其实是 1 位数），需要在循环后补一句if (count == 0) count = 1;特判。
套路四：比较找最值（打擂台）🔥🔥🔥
标志：题目里出现"最大值""最小值""最高""最低"。
口诀：先请一人当擂主，后来者更强就换人。
cpp
// 模板：从 n 个数中找最大值
int n;
cin >> n;
int maxVal;
cin >> maxVal; // 第 1 个数直接坐上"擂主"宝座
for (int i = 2; i <= n; i++) { // 剩下的 n-1 个数挨个来挑战
int x;
cin >> x;
if (x > maxVal) { // 挑战者比擂主更强？
maxVal = x; // 换人！新擂主诞生
}
}
cout << maxVal << endl;找最小值只要把 > 换成 <。打擂台的生活画面：一排同学比身高，第一个人先站上台；后面每个人上来和台上的比，谁高谁留下——比到最后，台上站的就是全班最高的人。
💡 小技巧：如果题目保证数据都是非负的（比如成绩 0~100），也可以让
maxVal = 0起步、所有数都从第 1 个开始打；但"第一个数当擂主"是通用写法，正数负数都不怕，推荐优先用它。
套路五：分支判断类 🔥🔥
标志：题目让程序"判断……是不是……""输出等级/类别"。核心就是 if / else if / else 对号入座，三个最经典的模子：
① 判断闰年（四年一闰，百年不闰，四百年又闰）：
cpp
int year;
cin >> year;
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
cout << "闰年" << endl;
} else {
cout << "平年" << endl;
}🔥 高频考点：闰年条件 = 能被 4 整除但不能被 100 整除，或者能被 400 整除。
&&是"并且"（两个条件都要成立），||是"或者"（任一成立即可），注意括号别漏。
② 成绩等级（多分支阶梯，命中一个就收手）：
cpp
int score;
cin >> score;
if (score >= 90) {
cout << "优秀" << endl;
} else if (score >= 60) { // 能走到这里说明 score < 90，不用再写
cout << "及格" << endl;
} else {
cout << "不及格" << endl;
}③ 奇偶分类：
cpp
if (x % 2 == 0) cout << "偶数" << endl;
else cout << "奇数" << endl;⚠️ 易错点：判断相等是两个等号
==，一个等号=是赋值！if (score = 90)是把 90 放进 score（条件恒为真），if (score == 90)才是"分数等于 90 吗"。口诀：一个等号放进去，两个等号比一比。
套路六：switch 等值分支 🔥🔥
标志：题目让你根据一个整数/字符变量的值，从多个固定选项中选一个（比如"输入 1 选加法、2 选减法"）。这种"等于几就做什么"的题，除了用 else if，还能用 switch 写得更整齐。
模板：简易计算器（加减乘除）
cpp
int a, b;
char op; // 运算符：+ - * /
cin >> a >> op >> b;
switch (op) {
case '+':
cout << a + b << endl;
break;
case '-':
cout << a - b << endl;
break;
case '*':
cout << a * b << endl;
break;
case '/':
cout << a / b << endl;
break;
default:
cout << "输入错误" << endl;
}💡 什么时候用 switch 比 if 好？
- 分支条件是"等于哪个固定值"（整数或字符）→ 用 switch
- 分支是"大于小于"的范围判断 → 只能用 if
- 考试里两种都能用时，选你写得最熟的就行
⚠️ switch 三大铁律：
case后面只能是常量（整数或字符），不能写变量或条件- 每个
case末尾的break不能漏，否则会穿透到下一个 casedefault是兜底分支，所有 case 都不匹配时走它
套路七：do-while 循环输入 🔥🔥
标志：题目让用户"反复输入直到输入某个值停止"或者"至少输入一次再判断"。典型关键词："直到输入 0 结束""反复输入直到正确"。
模板：反复读入数字，输入 0 就停止（统计总和）
cpp
int sum = 0;
int x;
do {
cin >> x; // 先读一个数
sum += x; // 加进总和（0 加进去也不影响）
} while (x != 0); // 不是 0 就继续循环
cout << sum << endl;🔥 为什么用 do-while 而不是 while？ 因为"读入一个数"这件事至少要发生一次——总不能一次都不读就结束吧？do-while 的"先执行一次，再判断"正好完美匹配这种场景。
💡 do-while 最容易忘的两个点：
- 结尾
while (条件);的分号不能漏（和 while 循环不一样！）- 条件是"继续循环的条件"，不是"停止的条件"——想"输入 0 就停止"，条件就要写
x != 0（不等于 0 就继续）
📌 七大套路光看不练记不牢，建议到 百练百会（官网 www.bestwit.cn，或微信小程序搜索"百练百会"）把求和、计数、数位拆分、找最大值的专项题各刷 5 道，平台支持 C++ 在线编译评测，提交立刻判对错，套路练到"肌肉记忆"，考场上想写错都难。
三、三道完整编程题精讲
下面三道题难度层层递进，我们严格按"四步法"走完全流程。
精讲 1 ⭐⭐：n 个整数的和与平均值
【题目】 读入一个正整数 n，再读入 n 个整数，输出它们的总和与平均值。
① 读题：输入第一行是 n，第二行是 n 个整数；输出两行——第一行总和，第二行平均值。
② 想思路：典型"累加求和"套路。准备累加器 sum = 0，循环 n 次，每次读一个数加进去；平均值 = 总和 ÷ 个数。
③ 写代码：
cpp
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
long long sum = 0; // 累加器清零；用 long long 防溢出
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
sum += x;
}
cout << sum << endl; // 输出总和
cout << sum * 1.0 / n << endl; // 输出平均值（乘 1.0 变成小数除法）
return 0;
}④ 测试：
| 测试输入 | 预期输出 | 说明 |
|---|---|---|
3 换行 1 2 3 | 6 换行 2 | 样例数据，1+2+3=6，平均 2 |
1 换行 5 | 5 换行 5 | 边界 n=1：只有一个数 |
4 换行 1 2 3 4 | 10 换行 2.5 | 验证平均值能出小数 |
⚠️ 易错点：
sum / n在两个整数相除时是整除（小数部分被砍掉），10/4 会得到 2 而不是 2.5！写成sum * 1.0 / n，让除法"变身"小数除法，平均值才算得准。
精讲 2 ⭐⭐⭐：各位数字之和
【题目】 读入一个非负整数 n（0 ≤ n ≤ 10⁹），输出它各位数字之和。例如 123 的各位数字之和是 1+2+3=6。
① 读题：输入一个整数；输出一个整数——各位数字之和。
② 想思路：数位拆分套路——while (n > 0) 循环，每圈 n % 10 掰下个位加进总和，再 n / 10 去掉个位。
③ 写代码：
cpp
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int sum = 0;
while (n > 0) {
sum += n % 10; // 掰下个位数字，加进总和
n = n / 10; // 砍掉个位，剩下的继续
}
cout << sum << endl;
return 0;
}④ 测试：
| 测试输入 | 预期输出 | 手动验证 |
|---|---|---|
123 | 6 | 1+2+3=6 ✅ |
1000 | 1 | 1+0+0+0=1，0 也要会处理 ✅ |
999 | 27 | 9+9+9=27，每位都最大 ✅ |
0 | 0 | 边界 0：循环不执行，sum 初始就是 0，答案正确 ✅ |
🔥 高频考点：数位拆分是一级最爱的"变身题"——同一套模板，把
sum += n % 10换成count++就是求几位数，换成if ((n % 10) % 2 == 0) count++就是统计偶数数字的个数。一个模子能变出半打考题！
精讲 3 ⭐⭐⭐⭐：成绩统计（计数 + 最值综合）
【题目】 依次读入 10 个同学的成绩（0~100 的整数），统计并输出：及格（≥60 分）的人数，以及全班最高分。
① 读题：输入 10 个整数（一行或多行都行，cin 会自动跳过空格换行）；输出两行——第一行及格人数，第二行最高分。
② 想思路：这道题是计数 + 打擂台双套路合体！
- 计数器
pass统计 ≥60 的个数； - 擂台变量
maxScore记最高分； - 循环 10 次，每读一个成绩，同时干这两件事。
③ 写代码：
cpp
#include <iostream>
using namespace std;
int main() {
int pass = 0; // 及格人数计数器
int maxScore = 0; // 最高分擂台（成绩最小是 0，0 当起点安全）
for (int i = 1; i <= 10; i++) {
int score;
cin >> score;
if (score >= 60) { // 及格？
pass++; // 计数器加 1
}
if (score > maxScore) { // 比当前最高分还高？
maxScore = score; // 擂台换人
}
}
cout << pass << endl; // 输出及格人数
cout << maxScore << endl; // 输出最高分
return 0;
}④ 测试：
| 测试输入（10 个成绩） | 预期输出 | 验证点 |
|---|---|---|
60 60 60 60 60 60 60 60 60 60 | 10 换行 60 | 边界：60 分整算及格（>=） |
59 59 59 59 59 59 59 59 59 59 | 0 换行 59 | 边界：59 分不及格；无人及格 |
0 100 55 78 90 33 66 88 100 42 | 6 换行 100 | 正常数据，最高分并列也不怕 |
💡 综合题不可怕：它不过是把两个套路"焊"在同一个循环里——一圈读一个数，计数、打擂同时做。读完题先在草稿纸上列出"我需要几个变量、每圈干什么"，思路就不会乱。
四、考场技巧：让 25 分稳稳到手
技巧 1：编译报错怎么办？别慌，按图索骥 🔧
上机考试最吓人的就是"一片红色报错"。记住：编译器是你的朋友，它会告诉你错在第几行。处理流程：
- 只看第一条错误，改完重新编译——后面一大串报错常是第一条引起的连锁反应；
- 双击错误信息，光标会跳到出错行，重点看这一行和它的上一行（漏分号的错误常报在下一行）；
- 一级高频"翻车点"对照表：
| 报错现象 | 最可能的原因 |
|---|---|
expected ';' before ... | 上一行漏了分号 ; |
was not declared in this scope | 变量没定义就用，或名字拼写大小写不一致 |
cout/cin was not declared | 漏写 #include <iostream> 或 using namespace std; |
| 程序能运行但结果错 | 语法没错、逻辑错：检查循环条件、=/==、变量初始化 |
技巧 2：先保证能编译运行，再求对 ✅
时间紧张时的正确策略：先写一个能跑起来的最简版本（哪怕只完成读入和原样输出），确认没有语法错误，再一步步往里加逻辑。一个能运行、能拿部分分的程序，远胜过一个编译不过、0 分的"完美半成品"。
技巧 3：变量一定初始化！ 🧮
- 累加器
sum = 0、计数器count = 0，必须在循环之前写好； - C++ 中局部变量不初始化，里面是随机的"垃圾值"——不清零就累加，结果会是一个莫名其妙的数。这是一级考场排名第一的"隐形杀手"。
技巧 4：long long 防爆 💣
int 大约只能装 -21 亿 ~ 21 亿。单个的数够用，可一旦做累加就可能撑爆：比如 1 加到 100000，和是 50 多亿，int 装不下，答案会变成负数或怪数字。
🔥 养成习惯：凡是"求和"的累加器，直接写
long long sum = 0;。long long能装约 900 亿亿，一级考试随便加都炸不了，多写两个单词，杜绝爆零惨剧。
技巧 5：输出格式严格按题目 📐
- 要换行就写
endl（或"\n"），题目几个输出就几行； - 数字之间要空格就输出
" "，样例没有空格就别加； - 不要输出任何题目没要求的文字（"请输入""答案是""thank you"统统不要）；
- 提交前把自己的输出和样例逐字符对一眼：行数、空格、换行，一模一样才算过。
五、📝 实战练习
光说不练假把式，下面几道题覆盖选择、判断、编程三种题型，先自己做再看答案。
练习题 1（程序阅读题）
题目： 以下程序段执行后，sum 的值是（ ）
cpp
int sum = 0;
for (int i = 1; i <= 5; i++) {
sum += i;
}
cout << sum << endl;A. 5 B. 10 C. 15 D. 不确定
🔑 点击查看答案与解析
答案： C
解析： 循环让 i 依次取 1、2、3、4、5，sum 从 0 开始累加：0+1+2+3+4+5 = 15。这正是"1 到 n 求和"模板，n=5 时答案是 15。
练习题 2（单选题）
题目： 整数 n = 2024，表达式 n % 10 和 n / 10 的值分别是（ ）
A. 4 和 202 B. 2 和 24 C. 4 和 202.4 D. 202 和 4
🔑 点击查看答案与解析
答案： A
解析： n % 10 取个位 → 4；n / 10 是整数除法，砍掉个位 → 202（不是 202.4，整数除以整数结果仍是整数）。
练习题 3（判断题）
题目： 判断下列说法是否正确：
① 累加器变量在循环开始前应初始化为 0。（ ）
② 求 n 个数的平均值时，sum / n 一定能得到带小数的准确结果。（ ）
③ 统计"个数"的计数器和求"总和"的累加器，都必须在循环前清零。（ ）
④ 为防止求和结果过大，累加器可以声明为 long long 类型。（ ）
⑤ 编程题输出时，为了友好，可以自己加上"请输入数据："这样的提示语。（ ）
🔑 点击查看答案与解析
答案：
- √ 对。不清零就累加，初始的"垃圾值"会污染结果。
- × 错。两个整数相除是整除，小数部分被砍掉，应写
sum * 1.0 / n。 - √ 对。计数、累加本质相同，都是"从零开始攒"。
- √ 对。
long long范围远大于int，求和时推荐使用。 - × 错。机器判分要求输出与样例逐字符一致，多余文字会导致判错。
练习题 4（编程题）
题目： 读入一个正整数 n，再读入 n 个整数，输出其中偶数的个数。
🔑 点击查看答案与解析
思路： 计数套路——计数器清零，循环读入每个数，x % 2 == 0 成立就 count++。
参考代码：
cpp
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int count = 0;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x % 2 == 0) {
count++;
}
}
cout << count << endl;
return 0;
}测试：输入 5 和 1 2 3 4 6，输出 3（偶数为 2、4、6）；输入 1 和 7，输出 0（边界：一个偶数都没有）。
练习题 5（编程题）
题目： 读入一个非负整数 n（0 ≤ n ≤ 10⁹），输出它是几位数。例如 123 是 3 位数。
🔑 点击查看答案与解析
思路： 数位拆分模板变身——每砍掉一个个位，计数器加 1；特别注意 n = 0 时循环不执行，要特判为 1 位。
参考代码：
cpp
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int count = 0;
while (n > 0) {
count++; // 每有一个个位，位数加 1
n = n / 10; // 砍掉个位
}
if (count == 0) { // 边界：输入是 0，循环没执行
count = 1; // 0 也是 1 位数
}
cout << count << endl;
return 0;
}测试：123 → 3；1000 → 4；9 → 1；0 → 1（边界特判是否生效）。
练习题 6（判断题）
题目： 输入两个整数和一个运算符（+、-、*、/ 中的一个），输出运算结果。如果运算符不是这四个，输出"error"。
输入样例 1：
3 + 5输出样例 1：
8输入样例 2：
10 & 2输出样例 2：
error提示：用 switch 判断运算符，注意整数除法直接舍弃小数。
🔑 点击查看参考代码
cpp
#include <iostream>
using namespace std;
int main()
{
int a, b;
char op;
cin >> a >> op >> b;
switch (op) {
case '+':
cout << a + b << endl;
break;
case '-':
cout << a - b << endl;
break;
case '*':
cout << a * b << endl;
break;
case '/':
cout << a / b << endl;
break;
default:
cout << "error" << endl;
}
return 0;
}要点说明：
- switch 里判断字符型变量
op，每个 case 对应一个运算符 - 每个 case 末尾必须有
break，否则会穿透 default处理运算符不合法的情况
练习题 7（编程题）
题目： 设定一个答案 answer = 42，让用户反复输入数字猜答案，直到猜对为止。每次猜错告诉用户"太大了"或"太小了"，猜对时输出"恭喜猜对了！"。
输入样例：
50
30
42输出样例：
太大了
太小了
恭喜猜对了！提示：因为至少要猜一次，用 do-while 最合适。循环条件是"没猜对就继续"。
🔑 点击查看参考代码
cpp
#include <iostream>
using namespace std;
int main()
{
int answer = 42;
int guess;
do {
cin >> guess;
if (guess > answer) {
cout << "太大了" << endl;
} else if (guess < answer) {
cout << "太小了" << endl;
} else {
cout << "恭喜猜对了！" << endl;
}
} while (guess != answer);
return 0;
}要点说明：
- do-while 保证至少执行一次（至少猜一次）
- 循环条件
guess != answer意思是"没猜对就继续" - 注意 do-while 末尾的分号不能漏！
六、📊 考点总结表
| 考点 | 重要程度 | 出题形式 |
|---|---|---|
| 编程题四步法（读题→思路→编码→测试） | ⭐⭐⭐⭐⭐ | 两道编程大题 |
| 程序四段式骨架（头文件→main→输入处理输出） | ⭐⭐⭐⭐⭐ | 两道编程大题 |
| 累加求和（sum=0，循环 sum+=） | ⭐⭐⭐⭐⭐ | 编程大题 |
| 计数统计（count=0，满足条件 count++） | ⭐⭐⭐⭐⭐ | 编程大题 |
| 数位拆分（n%10 取个位、n/10 去个位、while） | ⭐⭐⭐⭐⭐ | 编程大题 |
| 打擂台找最大/最小值 | ⭐⭐⭐⭐⭐ | 编程大题 |
| 闰年判断、成绩等级、奇偶分类等分支题 | ⭐⭐⭐⭐ | 选择/编程 |
| switch 等值分支（case/break/default） | ⭐⭐⭐⭐ | 选择/编程 |
| do-while 循环（先执行后判断、末尾分号） | ⭐⭐⭐⭐ | 选择/编程 |
| 边界数据测试（0、1、最大值） | ⭐⭐⭐⭐ | 编程自检 |
| 变量初始化（局部变量不清零是垃圾值） | ⭐⭐⭐⭐⭐ | 改错/编程 |
| long long 防止求和溢出 | ⭐⭐⭐⭐ | 编程 |
| 整数除法截断（sum*1.0/n 求平均） | ⭐⭐⭐⭐ | 选择/编程 |
| 输出格式严格照抄样例（endl、空格、无多余文字） | ⭐⭐⭐⭐⭐ | 编程大题 |
┌──────────────────────────────────────────────────────────────┐
│ 💻 编程题必背速记卡（一级） │
├──────────────────────────────────────────────────────────────┤
│ 1. 四步法：读题（输入/输出）→ 想思路 → 写代码 → 测边界 │
│ 2. 框架先敲：#include <iostream> + using namespace std; │
│ 3. 累加：long long sum = 0; 循环里 sum += x; │
│ 4. 计数：int count = 0; 满足条件 count++; │
│ 5. 拆数位：while(n>0){ sum += n%10; n /= 10; } │
│ 6. 打擂台：第一个数当擂主，更大（更小）就换人 │
│ 7. 闰年：(y%4==0 && y%100!=0) || y%400==0 │
│ 8. 判断相等用 ==，赋值用 =；奇数判断用 x%2!=0 │
│ 9. 求平均：sum * 1.0 / n（整数相除会砍掉小数） │
│ 10. 变量先初始化；求和用 long long；输出照抄样例格式 │
└──────────────────────────────────────────────────────────────┘七、全书回顾 · 一级知识地图
从第1章到本章，你已经走完了 GESP 一级 C++ 备考的完整路径：
| 章 | 主题 | 对应考纲知识块 |
|---|---|---|
| 第1章 | 总览：考纲全景与备考规划 | —— |
| 第2章 | 计算机基础知识与开发环境 | 计算机基础知识、集成开发环境 |
| 第3章 | 编程规范 | 程序的基本概念（注释） |
| 第4章 | 基础语法：标识符、关键字与变量 | 程序的基本概念 |
| 第5章 | 基本数据类型 | 基本数据类型 |
| 第6章 | 三大基本结构 | 结构化程序设计 |
| 第7章 | 运算符 | 基本运算 |
| 第8章 | 输入输出与头文件 | 程序的基本语句 |
| 第9章 | 编程题实战与综合应用 | 综合应用 |
九章内容，从考纲全景出发，你认识了计算机的软硬件世界和 Dev-C++ 开发环境，记住了编程规范里的一条条"交通规则"；你学会了标识符、关键字、变量与基本数据类型，练熟了算术、赋值、比较、逻辑各种运算符，掌握了顺序、分支、循环三大基本结构，能熟练地包含头文件、用 cin / cout 与程序"对话"；今天，你又把这一切融会贯通——读题、构思、编码、测试，独立写出了求和、计数、拆数位、找最值的完整程序。🎉 你已经搭建起了完整的一级知识体系，从一个"看代码的人"，变成了"写代码的人"。