GESP C++ 三级 · 14 天闯关
数据表示 · 进制位运算与数组字符串
7 天理论 + 7 天编程题:前 7 天把本级别考点的 近 13 期真题 325 道全部刷完(含 28 道需要看原卷配图的题), 后 7 天按知识点分天练编程题(洛谷题面 + 美力程题解),共 32 道; 末尾附 1 套模拟自测卷。
理论天含:① 今日考情(真题分布 + 配套教材)→ ② 知识地图(思维导图)→ ③ 核心精讲 → ④ 真题演练(本考点全部真题,10 题/卡)→ ⑤ 今日打卡。 编程天按知识点分组(如「图案输出 · 嵌套循环画图」一天),题面取洛谷、题解取美力程。 单选答案已与官方答案表逐题核对。进度保存在本机浏览器。
进制转换
①今日考情 · 真题分布与备考建议
本考点在 GESP C++ 3级近 14 期真题中共 52 道客观题(单选 35 / 判断 17,其中 2 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。
本期分布
| 期次 | 题数 |
|---|---|
| 2023年12月 C++ 3级 | 2 |
| 2023年6月 C++ 3级 | 5 |
| 2023年9月 C++ 3级 | 5 |
| 2024年12月 C++ 3级 | 6 |
| 2024年3月 C++ 3级 | 2 |
| 2024年6月 C++ 3级 | 3 |
| 2024年9月 C++ 3级 | 4 |
| 2025年12月 C++ 3级 | 2 |
| 2025年3月 C++ 3级 | 8 |
| 2025年6月 C++ 3级 | 4 |
| 2026年3月 C++ 3级 | 7 |
| 2026年9月 C++ 3级 | 4 |
配套教材
GESP 大通关 3 级(全书 64 页):本天对应 3.1 进制转换。教材按同一套大纲顺序编排,可对照阅读。
备考建议(出题人视角)
进制转换是三级最"能算"的一块:只要会两张表(2 的幂次表、十六进制对照表)和一个口诀(除基取余倒读、按权展开相加),所有题都能一步步算出来。丢分点非常集中:**十六进制要看四位一组**、**转十进制是从右往左标权**、**余数要倒着读**。建议每天手算 5 道,要求写出过程。
②知识地图 · 本考点思维导图
- 四种常用进制
- 二进制 B(0-1) 八进制 O(0-7)
- 十进制 D(0-9) 十六进制 H(0-9 A-F)
- 2 的幂次表:2⁰=1 2¹=2 2²=4 2³=8 2⁴=16
- 2⁵=32 2⁶=64 2⁷=128 2⁸=256 2¹⁰=1024
- 任意进制 → 十进制
- 按权展开相加:从右往左,第 k 位权是 base^k
- 十进制 → 任意进制
- 除基取余,余数**倒着读**
- 二进制 ↔ 八 / 十六进制(分组法)
- 八进制:三位一组(向左补 0)
- 十六进制:四位一组(向左补 0)
- 常见陷阱
- 余数顺序读反(必须倒读)
- 十六进制 A=10 B=11 C=12 D=13 E=14 F=15
- 位数不足时忘了补前导 0
③核心精讲
1. 四种进制与基本数位
| 进制 | 基数 | 数字符号 | 例子 |
|---|---|---|---|
| 二进制 | 2 | 0 1 | 1011₂ |
| 八进制 | 8 | 0~7 | 17₈ |
| 十进制 | 10 | 0~9 | 15 |
| 十六进制 | 16 | 0~9 A~F | 1B₁₆ |
十六进制里 A=10,B=11,C=12,D=13,E=14,F=15。
2 的幂次表(必背)
| 2⁰ | 2¹ | 2² | 2³ | 2⁴ | 2⁵ | 2⁶ | 2⁷ | 2⁸ | 2⁹ | 2¹⁰ |
|---|---|---|---|---|---|---|---|---|---|---|
| 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128 | 256 | 512 | 1024 |
2. 任意进制 → 十进制:按权展开
从右往左数位,第 k 位(从 0 开始)的权是 base^k。
1011₂ = 1×2³ + 0×2² + 1×2¹ + 1×2⁰
= 8 + 0 + 2 + 1 = 11
7E6₁₆ = 7×16² + 14×16¹ + 6×16⁰
= 7×256 + 224 + 6 = 1792 + 230 = 2022
易错:权是从 2⁰ 开始,不是从 2¹ 开始;最高位的权是「位数−1」次方。
3. 十进制 → 任意进制:除基取余,倒读
把 25 转成二进制:
25 ÷ 2 = 12 …… 余 1 ↑
12 ÷ 2 = 6 …… 余 0 │
6 ÷ 2 = 3 …… 余 0 │ 余数
3 ÷ 2 = 1 …… 余 1 │ 倒着读
1 ÷ 2 = 0 …… 余 1 │
→ 11001₂
余数必须从下往上读(倒读),这是最常见的错。
4. 二进制 ↔ 八进制 / 十六进制:分组法
| 转换 | 分组 | 例子 |
|---|---|---|
| 二 → 八 | 从右往左三位一组 | 101 110 → 56₈ |
| 二 → 十六 | 从右往左四位一组 | 0010 1110 → 2E₁₆ |
| 八 → 二 | 每位拆成三位 | 56₈ → 101 110 |
| 十六 → 二 | 每位拆成四位 | 2E₁₆ → 0010 1110 |
易错:十六进制是四位一组,八进制是三位一组,不要混。 分组时最高位不够要在左边补 0。
5. 快速验算技巧
- 二进制转十进制可以逐位翻倍:从左到右,每读一位就
结果 = 结果×2 + 该位。
例 1011:0 →1 →2 →5 →11。
- 同理八进制用 ×8,十六进制用 ×16。这个方法比按权展开快,也不容易数错位。
6. 一分钟记忆卡
- 2 的幂:1 2 4 8 16 32 64 128 256 512 1024
- A=10 … F=15
- 转十进制:按权展开,最右位是 base⁰
- 转其他进制:除基取余,余数倒读
- 二↔八:三位一组;二↔十六:四位一组,左补 0
- 速算:从左到右
结果×base + 当前位
#include <iostream>
using namespace std;
void decimal2octal(int decimal) {
int oct_number[100];
int i = 0;
while (decimal > 0) {
__________________________ //在此处填入代码
}
for (int j = i - 1; j >= 0; j--) {
cout << oct_number[j];
}
cout << endl;
}[10000011]原=( ) [10000011]补=( )
#include <iostream>
using namespace std;
int main() {
int decimal = 255;
——————————————————
return 0;
}- 1.D 二进制数11.01 在十进制下是( )。…
- 2.B 计算机中存储的数据都是二进制形式。因此,在使用C++语言编写程序时,…
- 3.B 二进制数101.101 在十进制下是 5.005。…
- 4.C 下列代码将十进制转化成八进制,则横线上应填入( )。…
- 5.C 二进制数101.11对应的十进制数是( )。…
- 6.A 8进制数3703转换成16进制数是( )…
- 7.B 下列二进制表示的十进制数值分别是( )…
- 8.A 16进制数B2025转换成8进制数是( )…
- 9.A 十进制数 111.111 的二进制表示可以是下面的( )。…
- 10.C 下面程序是将十进制转十六进制,横线处应该填入的是( )…
- 11.A 二进制数 1101.101 对应的十进制数是( )…
- 12.A 八进制数 35.6 对应的十进制数是( )…
- 13.B 请将二进制数 (1101.101)₂,转换为等值的10进制数( )…
- 14.A a & b | (c ^ d),其中 a = 3, b = 7, c…
- 15.B 三进制数 2102(₃) 转换成十进制是:( )。…
- 16.D 关于进制转换,下面说法不正确的是( )…
- 17.B 在C++语言中,表达式(0xf == 015)的值为true。…
- 18.A 在C++语言中,表达式(0xff == 255) 的值为true。…
- 19.D 在下列编码中,不能够和二进制"1101 1101"相等的是( )。…
- 20.C 如果16位短整数-2 的二进制是"FFFE",则短整数-4 的十六进…
int a = 0b1010; int b = 01100; int c = a & b; cout << c <<endl;
63/2=31 余 1 31/2=15 余 1 15/2=7 余 1 7/2=3 余 1 3/2=1 余 1 1/2=0 余 1
- 21.B 执行下面C++代码后,输出的结果是8。…
- 22.D 0.8125变成二进制是( )。…
- 23.A 16进制数AB,表示成2进制数是10101011。( )…
- 24.B def (十六进制) = 103231 (五进制)。( )…
- 25.A 625.625变成二进制是( )。…
- 26.B 10 进制数 63,在转换成二进制的计算过程中,产生了如下的式子:按…
- 27.A CCF(十六进制) = 12363(七进制)…
- 28.B UTF-8 编码规则如下: 1 字节:0xxxxxxx 2 字节:1…
- 29.A 两个13进制的数A和B,在10进制下分别表示10和11。(A+B)1…
- 30.B k 进制,逢 k 进第二位,k² 进百位,k³ 进千位;…
对应的一位8 进制位。 为对应的一位16 进制位。
int main() {
int decimal = 25;
cout << oct << decimal;
return 0;
}- 31.B CCF(十九进制) = 21AC(十三进制)(不区分大小写)…
- 32.B 在C++语言中,表达式 ((0xf0 + 0x15) == 255)…
- 33.B 三进制有个奇妙的应用,有 1000 个酒缸,恰好 1 缸有毒。毒酒喝…
- 34.B 下列关于进制的叙述,不正确的是( )。…
- 35.C 下列关于进制的叙述,正确的是( )。…
- 36.A 下列程序的作用是( )…
- 37.A 若将一个正整数化为二进制数,在此二进制数中,我们将数字 1 的个数是…
- 38.D 已知 unsigned char c = 0x0F; (十六进制 0…
- 39.A 已知大写字符'A'的ASCII 编码的十六进制表示为0x41,则字符…
- 40.C 已知大写字符'A' 的ASCII编码的十六进制表示为0x41,则字符…
#include <iostream>
using namespace std;
int main() {
int n = 0;
cin >> n;
for (int i = 0; i < n; i++) {
char str[11];
cin >> str;
char max = '0';
for (int i = 0; str[i] != '\0'; i++)
if (str[i] > max)
max = str[i];
_____________________________
}
return 0;
}- 41.B C++的数据类型转换让人很难琢磨透,下列代码输出的值是( )。…
- 42.C C++的字符变量的码值是整数,下面字面量形式的字符码值最大的是( )…
- 43.A 函数声明 double f(); 返回 int 时,会自动转换为 d…
- 44.A 已知大写字符 A 的ASCII编码的十六进制表示为 0x41,计算字…
- 45.A 下列程序是分别判断输入的 N 个数是否可能是二进制、八进制、十进制、…
- 46.D 8 位二进制下,十进制数-15 的补码是( )。…
- 47.B 二进制数 10110101 是某数的 8 位补码,该数的十进制是( …
- 48.B 在下列代码的横线处填写( ),可以使得输出是“20 10”。…
- 49.A a|10(a与10都是10进制,且二进制表示最高位为1)运算的结果是…
- 50.B 二进制数 1010 | 1100 的结果是( )…
#include <iostream>
using namespace std;
int main() {
const int READ = 1 << 0;
const int WRITE = 1 << 1;
const int MODIFY = 1 << 2;
const int DELETE_ = 1 << 3;
int mask = 0;
__________________________
return 0;
}- 51.A 如果 a 为 int 类型的变量,且 a 的二进制最低位为 0,则表…
- 52.A 下面的程序是位掩码技术实现权限的组合管理。首先定义四个权限常量,分别…
④今日打卡 · 点一下就能勾选
- 默写 2 的幂次表(2⁰ 到 2¹⁰)与十六进制的 A~F 对应值
- 把 1011₂、110101₂、7E6₁₆ 按权展开算成十进制,写出每一步
- 把 25、100 用「除基取余倒读」转成二进制,标出余数读取方向
- 把 101110₂ 转成八进制与十六进制(注意三位/四位分组)
- 用「逐位翻倍」法验算一道二进制转十进制
- 默写二↔八=三位一组、二↔十六=四位一组,并说明哪里要补 0
- 把本日 52 道客观题做完,错题标记出来
数据编码:原码、反码、补码
①今日考情 · 真题分布与备考建议
本考点在 GESP C++ 3级近 14 期真题中共 23 道客观题(单选 12 / 判断 11,其中 0 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。
本期分布
| 期次 | 题数 |
|---|---|
| 2023年6月 C++ 3级 | 1 |
| 2024年12月 C++ 3级 | 4 |
| 2024年3月 C++ 3级 | 2 |
| 2024年6月 C++ 3级 | 3 |
| 2024年9月 C++ 3级 | 2 |
| 2025年3月 C++ 3级 | 3 |
| 2025年6月 C++ 3级 | 4 |
| 2025年9月 C++ 3级 | 1 |
| 2026年9月 C++ 3级 | 3 |
配套教材
GESP 大通关 3 级(全书 64 页):本天对应 3.2 数据编码(原码/反码/补码)。教材按同一套大纲顺序编排,可对照阅读。
备考建议(出题人视角)
原反补码是三级唯一的"负数表示"考点,题量不大但每年都考,而且几乎只考三件事:**负数的补码怎么求**、**8 位补码的范围 −128~127**、**补码运算后为什么结果正确**。记住口诀「正数三码相同;负数反码=符号位不变其余取反;补码=反码+1」,再记住 `−128` 这个特殊值没有原码和反码,就够用了。
②知识地图 · 本考点思维导图
- 正数(三码相同)
- +5 的 8 位:原码 = 反码 = 补码 = 0000 0101
- 负数(三步走)
- 原码:符号位 1 + 绝对值
- −5 → 1000 0101
- 反码:符号位不变,其余按位取反
- 1111 1010
- 补码:反码 + 1
- 1111 1011
- 补码转回真值
- 符号位为 1 → 再取反加一,读出绝对值
- 8 位补码范围
- −128 ~ 127(共 256 个)
- −128 没有原码和反码
- 为什么用补码
- 减法变加法,符号位一起参与运算,电路只做加法
③核心精讲
1. 为什么需要三种码
计算机里只有 0 和 1,没有"负号"。要表示负数,就用最高位当符号位 (0 表示正,1 表示负)。但直接用符号位算减法会出错,于是有了反码和补码。
2. 正数:三码相同
+5 的 8 位表示:
原码 = 反码 = 补码 = 0000 0101
3. 负数:三步走
以 −5 为例(8 位):
① 原码:符号位 1,其余是 5 的二进制
1000 0101
② 反码:符号位不变,其余按位取反(0→1,1→0)
1111 1010
③ 补码:反码 + 1
1111 1011
| 码 | −5 的 8 位表示 |
|---|---|
| 原码 | 1000 0101 |
| 反码 | 1111 1010 |
| 补码 | 1111 1011 |
易错:求反码时符号位不变,只把后面的数值位取反; 求补码是在反码基础上 +1,不是原码 +1。
4. 补码转回真值
看到符号位是 1 的补码,想知道它是多少:
补码 1111 1011
→ 再取反加一:0000 0100 + 1 = 0000 0101 = 5
→ 加上负号:−5
规律:补码的补码就是原码。
5. 8 位补码的表示范围
| 类型 | 范围 | 个数 |
|---|---|---|
| 8 位无符号 | 0 ~ 255 | 256 |
| 8 位原码 | −127 ~ 127 | 255(有 +0 和 −0) |
| 8 位补码 | −128 ~ 127 | 256 |
易错:补码比原码多表示一个 −128(
1000 0000), 它没有原码和反码。这也是"补码范围是 −128~127"而不是 −127~127 的原因。
6. 为什么用补码
- 减法可以变成加负数:
5 − 3 = 5 + (−3)。 - 符号位可以一起参与运算,不用单独判断。
- 电路只需要一个加法器,硬件简单。
验证:5 的补码 0000 0101 + (−3) 的补码 1111 1101 = 1 0000 0010,丢掉最高进位得 0000 0010 = 2,结果正确。
7. 一分钟记忆卡
- 正数三码相同
- 负数:原码(符号位 1)→ 反码(符号位不变,其余取反)→ 补码(反码+1)
- 补码的补码 = 原码
- 8 位补码范围 −128 ~ 127
- −128 没有原码和反码
- 补码让减法变加法,符号位一起算
- 1.A 在C++中,一个8位有符号整数(使用补码表示)的范围是( )…
- 2.B 数据编码方式只有原码、反码、补码三种。…
- 3.D 整数-5的16位补码表示是( )。…
- 4.A 补码的优点是可以将减法运算转化为加法运算,从而简化计算机的硬件设计。…
- 5.A +1和-1的原码进行1+(-1)计算的结果是-2。( )…
- 6.A 为了简化计算机基本运算电路,使加减法都只需要通过加法电路实现,也就是…
- 7.A 使用原码进行的计算,2+(-1) 的结果是 -3…
- 8.A 反码计算加减法:加法与减法结果都是正确的,只是解决不了 -0 的问题…
- 9.B 在C++中,补码的主要作用是( )…
- 10.B 反码表示中,零的表示形式有:…
#include <iostream>
using namespace std;
int main() {
int arr[10] = {125, 127, 136, 134, 137, 138, 126, 135, 140, 145};
int count = 0;
for(int i=0; i<10; i++)
__________________________ // 在此处填入代码
cout << count << endl;
return 0;
}- 11.A 补码 1011 1011 对应的真值是( )…
- 12.B 补码加法中,若符号位⽆进位⽽次⾼位有进位,则说 明( )…
- 13.B 对于计算机编码运算,补码做加法运算时,如果最高位产生进位,需要把该进…
- 14.A 8位二进制原码能表示的最小整数是:( )…
- 15.B 一个 8 位二进制原码表示的有符号数,可表示的数值范围是 −128 …
- 16.B 某小学男子篮球队招募新成员,要求加入球队的成员身高在135厘米以上(…
- 17.B 在C++中,char 类型的取值范围总是 -128 到 127。…
- 18.C 关于计算机中的编码,下列说法中正确的是( )…
- 19.B 补码1111 1101进行运算1111 1101>>1以后得到的结果…
- 20.B 任意整数a 的二进制反码与补码都有1位不同。 ( )…
- 21.A 整数-6的16位补码可用十六进制表示为FFFA。…
- 22.A 在 8 位二进制原码表示中,八进制数 -5 的二进制形式是什么( )…
- 23.D 关于计算机的数据编码,下面说法不正确的是( )。…
④今日打卡 · 点一下就能勾选
- 写出 +5 与 −5 的 8 位原码、反码、补码,各三步
- 默写负数求补码的口诀:符号位不变取反得反码,反码 +1 得补码
- 把补码 1111 1011 还原成真值,说明「补码的补码是原码」
- 默写 8 位无符号、原码、补码三种表示范围,指出为什么补码多一个数
- 解释 −128 为什么没有原码和反码
- 用 5 − 3 的补码加法验证「减法变加法」
- 把本日 23 道客观题做完,错题标记出来
位运算
①今日考情 · 真题分布与备考建议
本考点在 GESP C++ 3级近 14 期真题中共 52 道客观题(单选 30 / 判断 22,其中 0 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。
本期分布
| 期次 | 题数 |
|---|---|
| 2023年12月 C++ 3级 | 3 |
| 2023年6月 C++ 3级 | 3 |
| 2023年9月 C++ 3级 | 5 |
| 2024年12月 C++ 3级 | 5 |
| 2024年3月 C++ 3级 | 5 |
| 2024年6月 C++ 3级 | 3 |
| 2024年9月 C++ 3级 | 7 |
| 2025年12月 C++ 3级 | 6 |
| 2025年3月 C++ 3级 | 2 |
| 2025年6月 C++ 3级 | 4 |
| 2026年3月 C++ 3级 | 3 |
| 2026年9月 C++ 3级 | 6 |
配套教材
GESP 大通关 3 级(全书 64 页):本天对应 3.3 位运算。教材按同一套大纲顺序编排,可对照阅读。
备考建议(出题人视角)
位运算是三级的重点且是四级的伏笔,命题人喜欢把位运算和二进制理解绑在一起考。必背五条:`x & 1` 判奇偶、`x << k` 等于乘 2ᵏ、`x >> k` 等于整除 2ᵏ、`x ^ x = 0`、`x & (x-1)` 消掉最低位的 1。特别提醒:**`&&` 和 `&` 完全是两回事**,`~0` 是 −1 不是 0。
②知识地图 · 本考点思维导图
- 六个运算符
- & 按位与:两位都是 1 才得 1
- | 按位或:有 1 就得 1
- ^ 按位异或:不同得 1,相同得 0
- ~ 按位取反:0→1,1→0(~0 = −1)
- << 左移:低位补 0,等于乘 2ᵏ
- >> 右移:高位补符号位,等于整除 2ᵏ
- 五个必背技巧
- x & 1 判奇偶(1 奇 0 偶)
- x << k = x × 2ᵏ
- x >> k = x ÷ 2ᵏ(向下取整)
- x ^ x = 0 x ^ 0 = x 异或可用来交换
- x & (x−1) 消掉最低位的 1
- 与二进制的关系
- 位运算就是直接对二进制每一位动手
- 常见陷阱
- && 是逻辑与、& 是位运算,不能混
- ~0 = −1(不是 0,也不是 1)
- 左移溢出会变号
③核心精讲
1. 六个运算符
| 运算符 | 名称 | 规则 | 例子(4 位) | ||
|---|---|---|---|---|---|
& | 按位与 | 都为 1 才 1 | 1010 & 1100 = 1000 | ||
| `\ | ` | 按位或 | 有 1 就 1 | `1010 \ | 1100 = 1110` |
^ | 按位异或 | 不同得 1 | 1010 ^ 1100 = 0110 | ||
~ | 按位取反 | 0→1,1→0 | ~1010 = 0101 | ||
<< | 左移 | 右边补 0 | 1011 << 1 = 10110 | ||
>> | 右移 | 左边补符号位 | 1011 >> 1 = 0101 |
易错:
^是不同才得 1(不是"都是 1 才得 1")。&&/||是逻辑运算,&/|才是位运算,两者结果不同。
2. 五个必背技巧
① 判奇偶
if (x & 1) cout << "奇数"; // 末位是 1 → 奇数
else cout << "偶数";
② 移位等于乘除 2 的幂
x << 1 // x × 2
x << 3 // x × 8 (2³)
x >> 1 // x ÷ 2
x >> 3 // x ÷ 8
③ 异或的三条性质
x ^ x = 0 // 自己异或自己得 0
x ^ 0 = x // 异或 0 不变
a ^ b ^ a = b // 可以"消掉"重复出现的数
④ 消掉最低位的 1
x & (x - 1) // 把 x 二进制里最右边的 1 变成 0
// 例:12 = 1100 → 1100 & 1011 = 1000 = 8
⑤ lowbit:取出最低位的 1
x & (-x) // 只保留最低位的那个 1
// 例:12 = 1100 → 1100 & 0100 = 0100 = 4
3. ~0 为什么等于 −1
在补码表示里,0 是全 0,取反后是全 1,而全 1 正是 −1 的补码。
~0 // -1
~1 // -2
!0 // 1 ← 注意 ! 是逻辑非,结果只有 0/1
!5 // 0
易错:
~是按位取反(结果可以是负数),!是逻辑非(结果只有 0/1)。
4. 移位与溢出
int x = 1;
x << 31; // 变成负数(符号位被置 1)
21 << 1; // 42
21 >> 1; // 10(整除)
右移是向下取整:-7 >> 1 得 −4,不是 −3。
5. 位运算的典型用途
| 用途 | 写法 |
|---|---|
| 判奇偶 | x & 1 |
| 乘除 2 的幂 | x << k / x >> k |
| 判断是不是 2 的幂 | x > 0 && (x & (x-1)) == 0 |
| 统计二进制里 1 的个数 | 循环 x &= x-1 计数 |
| 不借第三个变量交换 | a ^= b; b ^= a; a ^= b; |
6. 一分钟记忆卡
&与、\|或、^异或(不同才 1)、~取反、<<左移、>>右移x & 1判奇偶;x << k乘 2ᵏ;x >> k除 2ᵏx ^ x = 0,x ^ 0 = xx & (x-1)消最低位 1;x & (-x)取最低位 1~0 = -1;&&≠&
明a 在从0 到3 之间(可能为0、可能为3)。
- 1.D 一个int 类型的值,做以下哪个操作,一定会变回原来的值?( )…
- 2.A 在C++语言中,位运算符也有类似“先乘除、后加减”的优先级规则。因此…
- 3.A 在C++语言中,所有int 类型的值,经过若干次左移操作(<<)后,…
- 4.A 以下哪个位运算可以交换两个变量的值(无需临时变量)( )…
- 5.B 位运算符 &、|、^、~ 的优先级高于算术运算符 +、-、*、/。…
- 6.A 在 C++ 位运算中,各种不同的运算符有优先级的区分,使用括号能够解…
- 7.D 下面选项中提到的变量都是正整数,关于位运算,下面说法错误的是( )。…
- 8.A 如果a 为int 类型的变量,下列哪个表达式可以正确求出满足“小于等…
- 9.A 如果a 为int 类型的变量,且表达式((a | 3) == 3)的…
- 10.A 如果a 是int 类型的变量,下列哪个表达式的值一定为true?( …
int main()
{
cout << (3|16) << endl;
cout << endl;
return 0;
}- 11.B 如果a 和b 均为int 类型的变量,下列表达式不能正确判断“a 等…
- 12.A 如果a 为int 类型的变量,且表达式((a & 1) == 0) …
- 13.C 32位计算机中,C++的整型变量int能够表示的数据范围是( )。…
- 14.A 执行C++代码cout<<(5&&2)<<endl; 后将输出1。(…
- 15.A 执行C++代码cout<<(5||2); 后将输出1。( )…
- 16.C 下面C++代码执行后的输出是( )。…
- 17.B 定义整数int x=-5,则执行C++代码cout << (x ==…
- 18.B 对整型变量int a = 3,执行C++代码a<<2 将把2输出到a…
- 19.B 一个int 类型变量a,执行操作(a<<2>>2) 后的值一定是a。…
- 20.B 在C++语言中,(010<<1) 执行结果是100。( )…
#include <iostream>
using namespace std;
int main() {
int a = 12;
int result = a >> 2;
cout << result << endl;
return 0;
}- 21.C 一般默认64位计算机系统中整型变量(int)还是32位,则整数能够表…
- 22.C 下列代码的输出结果是( )。…
- 23.A 如果a为int 类型的变量,且表达式((a | 3) == 3) 的…
- 24.C 下面说法正确的是( )…
- 25.C a&~1运算实现的是( )。…
- 26.A a=1010 1110,a<<2,下面关于这个说法正确的是( )。…
- 27.A ~1 的输出值是-2。( )…
- 28.A ~1 = 1111 1110。( )…
- 29.D 下面逻辑运算中,正确的是( )…
- 30.D 兔子五元一只,鸡三元一只,小鸭子一元三只,现在你有一百元要买一百只,…
{
int sum = 0;
for (int i = 1; i <= 10; i++) {
if (i % 3 == 8>>2)
continue;
sum += i;
}
}int arr[5] = {2, 4, 6, 8, 10};
int sum = 0;
for (int i = 0; i < 5; i++) {
switch (arr[i] % (1|2)) {
case 0: sum += 1; break;
case 1: sum += 2; break;
case 2: sum += 3; break;
}
}char x='1'; int y=1;
- 31.C 求小于等于N的素数的方法中,有一种方法是将所有从2到它本身减1的数都…
- 32.B x 是浮点数,(x >> 1) 等价于 x / 2…
- 33.A (x & 1) == 0 可以判断整数x 是否为偶数。…
- 34.D 下列代码段执行后,变量 sum 的值是( )…
- 35.A 在一个特定的计算机系统中,假如 unsigned int 类型需要占…
- 36.B 以下代码运行后,sum 的结果是( )…
- 37.B 补码的情况下,关于按位取反运算,用笔计算的情况下,以下说法错误的是:…
- 38.B 由于在 0~255 范围内,char 类型和 int 类型可以互换,…
- 39.D 计算 3 & 7 | 15 ^ ~11 (a=3, b=7, c=1…
- 40.B a 是 int 有符号整型,若 (a & 1) == 1 结果为 t…
void Swap(int &a, int &b) {
if (a != b) {
a ^= b;
b ^= a;
a ^= b;
}
}char x=65; x=x&00001111; cout<<x<<endl;
int main()
{
char x;
scanf("%c", &x);
int ASCII = (int)x;
cout << (x & 1 ? "YES" : "NO") << '\n';
return 0;
}int x = 5; if (x == 3 >> 2) x = 8 >> 3; cout << x << endl;
#include <iostream>
using namespace std;
int main() {
int a = 0b1101;
int b = 0b1011;
cout << (a ^ b);
return 0;
}- 41.C 下列代码实现的是( )…
- 42.B 下列说法正确的是( )…
- 43.A 下列程序输出的是 A…
- 44.A 这段程序进行的是判断一个从键盘输入的字符的ASCII 是否是奇数,若…
- 45.B 执行以下程序段,输出值是( )…
- 46.D 以下代码的说法正确的是什么( )…
- 47.C 关于位运算,下列说法错误的是( )。…
- 48.D 关于计算机中的编码,下列说法中错误的是( )…
- 49.A 若X的8位补码为 0000 1010,则 X/2 的补码是( )。…
- 50.A 给定一个正整数 a,当需要计算 -a 的补码时,有这样一个计算技巧:…
- 51.C 关于计算机编码中补码,下面说法错误的是( )。…
- 52.B 求 −13 的补码,可以对正数 13 的二进制,从右向左扫描,遇到第…
④今日打卡 · 点一下就能勾选
- 默写六个位运算符的名称与规则,各用 4 位二进制举一例
- 算出 x & 1、x << 3、x >> 2 在 x=12 时的值
- 背下异或三条性质,并说明「a^b^a = b」怎么用来找出只出现一次的数
- 手算 x & (x−1) 与 x & (−x) 在 x=12 时的结果
- 解释 ~0 为什么等于 −1,以及 ~ 与 ! 的区别
- 说清 && 与 & 的区别,各写一行代码
- 把本日 52 道客观题做完,错题标记出来
一维数组
①今日考情 · 真题分布与备考建议
本考点在 GESP C++ 3级近 14 期真题中共 35 道客观题(单选 19 / 判断 16,其中 1 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。
本期分布
| 期次 | 题数 |
|---|---|
| 2023年12月 C++ 3级 | 1 |
| 2023年6月 C++ 3级 | 5 |
| 2023年9月 C++ 3级 | 7 |
| 2024年3月 C++ 3级 | 4 |
| 2024年6月 C++ 3级 | 2 |
| 2024年9月 C++ 3级 | 1 |
| 2025年12月 C++ 3级 | 4 |
| 2025年3月 C++ 3级 | 1 |
| 2025年6月 C++ 3级 | 2 |
| 2025年9月 C++ 3级 | 3 |
| 2026年3月 C++ 3级 | 2 |
| 2026年9月 C++ 3级 | 3 |
配套教材
GESP 大通关 3 级(全书 64 页):本天对应 3.4 一维数组。教材按同一套大纲顺序编排,可对照阅读。
备考建议(出题人视角)
一维数组是三级分值最重的一块,考法有两类:**数组的定义与越界**(概念题)和**数组的遍历推演**(读程序题)。读程序题的坑集中在三处:下标从 0 起、`a[a[i]]` 这种套索引、循环上界写成 `<=n` 导致越界。建议所有数组题一律**先画出下标与值的对应表**再动手。
②知识地图 · 本考点思维导图
- 定义与初始化
- int a[10]; 下标 0 ~ 9(没有 a[10])
- int a[5] = {1,2,3}; 后面自动补 0
- 全局数组默认 0,局部数组是随机值
- 下标与越界
- 合法下标:0 ~ n−1
- a[n] 越界,**编译不报错但结果不可预测**
- 数组长度:sizeof(a)/sizeof(a[0])
- 四种基本遍历
- 求和 / 求平均
- 求最大值及其下标
- 计数(满足条件的个数)
- 查找(顺序查找)
- 常用技巧
- 桶计数:cnt[x]++ 统计出现次数
- 套索引:a[b[i]] 先算内层再算外层
- 前缀和:s[i] = s[i-1] + a[i]
- 常见陷阱
- for(i=1;i<=n;i++) 配 a[1..n] 要一致
- 局部数组未初始化直接用
③核心精讲
1. 定义、初始化与下标
int a[10]; // 10 个元素,下标 0~9
int b[5] = {1, 2, 3}; // 前 3 个赋值,后 2 个自动为 0
int c[] = {4, 5, 6}; // 长度自动推出为 3
下标从 0 开始,合法范围是 0 ~ n-1。a[10] 是第 11 个,越界。
| 写法 | 含义 |
|---|---|
a[0] | 第 1 个元素 |
a[n-1] | 第 n 个(最后一个) |
a[n] | 越界,非法 |
易错:局部数组不初始化是随机值,全局数组默认是 0。 越界访问编译不报错,运行时结果不可预测——这是最危险的一类错。
2. 数组长度怎么求
int a[10];
int n = sizeof(a) / sizeof(a[0]); // 10
sizeof(a) 是整个数组的字节数(10×4=40),sizeof(a[0]) 是一个元素的字节数(4)。
易错:
sizeof得到的是字节数,不是元素个数;要除一下。
3. 四种基本遍历
求和 / 求平均
int s = 0;
for (int i = 0; i < n; i++) s += a[i];
double avg = (double)s / n;
求最大值与下标
int mx = a[0], pos = 0;
for (int i = 1; i < n; i++)
if (a[i] > mx) { mx = a[i]; pos = i; }
计数
int cnt = 0;
for (int i = 0; i < n; i++)
if (a[i] % 2 == 0) cnt++; // 偶数个数
顺序查找
int pos = -1;
for (int i = 0; i < n; i++)
if (a[i] == x) { pos = i; break; }
4. 两个高频技巧
① 桶计数(统计每个数出现几次)
int cnt[101] = {0};
for (int i = 0; i < n; i++) cnt[a[i]]++; // a[i] 在 0~100
② 套索引 a[b[i]]
// 先算里面那层 b[i],再把结果当下标
// b = {2, 0, 1}, a = {10, 20, 30}
// a[b[0]] = a[2] = 30
// a[b[1]] = a[0] = 10
// a[b[2]] = a[1] = 20
易错:
a[b[i]]一定先算b[i],不能从外往里读。
5. 前缀和(后面很多题的伏笔)
int s[105];
s[0] = 0;
for (int i = 1; i <= n; i++) s[i] = s[i-1] + a[i];
// 区间 [l, r] 的和 = s[r] - s[l-1]
6. 一分钟记忆卡
- 下标 0 ~ n−1,
a[n]越界,越界不报错 - 局部数组随机值,全局数组为 0
- 长度 =
sizeof(a)/sizeof(a[0]) - 求最大值:初值取
a[0],从 i=1 开始比 a[b[i]]先算内层- 桶计数
cnt[x]++,前缀和s[i]=s[i-1]+a[i]
- 1.C 关于一维数组,下列程序能够正确执行的是( )。…
- 2.C 以下关于标准 C++ 一维数组的描述,哪一项是错误的?( )…
- 3.B 以下数组定义,符合C++语言语法的是( )。…
- 4.B 在C++语言中,长度为n 的数组,合理的下标范围是从0 到n,包括0…
- 5.A 在C++语言中,数组被定义时,它的大小就确定了。…
- 6.A 如果数组定义为long long array[] = {3, 5, …
- 7.B 以下数组定义,符合C++语言语法的是( )。…
- 8.B 在C++语言中,长度为n的数组,访问下标为n的元素会引起编译错误。…
- 9.B 在C++语言中,数组下标的大小决定元素在逻辑上的先后顺序,与元素在内…
- 10.C 下面C++数组的定义中,会丢失数据的是( )。…
int main()
{
int a[20],i;
for(i = 0; i < 20; i++)
a[i] = i+1;
for(int i = 0; i < 20; i++)
if((a[i]%2)&&(a[i]%3))
a[i] = 0;
for(i = 0; i < 20; i++)
if(a[i])
cout << a[i] << " ";
cout << endl;
return 0;
}int main()
{
int a[20],i;
int cnt=0;
for(i = 0; i < 20; i++)
a[i] = i+1;
for( ; i > 1; i--)
if((a[i-1]+a[i-2])%3)
cnt++;
cout << cnt << endl;
cout << endl;
return 0;
}#include <iostream>
using namespace std;
int main() {
int arr[] = {1, 2, 3, 4, 5};
int left = 0, right = 4;
while (left < right) {
while (arr[left] % 2 == 1 && left < right) left++;
————————————————————————————————————————————————————
if (left < right) {
swap(arr[left], arr[right]);
}
}
for (int i = 0; i < 5; i++) {
cout << arr[i] << " ";
}
return 0;
}int arr[4] = {1, 2, 3};
arr[3] = arr[0] + arr[2];- 11.C 下面C++代码执行后数组中大于0的数的特征是( )。…
- 12.D 下面C++程序执行的结果是( )。…
- 13.A 对定义的数组int a[7]={2,0,2,4,3,1,6},可以用…
- 14.B 数组的所有元素在内存中可以不连续存放。…
- 15.B C++中可以对数组和数组的每个基础类型的元素赋值。…
- 16.D 以下代码的功能是将数组中的奇数和偶数分别放在数组的前半部分和后半部分…
- 17.D 如何正确定义一个长度为5的整型数组( )…
- 18.B sort 可以直接用于排序set 中的元素。…
- 19.D 以下关于C++数组的说法,错误的是( )。…
- 20.B 执行以下C++代码后,数组 arr 的内容是( )。…
int arr[6] = {1, 2, 3, 4, 5, 6};
for (int i = 0; i < 6; i += 2) {
arr[i] = arr[i] + arr[i+1];
arr[i+1] = arr[i] - arr[i+1];
arr[i] = arr[i] - arr[i+1];
}int a[] = {2, -5, 7, 0, -1};
int n = sizeof(a) / sizeof(a[0]);
for (int num : a) {
if (num > 0) {
num = 0;
}
}- 21.A 以下代码执行后,数组 arr 的内容是( )…
- 22.A 在 C++ 中,数组名不能改变,数组名不能被赋值。…
- 23.A 在 C++ 中,int a[] = {1, 2, 3, 4, 5};…
- 24.B 定义 int arr[5] = {1,2,3};,则 arr[3] …
- 25.B 定义 double arr[10];,未手动初始化时,数组中所有元素…
- 26.B 以下数组定义,符合 C++ 语法的是( )…
- 27.B 这段代码执行后,能够将数组中所有大于 0 的元素赋值为 0。…
- 28.A 一个数组定义为double array[3];,则这个数组占用内存的…
- 29.A 一个数组定义为double array[3];,则可合理访问这个数组…
- 30.B 在C++语言中,定义数组时,[] 中必须指定元素个数。…
int main()
{
int a[20],i;
for(i = 0; i < 20; i++)
a[i] = i+1;
for( ; i > 0; i--)
cout << a[i-1] << " ";
cout << endl;
return 0;
}#include <iostream>
using namespace std;
int findMax(int arr[], int size) {
int maxVal = ________; // 划线处
for (int i = 1; i < size; i++) {
if (arr[i] > maxVal) {
maxVal = arr[i];
}
}
return maxVal;
}- 31.A 执行下面C++代码后输出的第一个数是( )。…
- 32.A 在C++语言中,可以使用字符(如'0')作为数组下标。…
- 33.C 以下C++代码试图查找数组中的最大值,划线处应填入( )。…
- 34.B 下面流程图逻辑:初始化 sum ← 0,i ← 0;当 i < n …
- 35.C 下列关于C++语言中数组的叙述,不正确的是( )。…
④今日打卡 · 点一下就能勾选
- 默写一维数组的定义方式,写出 a[10] 的合法下标范围
- 说明局部数组与全局数组初始化后的默认值差别,解释越界为什么不报错
- 写出求数组最大值及其下标的完整代码(初值怎么取)
- 用 sizeof 求数组元素个数,并说明为什么要除以 sizeof(a[0])
- 手算 a[b[i]] 的结果(b={2,0,1},a={10,20,30}),说明计算顺序
- 写出桶计数与一维前缀和的代码各 3 行
- 把本日 35 道客观题做完,错题标记出来
字符串及其函数
①今日考情 · 真题分布与备考建议
本考点在 GESP C++ 3级近 14 期真题中共 48 道客观题(单选 33 / 判断 15,其中 3 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。
本期分布
| 期次 | 题数 |
|---|---|
| 2023年12月 C++ 3级 | 4 |
| 2023年6月 C++ 3级 | 3 |
| 2023年9月 C++ 3级 | 1 |
| 2024年12月 C++ 3级 | 5 |
| 2024年3月 C++ 3级 | 6 |
| 2024年6月 C++ 3级 | 4 |
| 2024年9月 C++ 3级 | 2 |
| 2025年12月 C++ 3级 | 3 |
| 2025年3月 C++ 3级 | 3 |
| 2025年6月 C++ 3级 | 7 |
| 2025年9月 C++ 3级 | 2 |
| 2026年3月 C++ 3级 | 5 |
| 2026年9月 C++ 3级 | 3 |
配套教材
GESP 大通关 3 级(全书 64 页):本天对应 3.5 字符串及其函数。教材按同一套大纲顺序编排,可对照阅读。
备考建议(出题人视角)
字符串在三级同时考"概念"和"读程序"。概念题考 `strlen` 与 `sizeof` 的区别、`\0` 结尾、字符数组与 string 的差异;读程序题考**逐字符变换**(大小写互换、数字加 3、回绕)。最高频的坑是:`cin >>` 遇空格就停、`strlen` 不算 `\0` 但 `sizeof` 算、字母位移越界要回绕 26。
②知识地图 · 本考点思维导图
- 两种字符串
- char 数组:char s[20] = "abc"; 以 '\0' 结尾
- string 类型:string s; 更安全,支持 + 与比较
- 长度
- strlen(s) 字符个数,**不含 '\0'**
- sizeof(s) 数组占的字节数,**含 '\0'**
- s.length() / s.size() string 的长度
- 常用函数
- strcpy(a, b) 复制 strcat(a, b) 拼接
- strcmp(a, b) 比较(返回 0 表示相等)
- s.substr(pos, len) 取子串 s.find(t) 查找
- 遍历与字符变换
- for (i=0; i<s.length(); i++)
- 大小写互换:±32
- 位移回绕:字母 −26、数字 −10
- 常见陷阱
- cin >> 遇空格停(要 getline)
- strlen ≠ sizeof
- 子串 n(n+1)/2 个
③核心精讲
1. 两种字符串
| char 数组 | string 类型 | |
|---|---|---|
| 定义 | char s[20] = "abc"; | string s = "abc"; |
| 结尾 | 自动补 '\0' | 不需要 |
| 长度 | strlen(s) | s.length() |
| 赋值 | 要用 strcpy | 直接 = |
| 拼接 | 要用 strcat | 直接 + |
| 比较 | 要用 strcmp | 直接 > < |
2. strlen 与 sizeof 的区别(必考)
char s[20] = "abc";
strlen(s) // 3 字符个数,不含 '\0'
sizeof(s) // 20 整个数组的字节数
易错:
strlen不算'\0',sizeof算整个数组。 对于char s[] = "abc";,sizeof(s)是 4(3 个字符 + 1 个'\0')。
3. 常用函数
| 函数 | 作用 | 例子 |
|---|---|---|
strcpy(a, b) | 把 b 复制到 a | strcpy(a, "hi") |
strcat(a, b) | 把 b 接到 a 后面 | strcat(a, "!") |
strcmp(a, b) | 比较,相等返回 0 | strcmp("a","b") < 0 |
s.substr(pos, len) | 从 pos 起取 len 个 | "hello".substr(1,3) = "ell" |
s.find(t) | 找 t 首次出现位置 | 找不到返回 string::npos |
字典序:逐字符比 ASCII 码,'A'(65) < 'a'(97),所以 "Apple" < "apple"。
4. 逐字符遍历与变换
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] >= 'a' && s[i] <= 'z') s[i] = s[i] - 32; // 转大写
else if (s[i] >= 'A' && s[i] <= 'Z') s[i] = s[i] + 32; // 转小写
}
位移必须回绕:
// 字母后移 3 位,超过 'z' 要回到 'a'
if (s[i] + 3 > 'z') s[i] = s[i] + 3 - 26;
else s[i] = s[i] + 3;
// 数字后移 3 位,超过 '9' 要回到 '0'
if (s[i] + 3 > '9') s[i] = s[i] + 3 - 10;
else s[i] = s[i] + 3;
易错:忘记回绕 ——
'z' + 3会跑到符号区,不是'c'。
5. 子串与子序列
| 名称 | 含义 | 例子("abcd") |
|---|---|---|
| 子串 | 连续的一段 | "ab"、"bc"、"bcd" |
| 子序列 | 不要求连续,保序 | "ac"、"bd" |
长度 n 的字符串,子串个数 = n(n+1)/2(不含空串),加空串是 n(n+1)/2 + 1。 子序列有 2ⁿ 个。
6. 一分钟记忆卡
strlen不含'\0',sizeof是整个数组strcmp相等返回 0- 大小写差 32;
'a'-'A' = 32 - 位移越界要回绕:字母 −26,数字 −10
cin >>遇空格停 → 用getline- 子串 n(n+1)/2 个,子序列 2ⁿ 个
int main()
{
string str="gEsP is Interesting !";
int x = str.length();
int nwords = 0;
for(int i = 0; i < x; i++)
if (str[i]==' '){
nwords++;
while(str[++i]==' ') ;
}
cout << nwords << endl;
cout << endl;
return 0;
}int main()
{
string str="gEsP is Interesting";
int x = str.find("s");
cout << x << endl;
cout << endl;
return 0;
}#include <iostream>
using namespace std;
int main() {
string str = "gesp.ccf.org.cn";
string delimiter = ".";
string result="";
string token;
size_t found = str.find(delimiter);
while (found != string::npos) {
token = str.substr(0, found);
result += token;
result += " ";
__________________________ // 在此处填入代码
found = str.find(delimiter);
}
//最后一部分
result += str;
result += " ";
cout << result << endl;
return 0;
}char ch[] = "hello world"; size_t ret=strlen(ch); cout<<ret<<endl;
#include <iostream>
#include <string>
using namespace std;
int main() {
string str = "HelloC++";
_________________
_________________
return 0;
}- 1.A 字符常量'\0'常用来表示字符串结束,它和字符常量'0'是不同的。…
- 2.A C++代码用于抽取字符串中的电话号码。约定:电话号码全部是数字,数字…
- 3.C 假设英文句子由若干词构成。下面C++代码统计输出的词数是( )。…
- 4.A 执行下面C++代码后将输出2。( )…
- 5.A 如果执行下面C++代码后,输出的结果是“gesp ccf org c…
- 6.B 字符常量'\0'常用来表示字符串结束,和字符常量'0'相同。…
- 7.D 下列程序中,假设一个字符占用的内存空间是1,下列程序中,ch占用的内…
- 8.D Base64 编码将每3字节的输入数据编码为 4 字节的输出数据。如…
- 9.D 想要得到字符串world ,下面程序横线处应该填入的是( )…
- 10.C C++语句string s="Gesp Test"; 执行s.rfi…
for (int i = 0; i < s.length(); i++) {
s[i] = toupper(s[i] + i);
}#include <iostream>
#include <string>
using namespace std;
int main() {
int key;
cin >> key;
string msg = "Hello GESP";
cout << msg << endl;
for (int i = 0; i < msg.size(); i++) {
msg[i] = msg[i] ^ key;
}
cout << msg << endl;
_________________________________
cout << msg << endl;
return 0;
}string s="1234@@chenadai"; string str="12345"; s.replace(1,5,str); cout<<s<<endl;
string ch="chen"; cout<<ch[4]<<endl;
- 11.C 字符串"Gesp考试",字符数是( )…
- 12.B C++中string 的== 运算符比较的是字符串的内存地址,而非内…
- 13.B string 的substr(2, 10) 在字符串长度不足时会抛出…
- 14.D 如果字符串 s 的值是 GESP,以下代码 s 的最后结果是( )…
- 15.C 下面函数是一个加密解密的函数,横线处应该填入的程序段是( )。…
- 16.B 判断字符串中字符是否是 '0' 或者 '1',可以写条件:if(st…
- 17.C 下面C++代码执行后不能输出"GESP"的是( )。…
- 18.A 执行下面C++代码后输出的是( )。…
- 19.C 下列代码输出的是…
- 20.B 该段程序将不能正确执行…
int main() {
string str = "HelloWorld";
___________________
cout << str;
return 0;
}string str = "GESP2026"; string sub = str.substr(4, 2);
char s[10] = "abcde"; int a = sizeof(s) / sizeof(s[0]); int b = strlen(s); cout << a - b;
int main()
{
string str="gEsP is Interesting";
int x = str.length();
for(int i = 0; i < x; i++)
if ((str[i]>='a') && (str[i]<='z'))
________________________;
cout << str << endl;
cout << endl;
return 0;
}string str = "Hello,CHAD";
cout << str.find("A") << '\n';string str="CHADai";
size_t pos = str.find('D');
cout<<pos<<endl;string str="chenADai";
int pos = str.find('D');
--pos&11;- 21.B 下面程序最后能够得到HelloC++ 的是( )…
- 22.D C++代码string s = "GESP考试";,s占据的字节数是…
- 23.A string("hello") == "hello" 的比较结果为t…
- 24.B strcmp(str1, str2) 返回 0 表示 str1 大于…
- 25.A 执行以下 C++ 代码后,sub 的值是( )。…
- 26.B 执行以下代码后,输出结果是:( )。…
- 27.C 在下列代码的横线处填写( ),可以使得输出是GESP IS INTE…
- 28.B 下列程序输出的是( )…
- 29.A 下列程序输出的是3。( )…
- 30.A 下列可执行程序段中,最后 pos 的值是 4…
cout << (int)(s.length() | 3) << endl;
- 31.B 已知字符串 s = "C++ Programming",下列程序运行…
- 32.C 如果字符串定义为char str[] = "Hello";,则字符数…
- 33.C 下列关于C++语言中数组的叙述,不正确的是( )。…
- 34.B 字符常量'3' 的值和int 类型常量3 的值是相同的,只是占用的字…
- 35.C 下面C++代码用于统计每种字符出现的次数,当输出为3时,横线上不能填…
- 36.A 定义字符数组char str[20] = {'G', 'E', 'S…
- 37.B 在C++语言中,字符数组被定义时,它的大小可以调整。( )…
- 38.C 如果字符串定义为char str[] = "GESP";,则字符数组…
- 39.A string 的substr(1, 3) 返回从下标1开始的3个字符…
- 40.D 以下关于C++中 string 类和字符数组( char[] )的说…
char str1[] = "Hello";
char str2[] ={'H','e','l','l','0'};for (int i = 0; i < str.length(); i++) {
// 需补充条件:
_______________________
else {
str[i] += 3;
}
}string ch="hello";
if(ch[5]==NULL)
{
cout<<"right"<<endl;
}
else if (ch[5]=='\0')
{
cout<<"wrong"<<endl;
}
else
{
cout<<"hello"<<endl;
}int main()
{
string s="316";
int n=s.length();
int x=0;
for(int i = 0; i < n; i++)
x += s[i];
cout << x << endl;
cout << endl;
return 0;
}#include <iostream>
using namespace std;
int main() {
string s = "0629";
int n = s.length();
int x = 0;
for(int i = 0; i < n; i++)
x += s[i];
cout << x << endl;
return 0;
}- 41.B 表达式 sizeof('a') 的结果总是 1,因为 'a' 是一个…
- 42.C 如果字符变量_1 的值是字符1 ,那么(int)_1 的值是?( )…
- 43.C 关于下列正确的程序段,说法正确的是( )。这段程序多次执行将输出不同…
- 44.D 模拟 “字符串加密”:规则为 “每个字符 ASCII 码 + 3,若…
- 45.D 关于 string 的成员函数,下面说法错误的是( )…
- 46.A 下列程序输出的是( )…
- 47.C 已知字符'0' 的ASCII编码的十进制表示为48,则执行下面C++…
- 48.C 已知字符 '0' 的ASCII编码的十进制表示为48,则执行下面C+…
④今日打卡 · 点一下就能勾选
- 对比 char 数组与 string 的四处差异(定义/长度/拼接/比较)
- 算 char s[20]="abc" 的 strlen 与 sizeof,解释为什么一个 3 一个 20
- 写出大小写互换的循环代码,并说明为什么用 32
- 写字母后移 3 位并回绕的代码,解释为什么减 26
- 说明 strcmp 相等时的返回值,以及 "Apple" 与 "apple" 谁大
- 默写子串个数公式 n(n+1)/2,说明子串与子序列的区别
- 把本日 48 道客观题做完,错题标记出来
枚举法
①今日考情 · 真题分布与备考建议
本考点在 GESP C++ 3级近 14 期真题中共 35 道客观题(单选 15 / 判断 20,其中 0 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。
本期分布
| 期次 | 题数 |
|---|---|
| 2023年9月 C++ 3级 | 1 |
| 2024年12月 C++ 3级 | 1 |
| 2024年3月 C++ 3级 | 1 |
| 2024年6月 C++ 3级 | 1 |
| 2025年12月 C++ 3级 | 8 |
| 2025年3月 C++ 3级 | 1 |
| 2025年6月 C++ 3级 | 2 |
| 2025年9月 C++ 3级 | 9 |
| 2026年3月 C++ 3级 | 6 |
| 2026年9月 C++ 3级 | 5 |
配套教材
GESP 大通关 3 级(全书 64 页):本天对应 3.6 枚举法。教材按同一套大纲顺序编排,可对照阅读。
备考建议(出题人视角)
三级的枚举比二级要求高一层:不只是两重循环,还要会**定范围**和**去重**。命题人常给一个"有多少种方案"的题,答案选项是差一的两个数,就是考你的边界取没取对。练法:每道枚举题都先写清"枚举什么""从几到几""条件是什么"三句话,再写代码。
②知识地图 · 本考点思维导图
- 三步定式
- ① 枚举什么:确定要试的变量
- ② 范围多少:从题目上下界推,宁紧勿松
- ③ 什么条件:把要求翻译成 if
- 单重枚举
- 一个变量穷举(找约数、判质数、找满足条件的数)
- 多重枚举
- 两重:百钱百鸡、两数之和
- 三重:三个数凑成定值(注意去重)
- 枚举优化
- 用关系式消掉一层循环
- 缩小范围(如 j 从 i 开始,避免重复)
- 提前 break(找到就停)
- 常见陷阱
- 边界取错(< 还是 <=)
- 重复计数((a,b) 与 (b,a) 算两次)
- 忘记排除不合法的解
③核心精讲
1. 枚举的三步定式
拿到枚举题,先在草稿上写三句话:
① 枚举什么?(哪个变量要一一试)
② 范围多少?(从几到几,为什么)
③ 什么条件?(满足什么才算解)
2. 单重枚举
// 求 n 的所有约数
for (int i = 1; i <= n; i++)
if (n % i == 0) cout << i << " ";
// 优化:只需试到 sqrt(n)
for (int i = 1; i * i <= n; i++)
if (n % i == 0) {
cout << i << " ";
if (i != n / i) cout << n / i << " "; // 别把平方根算两次
}
3. 多重枚举
// 百钱百鸡:公鸡 5 元、母鸡 3 元、小鸡 3 只 1 元,100 元买 100 只
for (int g = 0; g <= 20; g++)
for (int m = 0; m <= 33; m++) {
int x = 100 - g - m; // 小鸡由总数推出
if (x >= 0 && x % 3 == 0 && 5*g + 3*m + x/3 == 100)
cout << g << " " << m << " " << x << endl;
}
范围怎么定:公鸡最贵,100÷5 = 20,所以 g <= 20;母鸡 100÷3 = 33,所以 m <= 33。 为什么不用三重循环:小鸡数由总数减出来,省一层。
要点:能用一个关系式推出第三个变量,就少写一层循环——这是枚举优化的第一招。
4. 避免重复计数
// 从 1~n 中选两个不同的数,有多少对?(顺序无关)
int cnt = 0;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) // j 从 i+1 开始
cnt++;
// 结果 = n(n-1)/2
易错:
j从 1 开始会把(a,b)和(b,a)都算上,结果翻倍。
5. 边界:< 还是 <=
| 题目说 | 写法 |
|---|---|
| "1 到 n"(含 n) | i <= n |
| "小于 n" | i < n |
| "n 位数" | i = 10^(n-1) 到 10^n - 1 |
易错:答案选项常设「差 1」的干扰项,就是赌你边界取错。
6. 提前结束
bool found = false;
for (int i = 1; i <= n; i++)
if (a[i] == x) { found = true; break; } // 找到就停,不用跑完
7. 一分钟记忆卡
- 三步:枚举什么、范围多少、条件是什么
- 能从总数推出第三个量,就别写第三层循环
j从i+1开始避免重复计数- 边界看题目:"到 n" 用
<=,"小于 n" 用< - 找到就 break
#include <iostream>
using namespace std;
int main() {
int count = 0;
for (int i = 100; i <= 999; i++) {
int a = i / 100;
————————————————————
int c = i % 10;
if (a * a + b * b == c * c) {
count++;
}
}
cout << count << endl;
return 0;
}int main()
{
int i,sum=0;
for(int i = 1; i <= 100 ; i++)
sum += i;
cout << sum << endl;
cout << endl;
return 0;
}#include <iostream>
using namespace std;
int main() {
int arr[] = {3, 7, 2, 9, 5};
int maxIndex = 0;
for (int i = 1; i < 5; i++) {
————————————————————————————————
{
maxIndex = i;
}
}
cout << maxIndex;
return 0;
}- 1.B 以下程序使用枚举法(穷举法)求解满足条件的三位数,横线处应该填入的是…
- 2.A 把整数3025从中剪开分为30和25两个数,此时再将这两数之和平方,…
- 3.C 想要计算从数字n到数字m之间(包含n和m)有多少个数字d出现,下列程…
- 4.B 著名的哥德巴赫猜想:任一大于2的偶数都可写成两个素数之和。我们可以通…
- 5.B 下面C++代码可以计算1到100的累加和,采用的是穷举法。…
- 6.D 下面枚举法查找最大值索引程序中,横线处应该填写的是( )…
- 7.B 在 C++ 中,枚举的底层类型可以是非整型(如 float 或 do…
- 8.A 枚举可以在保证不漏解的前提下缩小枚举范围,不是必须遍历全部。…
- 9.C 以下问题中,最不适合用枚举法解决的是:( )…
- 10.A 用枚举法解决 “鸡兔同笼问题:头共 35 个,脚共 94 只,求鸡和…
#include <iostream>
using namespace std;
int main() {
const int SIZE = 5;
int arr[SIZE];
for (int i = 0; i <= SIZE; i++) {
arr[i] = i * 2;
}
cout << arr[SIZE] << endl;
return 0;
}- 11.C 以下C++代码中存在几处错误( )。…
- 12.A 在C++中,所有全局变量如果没有显式初始化,都会被自动初始化为0。…
- 13.A do { ... } while (false); 循环体内的语句至…
- 14.A 在C++中,++i 是一个左值表达式,而 i++ 是一个右值表达式。…
- 15.B 对于 enum Color { RED, GREEN, BLUE }…
- 16.B #define SQUARE(x) x * x 是一个安全的宏定义,…
- 17.B 表达式 a > b ? a : b = 10; 一定是合法的C++代…
- 18.B #include "file.h" 和 #include <file…
- 19.B 在同一个作用域内,extern 声明的变量可以多次定义。…
- 20.D 以下关于 C++ 求最小值函数 min() 的描述,不正确的是( )…
int t = x--; t -= x; cout << t << endl;
int a = 5, b = 3; int c = a++ + ++b; cout << c << endl;
if (a > b) {
z = x;
} else {
z = y;
}
int main() {
int arr[5] = {1, 2, 3, 4, 5};
cout << arr[3 > 2 ? 1 : 2] << endl;
return 0;
}for (int i = 0; i < 5; i++);
{
cout << "Hello" << endl;
}a=a^b; b=a^b; a=a^b;
int x=10; cout<<(x++) + (++x)<<endl;
int arr[] = {5, 10, 15, 20, 25, 30};
int count = sizeof(arr) / sizeof(arr[0]);
cout << count;- 21.C 整型变量 x 的初始值为 10,以下代码的输出结果是( )…
- 22.A 以下关于 C++ 中 abs() 函数的描述,正确的是( )…
- 23.B 整型变量 a 的值为 3,浮点数变量 b 的值为 3.5,在 C++…
- 24.B 以下代码输出结果为 8。…
- 25.A C++ 表达式 z = a > b ? x : y 等同于:以下代码…
- 26.B 在 C++ 中,++ 和 -- 运算符只能用于整型变量,不能用于浮点…
- 27.B 以下代码中,Hello 将被输出5次。…
- 28.B a,b是整型变量,各自有互不相同的初始值。下列程序实现了什么效果( …
- 29.A 关于以下程序段,说法正确的是( )。…
- 30.B 执行以下代码后,输出结果是:( )。…
#include <iostream>
using namespace std;
int main() {
int x = 1;
for (int i = 0; i = 0; i <= 5) {
x++;
}
cout << x << endl;
return 0;
}#include <iostream>
using namespace std;
int main() {
int x = 2026;
int count = 0;
while (x > 0) {
count++;
x = x & (x - 1);
}
cout << count << endl;
}- 31.A 定义 int arr[] = {1,2,3};,则 sizeof(a…
- 32.A 下面程序的运行结果是( )…
- 33.B 下面程序执行的结果是( )。…
- 34.C 已知:a=0, b=2, c=11, d=7, e=5,表达式 !a…
- 35.B char str[4] = "GESP"; 将在内存空间中给 str…
④今日打卡 · 点一下就能勾选
- 用三步定式分析「百钱百鸡」,写出每层循环的范围与理由
- 写求 n 全部约数的代码,并改成只试到 sqrt(n) 的优化版
- 解释为什么 j 要从 i+1 开始,说明从 1 开始会怎样
- 区分「1 到 n」「小于 n」「n 位数」三种范围的写法
- 写一段找到目标就 break 的查找代码
- 说明枚举优化有哪三招(消循环、缩范围、提前停)
- 把本日 35 道客观题做完,错题标记出来
模拟法与算法描述
①今日考情 · 真题分布与备考建议
本考点在 GESP C++ 3级近 14 期真题中共 80 道客观题(单选 51 / 判断 29,其中 22 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。
本期分布
| 期次 | 题数 |
|---|---|
| 2023年12月 C++ 3级 | 15 |
| 2023年6月 C++ 3级 | 8 |
| 2023年9月 C++ 3级 | 6 |
| 2024年12月 C++ 3级 | 4 |
| 2024年3月 C++ 3级 | 5 |
| 2024年6月 C++ 3级 | 9 |
| 2024年9月 C++ 3级 | 9 |
| 2025年12月 C++ 3级 | 2 |
| 2025年3月 C++ 3级 | 7 |
| 2025年6月 C++ 3级 | 2 |
| 2025年9月 C++ 3级 | 10 |
| 2026年3月 C++ 3级 | 2 |
| 2026年9月 C++ 3级 | 1 |
配套教材
GESP 大通关 3 级(全书 64 页):本天对应 3.7 模拟法与算法描述。教材按同一套大纲顺序编排,可对照阅读。
备考建议(出题人视角)
模拟法在三级题量不大,但它是**读程序题的通用解法**——绝大部分"问输出"的题本质都是模拟。所以这一天的重心不是背知识点,而是练"把代码当规则、逐轮推演"的能力。同时把算法的五个特征、流程图的三种结构再过一遍,这两块是三级客观题的稳定得分点。
②知识地图 · 本考点思维导图
- 模拟法
- 本质:把题目规则翻译成代码,一步步执行
- 关键:状态变量要写清(谁在变、变成什么)
- 步骤:初始化 → 循环推进 → 判断结束 → 输出
- 状态表的写法
- 列:轮次 / 关键变量 / 判断 / 动作 / 累计
- 一行一轮,不许跳步
- 算法描述三方式
- 自然语言
- 流程图(菱形判断、平行四边形输入输出)
- 伪代码
- 算法五特征
- 有穷性 · 确定性 · 可行性 · 输入(可 0)· 输出(必有)
- 读程序破题三步
- ① 找变量 ② 找循环 ③ 列表推演
- 陷阱:循环上界、break/continue、下标起点
③核心精讲
1. 模拟法是什么
模拟 = 照着题目的规则,用代码一步步走一遍。
// 模拟:n 个人围成一圈报数,报到 3 的人退出,问最后剩下谁
// 状态:还剩几个人、当前报数、当前位置
int left = n, cur = 0, cnt = 0;
while (left > 1) {
if (alive[cur]) {
cnt++;
if (cnt == 3) { alive[cur] = 0; cnt = 0; left--; }
}
cur = (cur + 1) % n; // 环形推进
}
模拟题的三步:初始化状态 → 按规则推进 → 判断结束条件。
2. 状态表:模拟题的命门
以"报数跳过 3 的倍数"为例:
| 轮次 | 当前数 | 判断 | 动作 | 累计输出 |
|---|---|---|---|---|
| 1 | 1 | 不是 3 的倍数 | 报数 | 1 |
| 2 | 2 | 不是 | 报数 | 1 2 |
| 3 | 3 | 是 | 跳过 | 1 2 |
| 4 | 4 | 不是 | 报数 | 1 2 4 |
要点:模拟题只要肯列表,就不会错;心算必错在第 3、4 轮之后。
3. 算法的三种描述方式
| 方式 | 特点 | 例子 |
|---|---|---|
| 自然语言 | 好懂但不严谨 | "把较大的数放到前面" |
| 流程图 | 图形化,结构清晰 | 菱形=判断,平行四边形=输入输出 |
| 伪代码 | 接近程序,无严格语法 | for i ← 1 to n do |
4. 算法的五个特征(再背一遍)
| 特征 | 含义 | 反例 |
|---|---|---|
| 有穷性 | 有限步结束 | 死循环 |
| 确定性 | 每步唯一 | "取较大的"若相等则二义 |
| 可行性 | 每步可执行 | "求 π 的精确值" |
| 输入 | 可以 0 个 | 直接计算 1+1 |
| 输出 | 至少 1 个 | 无输出的计算 |
易错:输入可以没有,输出必须有。
5. 读程序的三个陷阱
| 陷阱 | 表现 | 对策 |
|---|---|---|
| 循环上界 | i<=n 与 i<n 差一次 | 写出结束时的 i 值 |
| break / continue | 提前跳出或跳过 | 标出执行路径 |
| 下标起点 | 0 起还是 1 起 | 看数组定义与循环初值是否一致 |
6. 一分钟记忆卡
- 模拟三步:初始化 → 按规则推进 → 判断结束
- 一定要画状态表,一行一轮
- 算法三描述:自然语言 / 流程图 / 伪代码
- 五特征:有穷、确定、可行、输入可 0、输出必有
- 读程序三陷阱:上界、break、下标起点
#include <iostream>
using namespace std;
int main() {
int height = 10;
int distance = 0;
for (int i = 1; i <= 5; i++) { // 模拟5次落地
——————————————————————
height /= 2;
distance += height;
}
cout << distance << endl;
return 0;
}- 1.B 以下程序模拟了一个简单的小球反弹过程,横线处应该填入的是( )…
- 2.B 下列流程图的输出结果是?( )…
- 3.B 下面流程图在yr输入2024时,可以判定yr代表闰年,并输出2月是2…
- 4.B 下列流程图的输出结果是( )。…
- 5.B 根据下面的流程图,如果成绩 score 输入 60,输出的结果是( …
- 6.A 下面的流程图是用来求 1+2+3+…+10 的和。请判断:这个流程图…
- 7.A 下面流程图的功能是计算 5 对 2 取余数,输出结果为 1。…
- 8.B 一个算法可以用不同的形式来描述,但要求描述比较规范,因此不能用自然语…
- 9.A C++程序执行后,输入chen a dai 输出应该为:chen。(…
- 10.A 下面C++程序将输出1。( )…
#include<iostream>
using namespace std;
int main()
{
double a=0.9;
double b=1.0;
if(((b-a)==0.1))
{
cout<<"Equal"<<endl;
}
else
{
cout<<"Not equal"<<endl;
}
}long a = 123; int b = 1; long result = a & b; cout<<result<<endl; long a2 = -123; unsigned int b2 = -1; long result2 = a2 & b2; cout<<result2<<endl;
int a[10]={1,2,3,4,5,6,7,8,9,10};
cout<<a[10]<<endl;char x=65; x++; cout<<x++<<endl;
int a[10]={1};
cout<<a[1]<<endl;int a=65; cout<<(char)a<<endl;
int a=65; cout<<tolower(a)<<endl;
long long n;
cin >> n;
while(n != 0) {
cout << n/2 << ' ' << n%2 << '\n';
n /= 2;
}int arr[5] = {1, 2, 3, 4, 5};
int p = arr[1];
cout << (p + 2) << endl;#include <iostream>
using namespace std;
int main() {
int a = 'a', b = 'b';
if (a > 0 || b++ > 0) {
}
cout << b;
}- 11.B 下列代码中,输出结果是( )…
- 12.D 下列程序中,result和result2输出分别是( )…
- 13.D 下面的程序中,会输出( )。…
- 14.B 下列程序输出的是A。( )…
- 15.B 下列程序将输出1。( )…
- 16.A 下列程序将输出A。( )…
- 17.D 下列程序最后输出的是( )…
- 18.A 该段程序将 n 不停地除以 2,并输出此时的商和余数,直到 n=0 …
- 19.D 以下代码是一个程序的部分代码,能够正确执行,输出的结果是( )…
- 20.A 下面程序执行后,将输出 98。…
- 21.D 高级语言编写的程序需要经过以下( )操作,可以生成在计算机上运行的可…
- 22.D 以下哪个不是C++语言中的运算符?( )…
- 23.C 如果a 和b 均为int 类型的变量,下列表达式能正确判断“a 等于…
- 24.B 在下列代码的横线处填写( ),可以使得输出是“24 12”。…
- 25.D 在下列代码的横线处填写( ),可以使得输出是“2”。…
- 26.B 在下列代码的横线处填写( ),可以使得输出不是“31”。…
- 27.B 域名是由一串用点分隔的名字来标识互联网上一个计算机或计算机组的名称,…
- 28.B 人们所使用的手机上安装的App通常指的是( )。…
- 29.B 以下哪个不是C++语言中的运算符?( )…
- 30.D 如果a 为char 类型的变量,下列哪个表达式可以正确判断“a是大写…
- 31.D 在下列代码的横线处填写( ),可以使得输出是“120”。…
- 32.B 在下列代码的输出是( )。…
- 33.C 执行下面C++代码输出是( )。 A 10…
- 34.C 执行下面C++代码后,输出是( )。…
- 35.A 执行下面C++代码后输出的是( )。…
- 36.D 下面C++代码执行后的输出是( )。…
- 37.A 下面C++程序执行的结果是( )。…
- 38.C 某公司新出了一款无人驾驶的小汽车,通过声控智能驾驶系统,乘客只要告诉…
- 39.B 现代计算机是指电子计算机,它所基于的是( )体系结构。…
- 40.A 执行下面C++代码后将输出"China"。( )…
- 41.B 执行C++代码将输出0 5,5 之后还有一个空格。( )…
- 42.B 下面C++代码将输出1( )…
- 43.A 执行C++代码,将输出1 3 5 7 9,9 之后还有一个空格。( …
- 44.B 小杨最近在准备考GESP,他用的Dev C++来练习和运行程序,所以…
- 45.A 任何一个while循环都可以转化为等价的for循环( )。…
- 46.B 定义整型变量int a=3, b=16,则a|b 的值和a+b 的关…
- 47.C 小杨的父母最近刚刚给他买了一块华为手表,他说手表上跑的是鸿蒙,这个鸿…
- 48.C 中国计算机学会(CCF)在2024年1月27日的颁奖典礼上颁布了王选…
- 49.A 小杨今年春节回奶奶家了,奶奶家的数字电视要设置ip地址并接入到WIF…
- 50.A 任何一个for 循环都可以转化为等价的while 循环( )。…
#include <iostream>
using namespace std;
int main() {
int a = 5;
int b = 10;
a = a ^ b;
b = a ^ b;
a = a ^ b;
cout << "a = " << a << ", b = " << b << endl;
return 0;
}#include <iostream>
using namespace std;
int main() {
int array[5] = {3,7,5,2,4};
int max = 0;
for(int i=0; i<5; i++)
if(______________) // 在此处填入代码
max = array[i];
cout << max << endl;
return 0;
}#include <iostream>
using namespace std;
int main() {
int arr[35];
int count = 0;
for (int i = 1; i <= 35; i++) {
if (i % 7 == 0)
__________________________ // 在此处填入代码
}
for (int i = 0; i < count; i++)
cout << arr[i] << endl;
return 0;
}#include <iostream>
#include <cstdlib> // 为了使用 rand() 和 srand()
#include <ctime> // 为了使用 time()
using namespace std;
int main() {
// 设置随机种子
srand(time(NULL));
int i = 1;
int s[5];
while(i <= 5)
{
int a = rand() % 10;
if(a % 3 == (i + 1) % 3)
s[i++] = a;
}
for(int i = 1; i <= 5; i++)
cout << s[i];
cout << endl;
return 0;
}- 51.C 小杨父母带他到某培训机构给他报名参加CCF组织的GESP认证考试的第…
- 52.C 下列代码的输出结果是( )。…
- 53.B 在下列代码的横线处填写( ),可以使得输出是“7”。…
- 54.A 小杨在做数学题,题目要求找出从1到35中能被7整除的数字,即[7, …
- 55.D 下面可以正确输出 They're planning a party …
- 56.A GESP测试是对认证者的编程能力进行等级认证,同一级别的能力基本上与…
- 57.A 执行下面C++代码后,输出的结果不可能是89781。( )…
- 58.D 陈A歹种植一批农作物,第一天需要浇水一次,随后的两天(第2、第3天)…
- 59.C 有ABCD4个人,其中一个是小偷,每个人说一句话,只有小偷说的是假话…
- 60.A 取X 的低四位,可以用Y = 0000 1111,用X&Y 获取X …
char a='A'; a=a+32; cout<<(int)a<<endl;
int a = -5; unsigned int b = a; cout << b;
for (int i = 1; i <= n; i++) {
cin >> a;
__________________________
cnt++;
}cin>>n; cout<<((n%4==0&&n%100!=0)||(n%400==0))?1:0; return 0;
- 61.A 工人工作一天,会得到一个金环作为工资报酬,某个工作需要15天完成,一…
- 62.A 将输出 97…
- 63.A 自然界中,最小的素数是 2…
- 64.C 在C++中,以下代码的输出是什么()…
- 65.C 有 n 个正整数,假设一个正整数是美丽数字当且仅当该正整数是 9 的…
- 66.B 判断一个三角形是否成立的条件只有:任意两边长度之和大于第三条边的长度…
- 67.A 闰年的定义:普通闰年:公历年份是 4 的倍数,且不是 100 的倍数…
- 68.A C++语句cout<<(n%15==0? "YES":"NO"); …
- 69.A 有n个同学,从中抽取任意个人数来参加学校组织的大合唱,共有2的n次幂…
- 70.A 在数学纸面计算中,pow(2, 3) 的计算结果一定是8,但是在C+…
int a = 10, b = 3; double c = a / b;
int sum = 0;
for (int i = 1; i <= 5; i += 2) {
sum += i;
int sum=0;
}int i = 10;
int count=0;
while (i > 0) {
i -= 3;
continue;
count++;
}for (int i = 0; i < 4; i++) {
for (int j = 0; j <= i; j++) {
cout << j;
}
cout << "#";
}int reversed = 0;
while (x != 0) {
int digit = x % 10;
x /= 10;
reversed = reversed * 10 + digit;
}- 71.C 执行以下C++代码后,c 的数值是( )。…
- 72.C 下列C++表达式的结果为 true 的是( )。…
- 73.B 执行以下C++代码后,变量 sum 的值是( )。…
- 74.B 要正确定义一个返回两个整数中较大值的函数 max,应该使用( )。…
- 75.B 以下关于C++函数的描述,正确的是( )。…
- 76.D 以下C++代码 count++ 执行的次数是( )。…
- 77.A 以下C++代码段的输出是( )。…
- 78.C 以下关于C++变量作用域的说法,错误的是( )。…
- 79.D 关于以下代码的说法正确的是( )。…
- 80.D 以下关于C++函数的说法,正确的是( )。…
④今日打卡 · 点一下就能勾选
- 用状态表模拟「1~10 报数,跳过 3 的倍数」,写出前 5 轮
- 说出模拟法的三个步骤,并指出最容易漏的是哪一步
- 默写算法五特征,说明「输入可以 0 个、输出至少 1 个」
- 对比自然语言、流程图、伪代码三种描述方式的特点
- 列出读程序的三个陷阱(循环上界 / break / 下标起点)及对策
- 解释为什么模拟题必须画表,心算容易错在哪
- 把本日 80 道客观题做完,错题标记出来
数学计算与换算
①本日知识点 · 数学计算与换算
看清单位与进制;除法取整、取余的符号方向是最常错的。
本组 1 道题全部来自 GESP 真题,按「数学计算与换算」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。
编写程序,输入小猫的数量 N 以及每次扔到海里的鱼的数量 i,输出海滩上最少的鱼数,使得每只小猫都可吃到鱼。
例如:两只小猫来分鱼 N=2,每次扔掉鱼的数量为 i=1,为了每只小猫都可吃到鱼,可令第二只小猫需要拿走 1 条鱼,则此时待分配的有 3 条鱼。第一只小猫待分配的鱼有 3× 2+1=7 条。
保证 0<N<10;i<N 。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 2 1 | 7 |
| 2 | 3 1 | 25 |
三只小猫来分鱼 N=3,每次扔掉鱼的数量为 i=1,为了每只小猫都可吃到鱼,可令第三只小猫需要拿走 3 条鱼(拿走 1 条和 2 条不满足要求),则此时待分配的有 10 条鱼。第二只小猫待分配的鱼有 10×3/2+1 = 16 条。第一只小猫待分配的鱼有 16×3/2+1 = 25 条。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
海滩上有一堆鱼,N 只小猫来分。第一只小猫把鱼平均分成 N 份,多了 i 个(i < N),把多的 i 个扔进海里、拿走一份。第二只小猫接着把剩下的鱼再平均分成 N 份,又多了 i 个,同样扔掉 i 个、拿走一份……第 N 只小猫也是这样操作。
输入 N 和 i,输出海滩上最少的鱼数,使得每只小猫都能吃到鱼。
例:N = 2、i = 1 时答案是 7。
💡人话翻译:每次操作都是"设当前有 s 条鱼,那么 s = N × 某整数 + i,扔掉 i 条,拿走 N 分之一"。要从最后一只猫倒着往前推,而且每一步都必须整除。
🔍 关键词提取
逆向推导整除判定枚举最小值模拟
已知条件
项目说明
输入第一行 N;第二行 i
输出满足要求的最少鱼数
数据范围0 < N < 10
余数条件i < N
样例N = 2, i = 1 → 7;N = 3, i = 1 → 25
需要解决的问题
为什么倒着推?正着推不知道"初始有多少鱼",但最后一只猫的操作很确定:待分配数 = 它拿走的 × N + i
往前推的公式是什么?设某只猫待分配 s 条,它拿走 s/N 的一条份额后剩 s ÷ N × (N − 1) 条,所以上一只猫待分配 = s ÷ N × (N − 1) + i,也就是 s × (N − 1) ÷ N + i
"最少"怎么保证?从小到大枚举最后一只猫拿走的份额,第一个全部整除的就是答案
📥 读入
N 只猫(< 10)
每次扔 i 个(i < N)
N、i 都是小整数
注意 i 可能是 0
🔄 倒推模型
最后一只猫拿走 r 条
它待分配 = r × N + i
往前:x × (N−1) ÷ N + i
每步都必须整除
🔍 枚举最小
r 从 1 开始试
第一个全部整除的 r 即答案
整除判定用 % N
不需要数学公式
⚠️ 易错点
正着推无从下手
整除判定漏掉
N = 1 的边界
i = 0 的情况
我们从最后一只猫开始往前推。设最后一只猫拿走 r 条鱼。
1
先明确推进公式
设某只猫待分配 s 条,它把 s 分成 N 份、扔掉 i 个
拿走 1 份后,剩 N − 1 份给后面的猫
所以上一只猫待分配 = s × N ÷ (N − 1) + i
并且 s × N 必须能被 (N − 1) 整除
这是倒推的核心公式
2
尝试 r = 1
第三只猫待分配 = 1 × 3 + 1 = 4
往前:4 × 3 ÷ 2 + 1 = 6 + 1 = 7 ✅ 整除
再往前:7 × 3 = 21,21 ÷ 2 → 不整除 ✗
❌ r = 1 不成立
3
尝试 r = 2
第三只猫待分配 = 2 × 3 + 1 = 7
往前:7 × 3 = 21,21 ÷ 2 → 不整除 ✗
❌ r = 2 不成立
4
尝试 r = 3
第三只猫待分配 = 3 × 3 + 1 = 10
往前:10 × 3 ÷ 2 + 1 = 15 + 1 = 16 ✅ 整除
再往前:16 × 3 ÷ 2 + 1 = 24 + 1 = 25 ✅ 整除
✅ 全部成立,答案是 25
步骤说明数值
最后一只猫拿走设为 r = 33
第三只猫待分配r × N + i = 3 × 3 + 110
往前推一次10 × 3 ÷ 2 + 116
再往前推一次16 × 3 ÷ 2 + 125
🔑推进方向要分清:从"第 k 只猫待分配 s"推"第 k−1 只猫待分配",要先把 s 乘回 N 份再除以 (N−1) 份,即 s × N ÷ (N − 1) + i,并且要求 s × N 能被 N − 1 整除。这一步的乘除顺序是最容易写错的地方。
🧮 正向验证:25 条鱼确实是可行的
倒推得到 25 后,我们正着走一遍确认。
操作待分配鱼数分成 N 份扔掉 i 个拿走一份后剩余
第 1 只猫2525 ÷ 3 = 8 余 1扔 124 ÷ 3 × 2 = 16
第 2 只猫1616 ÷ 3 = 5 余 1扔 115 ÷ 3 × 2 = 10
第 3 只猫1010 ÷ 3 = 3 余 1扔 19 ÷ 3 × 2 = 6
💡注意最后剩余的 6 条:题目只要求每只猫都分到鱼并拿走一份,没有要求最后剩余为 0。这一点容易误解,很多同学会强行让剩余为 0 导致算不出来。
🟢 倒推 + 枚举份额(推荐) 推荐
枚举最后一只猫拿走的份数 r,往前推 N−1 次,全部整除即答案
N < 10,枚举量极小
逻辑与题面一一对应
不需要推导通项公式
代码 10 行
💡为什么够用:N 最大 9,而最小解的份额 r 通常不大,枚举几十次就能命中,完全不用担心效率。
🟠 推通项公式
设最后一只猫拿走 x 份,尝试推出初始鱼数的解析式
经典"猴子分桃"型问题
公式含 (N−1)^N 的幂
需要配合整除条件求解
推导复杂易错
⚠️结论:这类问题的通用形式是 N^N − (N − 1) 一类的表达式,但本题 i 可变化,公式要分情况讨论,不如枚举省事。
📈 性能对比
方案代码量可靠性
倒推枚举约 10 行 ⭐⭐⭐⭐⭐
通项公式约 15 行 + 推导⭐⭐(易错)
输入 N 和 i,程序会从最后一只猫开始往前推,展示每一步的数值和整除判定。
输入:第一行 N,第二行 i3
1
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
int N, i;
scanf("%d %d", &N, &i);
// 枚举最后一只猫拿走的份数 r(从 1 开始,保证每只猫都能吃到鱼)
for (int r = 1; ; r++) {
long long cur = 1LL * r * N + i; // 最后一只猫的待分配鱼数
bool ok = true;
// 往前推 N-1 次,每次都要整除
for (int k = 0; k < N - 1; k++) {
long long upper = cur * N;
if (upper % (N - 1) != 0) { ok = false; break; }
cur = upper / (N - 1) + i;
}
if (ok) {
printf("%lld\n", cur);
return 0;
}
}
return 0;
}
🔑为什么用 long long?N = 9 时答案大约是 9⁹ 量级(约 3.9 亿),虽然勉强在 int 范围内,但推过程中 cur * N 很容易瞬间超过 int 上限,务必用 long long 存中间结果。
📖 关键几行怎么看
代码作用为什么这样写
for (int r = 1; ; r++)枚举份额r 是最后一只猫拿走的份数,从 1 开始保证每只都有鱼吃
cur = 1LL * r * N + i最后一只猫的待分配写成 1LL * 是为了强制 long long 运算
upper % (N - 1) != 0整除判定不能整除说明这个 r 不合法,换下一个
cur = upper / (N - 1) + i往前推一步先乘 N 再除以 (N − 1),顺序不能反
⚠️三个坑:① 推进公式写成 cur / N * (N−1) + i,方向搞反了;② 忘了整除判定,直接用整除结果导致答案错误;③ 用 int 存中间量,cur * N 溢出。
写完程序后,用这些数据自查一遍:
输入答案考察点
2
17题面样例 1
3
125题面样例 2
2
04i = 0:每次都不扔
3
223i = 2 的情形
9
8运行验证最大规模,考察 long long
✅自查清单:① 是从最后一只猫倒推吗?② 每步都做了整除判定吗?③ 用 long long 了吗?
🚨 易错点清单
⚠️推进方向写反:必须是 cur × N ÷ (N − 1) + i,乘和除的位置不能互换。
⚠️漏掉整除判定:不检查整除就会算出错误的"伪解",必须 cur × N % (N − 1) == 0 才继续。
⚠️用 int 存中间量溢出:N = 9 时中间值可达 10⁹ 量级,乘以 N 后必然溢出。
⚠️以为最后必须剩 0 条:题目只要求每只猫都分到鱼,剩余不为 0 也是允许的。
时间复杂度
O(枚举 × N)
空间复杂度
O(1)
N 最大
9
枚举次数
通常几十次
时间怎么算的?
外层枚举份额 r
每个 r 往前推 N − 1 次
N < 10,命中所需的 r 通常很小
实际运算量几百次以内
空间都用在哪?
只需要几个整数变量,不需要数组。
✅ N 最大 9,枚举量极小,任何实现都瞬间完成;这题考的是逆向思维和整除判定。
// 逆向模拟的通用骨架
for (int r = 1; ; r++) { // 枚举"最后一刻"的状态
long long cur = f(r); // 由 r 推出最后一步的状态
bool ok = true;
for (int k = 0; k < steps; k++) {
if (!canAdvance(cur)) { ok = false; break; } // 合法性判定
cur = advance(cur); // 往前推一步
}
if (ok) { /* 输出 cur */ break; }
}
// 整除判定与防止溢出的写法
if (cur * 1LL * N % (N - 1) != 0) { /* 不合法 */ }
// 或者先除后乘(当能整除时等价)
// (cur / N) 的形式要求 cur 能被 N 整除,注意条件
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
逆向推导从终止状态反推初始状态猴子分桃、倒水、逆序操作类题目
整除判定用 % 检查可行性所有"必须恰好分成整数份"的题
枚举最小解从小到大试,第一个可行即最小求最小解、最优解的搜索题
🌟思考题:如果题目改成"求最大的鱼数(在某个上限以内)",枚举方向该怎么调整?(提示:把所有可行的 r 都找出来、取对应的最大 cur,但要注意题目是否有上界约束——没有上界时"最大的鱼数"是无穷大。)
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, i;
scanf("%d %d", &N, &i);
// 枚举最后一只猫拿走的份数 r(从 1 开始,保证每只猫都能吃到鱼)
for (int r = 1; ; r++) {
long long cur = 1LL * r * N + i; // 最后一只猫的待分配鱼数
bool ok = true;
// 往前推 N-1 次,每次都要整除
for (int k = 0; k < N - 1; k++) {
long long upper = cur * N;
if (upper % (N - 1) != 0) { ok = false; break; }
cur = upper / (N - 1) + i;
}
if (ok) {
printf("%lld\n", cur);
return 0;
}
}
return 0;
}// 逆向模拟的通用骨架
for (int r = 1; ; r++) { // 枚举"最后一刻"的状态
long long cur = f(r); // 由 r 推出最后一步的状态
bool ok = true;
for (int k = 0; k < steps; k++) {
if (!canAdvance(cur)) { ok = false; break; } // 合法性判定
cur = advance(cur); // 往前推一步
}
if (ok) { /* 输出 cur */ break; }
}
// 整除判定与防止溢出的写法
if (cur * 1LL * N % (N - 1) != 0) { /* 不合法 */ }
// 或者先除后乘(当能整除时等价)
// (cur / N) 的形式要求 cur 能被 N 整除,注意条件②编程打卡 · 点一下就能勾选
- 完成 B3925《小猫分鱼》,跑通全部样例
- 对比题解里的参考代码,找出自己写法的差异
循环 · 累加计数与嵌套
①本日知识点 · 循环 · 累加计数与嵌套
先定三重:初值、条件、更新;再分清内层跑几次。
本组 2 道题全部来自 GESP 真题,按「循环 · 累加计数与嵌套」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。
每行的各个整数之间用单个空格分隔。
保证 1 ≤ N ≤ 1,000;1 ≤ D ≤ 1,000。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 2 3 0 1 0 | 4 2 |
| 2 | 3 5 0 0 0 2 0 | 11 0 4 |
小杨在第 1 天、第 2 天、第 3 天分别向 0 号、 1 号、 0 号存钱罐存了 1 元钱、 2 元钱、 3 元钱,因此 0 号存钱罐有 1+3=4 元钱,而 1 号存钱罐有 2 元钱。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
小杨共有 N 个储蓄罐,编号从 0 到 N − 1。从第 1 天开始,每天挑一个罐子存钱:第 i 天往编号 aᵢ 的罐子里存入 i 元钱。
过了 D 天后,请输出每个罐子里各有多少钱(按编号 0 到 N − 1 的顺序)。
💡人话翻译:这是一道"记账"题。关键是记住第 i 天存的是 i 元(不是每天 1 元!),所以天数越大存得越多。用一个数组按罐号累加即可。
🔍 关键词提取
数组当桶按天累加索引与编号对应格式化输出
已知条件
项目说明
输入第一行 N、D;第二行 D 个整数 aᵢ
输出N 个整数,编号 0 到 N − 1 的罐内金额
数据范围1 ≤ N, D ≤ 1000
编号范围0 ≤ aᵢ ≤ N − 1
存款规则第 i 天存入 i 元
需要解决的问题
每天存多少?第 i 天存 i 元,i 从 1 开始计数
怎么记录每罐的钱?数组 sum[罐号] 累加,罐号直接当下标
最后输出顺序?按编号 0、1、…、N − 1,不是按存钱顺序
📥 读入
读 N、D
读 D 个罐号 aᵢ
罐号范围 0 ~ N−1
天数从 1 开始数
💰 累加
第 i 天存 i 元
sum[aᵢ] 加上 i
i 从 1 到 D
注意不是每天 1 元
🖨️ 输出
按罐号 0 ~ N−1 输出
空格分隔
0 号罐在最前
行末不加空格
⚠️ 易错点
把存款额当成 1
天数从 0 数
输出按存钱顺序
数组下标越界
注意每天存的金额是"第几天",不是固定的 1 元。
天数 i存入罐号 aᵢ存入金额0 号罐1 号罐
第 1 天0110
第 2 天1212
第 3 天031 + 3 = 42
🔑0 号罐为什么是 1 + 3 = 4?因为第 1 天和第 3 天都存进了 0 号罐,而金额分别是 1 元和 3 元。存钱的"金额"跟着天数走,这是本题的核心。
输出:4 2 ✓
🧮 样例 2:N = 3、D = 5,存钱顺序 0、0、0、2、0
天数 i罐号金额0 号罐1 号罐2 号罐
第 1 天01100
第 2 天02300
第 3 天03600
第 4 天24604
第 5 天051104
输出:11 0 4 ✓
💡1 号罐一直是 0:因为 D 天里从来没往 1 号罐存过钱,所以它输出 0。别忘了输出没有被存过的罐子。
🟢 数组边读边累加(推荐) 推荐
读入罐号时立刻把当天的金额加上去
时间 O(D)
空间 O(N)
一遍读取完成
不需要保存所有罐号
💡为什么推荐:读第 i 个数时,当天的金额 i 是已知的,直接 sum[a] += i 就完成了记账。
🟠 先存罐号再统计
把所有罐号存进数组,之后再逐罐统计
需要额外 O(D) 空间
要写两重循环
复杂度更差
没必要
⚠️注意:如果按罐号逐个去扫描所有天,复杂度会变成 O(N × D),本题数据小还不至于超时,但写法明显更差。
📈 性能对比
方案时间复杂度空间
边读边累加O(D)O(N)
存后统计O(N × D)O(N + D)
第一行输入 N 和 D,第二行输入 D 个罐号,程序会逐天记账并给出每罐余额。
输入:第一行 N D,第二行罐号序列3 5
0 0 0 2 0
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int sum[1005];
int main() {
int N, D;
scanf("%d %d", &N, &D);
for (int i = 1; i <= D; i++) { // i 既是天数,也是当天存入的金额
int a;
scanf("%d", &a);
sum[a] += i; // 罐号直接当下标
}
for (int i = 0; i < N; i++) {
if (i) printf(" ");
printf("%d", sum[i]);
}
printf("\n");
return 0;
}
🔑为什么循环变量 i 直接当金额用?题目说"第 i 天存入 i 元",所以把循环写成 for (int i = 1; i <= D; i++) 后,i 恰好就是当天的金额,一个变量身兼两职,代码非常简洁。
📖 关键几行怎么看
代码作用为什么这样写
for (i = 1; i <= D; i++)遍历每一天从 1 开始,因为第 1 天存 1 元
sum[a] += i记账罐号直接当下标,金额就是 i
if (i) printf(" ")控制空格第一个数前面不输出空格
int sum[1005]全局数组自动清零N ≤ 1000,开到 1005 足够
⚠️三个坑:① 把每天的金额当成 1 元(最常见的误解);② 输出时按"存钱顺序"而不是按"罐号顺序";③ 数组只开了 N 大小却访问了下标 N − 1 之外的(本题保证不会)。
写完程序后,用这些数据自查一遍:
输入答案考察点
2 3
0 1 04 2题面样例 1
3 5
0 0 0 2 011 0 4题面样例 2
1 1
01只有一个罐子
3 2
2 20 0 31 + 2 = 3 都进了 2 号罐
2 2
0 11 2每个罐各存一次
✅自查清单:① 第 i 天存的是 i 元吗?② 输出按罐号顺序吗?③ 没被存过的罐子输出了 0 吗?
🚨 易错点清单
⚠️把金额当成 1:那样样例 1 会输出 "2 1",与正确答案 "4 2" 不符。金额必须等于天数。
⚠️输出顺序错:必须按罐号 0、1、…、N−1 依次输出,不能按存钱的先后顺序。
⚠️循环从 0 开始:写成 i = 0 会让第 0 天存 0 元,整个金额序列都错位。
时间复杂度
O(N + D)
空间复杂度
O(N)
N, D 最大
1000
运算量
2000 次
时间怎么算的?
记账阶段遍历 D 天
输出阶段遍历 N 个罐子
合计 O(N + D)
最坏 2000 次操作
空间都用在哪?
一个长度为 N 的数组记录每个罐子的余额。
✅ N、D 都只有 1000,任何写法都瞬间完成;这题考的是"天数即金额"这个细节。
// 数组当桶的计数/累加模板
int cnt[1005]; // 求次数
long long sum[1005]; // 求和(金额可能较大时用 long long)
// 读入同时累加(最常用)
for (int i = 1; i <= D; i++) {
int a; scanf("%d", &a);
cnt[a]++;
sum[a] += i;
}
// 输出时控制空格的标准写法
for (int i = 0; i < N; i++) {
if (i) printf(" ");
printf("%lld", sum[i]);
}
printf("\n");
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
数组当桶累加用下标作为"键"累加计数排序、词频统计、分组求和
索引直接映射罐号 0 ~ N−1 与数组下标一一对应所有编号从 0 开始的题目
输出格式控制用 if (i) 避免行末空格所有多元素输出题
🌟思考题:如果题目改成"第 i 天存入的是 i² 元",代码要改哪一处?(提示:只需把 sum[a] += i 改成 sum[a] += 1LL * i * i,并注意用 long long 防止溢出。)
#include <bits/stdc++.h>
using namespace std;
int sum[1005];
int main() {
int N, D;
scanf("%d %d", &N, &D);
for (int i = 1; i <= D; i++) { // i 既是天数,也是当天存入的金额
int a;
scanf("%d", &a);
sum[a] += i; // 罐号直接当下标
}
for (int i = 0; i < N; i++) {
if (i) printf(" ");
printf("%d", sum[i]);
}
printf("\n");
return 0;
}// 数组当桶的计数/累加模板
int cnt[1005]; // 求次数
long long sum[1005]; // 求和(金额可能较大时用 long long)
// 读入同时累加(最常用)
for (int i = 1; i <= D; i++) {
int a; scanf("%d", &a);
cnt[a]++;
sum[a] += i;
}
// 输出时控制空格的标准写法
for (int i = 0; i < N; i++) {
if (i) printf(" ");
printf("%lld", sum[i]);
}
printf("\n");小明的原则很简单,见到想买的物品,只要能买得起,就一定会买下来之后才会继续往前走;如果买不起就直接跳过。
一天下来,小明到底买了多少物品呢?
第一行是一个整数 N,表示商场中共有 N 种小明想买的物品(1 ≤ N ≤ 100);
第二行共有 N 个整数,分别表示小明先后见到想买的物品的价格;
第三行是一个整数 X,表示开始时小明共有 X 元零花钱。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 6 7 5 9 10 7 4 30 | 4 |
对于 100% 的数据满足 1 ≤ N ≤ 100 且 0 ≤ a_i ≤ 100000。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
小明有个原则:见到想买的物品,只要能买得起,就一定会买下来,然后才继续往前走;如果买不起就直接跳过。问一天下来小明买了多少件物品。
输入第一行 N,第二行 N 个价格(按见到的先后顺序),第三行初始零花钱 X。
💡人话翻译:这是个"边走边买"的模拟题。关键点:必须按给定顺序处理,不能先排序再挑便宜的买——那样买到的件数可能更多,但不符合小明的行为规则。
🔍 关键词提取
顺序模拟余额递减贪心不可排序
已知条件
项目说明
输入N;N 个价格;初始金额 X
输出买到的物品件数
数据范围1 ≤ N ≤ 100
价格范围0 ≤ aᵢ ≤ 100000
行为规则按顺序,买得起就买(价格 ≤ 当前余额)
需要解决的问题
能不能排序?不能!顺序是题目规则的一部分
怎么判断买得起?X >= 价格,注意"恰好等于"也表示买得起
买了之后呢?从余额里扣掉价格,继续往后看
📥 读入
N 件商品
价格按见到顺序给出
初始金额 X
数组保存价格
🔁 顺序模拟
i 从 0 到 N−1
若 X ≥ 价格 → 买
余额减去价格,件数加 1
否则跳过继续
📤 输出
输出买到的件数
不需要输出余额
不需要输出买了哪些
只数个数
⚠️ 易错点
错误地排序后贪心
把"买得起"写成"严格大于"
余额没更新
顺序被打乱
我们按顺序一件件看,每次判断"当前余额够不够"。
1
第 1 件,价格 7
余额 30 ≥ 7 → 买
余额变为 30 − 7 = 23
买了,件数 1
2
第 2 件,价格 5
余额 23 ≥ 5 → 买
余额变为 18
买了,件数 2
3
第 3 件,价格 9
余额 18 ≥ 9 → 买
余额变为 9
买了,件数 3
4
第 4 件,价格 10
余额 9 < 10 → 买不起,跳过
余额保持 9
跳过,件数仍为 3
5
第 5 件,价格 7
余额 9 ≥ 7 → 买
余额变为 2
买了,件数 4
6
第 6 件,价格 4
余额 2 < 4 → 买不起,跳过
跳过,最终件数 4
顺序价格购买前余额判断购买后余额累计件数
173030 ≥ 7 ✅ 买231
252323 ≥ 5 ✅ 买182
391818 ≥ 9 ✅ 买93
41099 < 10 ❌ 跳过93
5799 ≥ 7 ✅ 买24
6422 < 4 ❌ 跳过24
最终买到 4 件 ✓
🔑如果排序后会怎样?把价格排序成 4、5、7、7、9、10,30 元能买到 4 + 5 + 7 + 7 = 23(4 件),再加 9 就是 32 > 30,还是 4 件。但这不是重点——重点是题目规定了"按顺序",所以必须按顺序模拟。
🟢 顺序模拟(唯一正确解) 推荐
按给定顺序遍历,买得起就扣钱计数
时间 O(N)
空间 O(N) 存价格
完全符合题意的行为规则
代码 10 行
💡为什么这是唯一正确解:题目描述的是小明的具体行为("按顺序看到、买得起就买"),不是"最多能买几件"。
🔴 排序后贪心
把价格排序,从最便宜的开始买
在本题是错误的
它求的是"最多能买几件"
与小明的实际行为不符
顺序信息被破坏
⚠️重要区别:"最多能买几件"和"小明实际买了几件"是两个不同的问题。本题问的是后者,所以不能排序。
📈 性能对比
方案是否符合题意说明
顺序模拟✅ 正确复现小明的真实行为
排序贪心❌ 错误改变了题目规定的顺序
第一行输入价格列表(空格分隔),第二行输入初始金额,程序会逐件模拟购买过程。
输入:第一行价格,第二行金额7 5 9 10 7 4
30
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int a[105];
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", &a[i]);
int X;
scanf("%d", &X);
int cnt = 0;
for (int i = 0; i < N; i++) { // 必须按给定顺序
if (X >= a[i]) { // 买得起(包含恰好等于)
X -= a[i]; // 扣钱
cnt++; // 计数
}
// 买不起就什么都不做,继续看下一件
}
printf("%d\n", cnt);
return 0;
}
🔑为什么用 >= 而不是 >?"能买得起"意味着价格不超过余额。如果余额恰好等于价格,也买得起(买完剩 0 元)。写成 > 会漏掉这种情况。
📖 关键几行怎么看
代码作用为什么这样写
for (int i = 0; i < N; i++)按顺序遍历顺序是题目规则的一部分,不能改
X >= a[i]判断买得起等于也买得起
X -= a[i]; cnt++;扣钱并计数两件事都要做,缺一不可
int X余额类型初始金额不大,int 足够
⚠️三个坑:① 排序后从便宜的开始买(改变了题目规定的行为顺序);② 判断写成 X > a[i],余额恰好等于价格时误判为买不起;③ 忘记扣钱 X -= a[i],导致后面错误地多买。
写完程序后,用这些数据自查一遍:
输入答案考察点
6
7 5 9 10 7 4
304题面样例
1
5
51余额恰好等于价格,仍然买得起
1
6
50差 1 元也买不起
3
1 2 3
00金额为 0,什么都买不起
3
0 0 0
03价格为 0 都能买(0 ≥ 0)
4
10 1 1 1
104买完第 1 件剩 0 元,但后面都是 0 元商品
3
5 5 5
142买两件花 10,剩 4 不够第三件
✅自查清单:① 是按顺序遍历的吗?② 判断用了 ≥ 吗?③ 买了之后扣钱了吗?
🚨 易错点清单
⚠️排序后贪心:虽然可能买到更多,但不符合题目描述的"按顺序"行为,本题必须顺序模拟。
⚠️判断写成严格大于:余额恰好等于价格时应判定为"买得起",所以要用 >=。
⚠️忘记扣钱:只计数不扣钱,会把后面买不起的也误判为买得起。
时间复杂度
O(N)
空间复杂度
O(N)
N 最大
100
运算量
100 次
时间怎么算的?
每件商品只看一次
做一次比较、最多两次赋值
合计 O(N)
空间都用在哪?
需要保存价格数组以便按顺序处理;其实也可以边读边判,但必须先读到 X,所以用数组更方便。
✅ N 只有 100,任何写法都瞬间完成;这题考的是读懂"行为规则"而不是想当然地求最优。
// 顺序模拟的通用骨架
int budget = X, cnt = 0;
for (int i = 0; i < N; i++) {
if (budget >= cost[i]) { // 满足条件就执行
budget -= cost[i];
cnt++;
}
// 不满足就跳过,什么都不做
}
// 对比:如果题目问的是"最多能买几件"
// 那就应该先排序再贪心
sort(cost, cost + N);
int best = 0, rest = X;
for (int i = 0; i < N; i++) {
if (rest >= cost[i]) { rest -= cost[i]; best++; }
}
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
顺序模拟按给定顺序判断执行所有"过程/行为"类模拟题
区分问题类型"实际行为"vs"最优解"读题时务必确认问的是哪一种
余额递减每次操作更新状态背包、预算、资源消耗类题目
🌟思考题:题目改成"求小明最多能买多少件"(允许调整顺序),答案会变成几件?(提示:把价格排序:4、5、7、7、9、10,30 元依次买 4、5、7、7 共 23,再加 9 就 32 超了,所以最多还是 4 件——但这只是巧合,很多数据下两种答案会不同。)
#include <bits/stdc++.h>
using namespace std;
int a[105];
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", &a[i]);
int X;
scanf("%d", &X);
int cnt = 0;
for (int i = 0; i < N; i++) { // 必须按给定顺序
if (X >= a[i]) { // 买得起(包含恰好等于)
X -= a[i]; // 扣钱
cnt++; // 计数
}
// 买不起就什么都不做,继续看下一件
}
printf("%d\n", cnt);
return 0;
}// 顺序模拟的通用骨架
int budget = X, cnt = 0;
for (int i = 0; i < N; i++) {
if (budget >= cost[i]) { // 满足条件就执行
budget -= cost[i];
cnt++;
}
// 不满足就跳过,什么都不做
}
// 对比:如果题目问的是"最多能买几件"
// 那就应该先排序再贪心
sort(cost, cost + N);
int best = 0, rest = X;
for (int i = 0; i < N; i++) {
if (rest >= cost[i]) { rest -= cost[i]; best++; }
}②编程打卡 · 点一下就能勾选
- 完成 B3867《小杨的储蓄》,跑通全部样例
- 完成 B3848《逛商场》,跑通全部样例
- 对比题解里的参考代码,找出自己写法的差异
枚举与判定
①本日知识点 · 枚举与判定
定范围、写条件、逐个试;能推出的量就别多写一层循环。
本组 4 道题全部来自 GESP 真题,按「枚举与判定」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。
现在有 N 个数,请你分别判断他们是否可能是二进制、八进制、十进制、十六进制。例如,15A6F 就只可能是十六进制,而 1011 则是四种进制皆有可能。
保证 1 ≤ N ≤ 1000,保证所有字符串长度不超过 10。
例如,对于只可能是十六进制数的 15A6F,就需要输出 0 0 0 1;而对于四者皆有可能的 1011,则需要输出 1 1 1 1。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 2 15A6F 1011 | 0 0 0 1 1 1 1 1 |
| 2 | 4 1234567 12345678 FF GG | 0 1 1 1 0 0 1 1 0 0 0 1 0 0 0 0 |
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
N 进制数逢 N 进一。十六进制用 A ~ F 表示 10 ~ 15。
给定 N 个由数字和大写字母组成的字符串(可能以 0 开头),分别判断它们是否可能表示二进制、八进制、十进制、十六进制数。输出 4 个 0/1,1 表示可能、0 表示不可能。
例如 15A6F 只可能是十六进制,输出 0 0 0 1;1011 四种都可能,输出 1 1 1 1。
💡人话翻译:一个 B 进制数里,每一位数字都必须小于 B。所以只要找出这个串里最大的那个数字,看它是否小于 2 / 8 / 10 / 16 就行了。不用真的去转换进制。
🔍 关键词提取
进制基础最大数字判据字符转数值四路判断
已知条件
项目说明
输入第一行 N;随后 N 行每行一个字符串
输出每行 4 个 0/1,分别对应 2、8、10、16 进制
数据范围N ≤ 1000,串长 ≤ 10
字符集数字与大写字母,可能以 0 开头
字母含义A = 10、B = 11、…、F = 15(十六进制惯例)
需要解决的问题
什么条件下可能?该进制下每一位都必须合法,即最大数字 < 进制基数
怎么求最大数字?把字符逐个转成数值,取最大值
字符怎么转数值?'0'~'9' 转 0 ~ 9;'A'~'Z' 转 10 ~ 35
📥 读入
N 个字符串
逐个独立判断
可能以 0 开头(无影响)
长度 ≤ 10
🔍 求最大数字
'0'~'9' → 0~9
'A'~'Z' → 10~35
遍历取最大值 maxDigit
O(L)
✅ 四路判断
2 进制:maxDigit < 2
8 进制:maxDigit < 8
10 进制:maxDigit < 10
16 进制:maxDigit < 16
⚠️ 易错点
误以为要真的转换
字母转换公式写错
输出顺序搞反
十六进制基数写成 15
我们把两组样例里的 6 个字符串都算一遍。先明确映射规则:'0' → 0,'9' → 9,'A' → 10,'F' → 15,'G' → 16。
1
15A6F
各字符数值:1、5、10、6、15
最大 = 15
2 进制:15 < 2?否
8 进制:15 < 8?否
10 进制:15 < 10?否
16 进制:15 < 16?是
输出 0 0 0 1
2
1011
各字符数值:1、0、1、1
最大 = 1
1 < 2 ✅、1 < 8 ✅、1 < 10 ✅、1 < 16 ✅
输出 1 1 1 1
3
FF
各字符数值:15、15
最大 = 15
只有 16 进制满足(15 < 16)
输出 0 0 0 1
4
GG
各字符数值:16、16
最大 = 16
16 < 16?不成立(必须严格小于基数)
输出 0 0 0 0(连十六进制都不行)
📊 汇总表
字符串最大数字2 进制8 进制10 进制16 进制
15A6F15(F)0001
101111111
123456770111
1234567880011
FF150001
GG160000
🔑两个关键点:① 判据是"严格小于"基数——所以 GG 的最大数字是 16,而 16 进制要求每位 < 16,于是连十六进制都不成立;② 二进制的基础判据是 < 2,所以只有由 0 和 1 组成的串才可能是二进制数。
🟢 最大数字判据(推荐) 推荐
求出串中最大数字,与 2、8、10、16 逐个比较
时间 O(N × L)
只需一次遍历
不需要任何进制转换
代码 12 行
💡为什么等价:"该串是合法的 B 进制数"⇔"每一位数字都 < B"⇔"最大数字 < B"。三种说法完全等价,取最好算的那个。
🟠 真的去转换进制
把字符串按各进制尝试转换,看是否溢出或报错
需要处理溢出判断
代码复杂得多
结果还受数值范围影响
完全不必要
⚠️注意:题目问的是"是否可能表示",重点在数字位是否合法,与数值大小无关。比如 1111111111(十个 1)远超 int,但它确实可能是二进制数。
📈 性能对比
方案代码量是否需转换
最大数字判据约 12 行不需要
真实转换约 30 行以上需要
每行输入一个由数字和大写字母组成的串,程序会给出它在 2/8/10/16 进制下是否可能。
输入字符串(每行一个)15A6F
1011
1234567
FF
GG
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
// 字符 -> 数值:'0'~'9' 为 0~9,'A'~'Z' 为 10~35
int charToVal(char c) {
if (c >= '0' && c <= '9') return c - '0';
return c - 'A' + 10;
}
int main() {
int N;
scanf("%d", &N);
char s[20];
while (N--) {
scanf("%s", s);
int maxD = 0;
for (int i = 0; s[i]; i++) {
int v = charToVal(s[i]);
if (v > maxD) maxD = v;
}
// 依次判断 2、8、10、16 进制是否可能
printf("%d %d %d %d\n",
maxD < 2 ? 1 : 0,
maxD < 8 ? 1 : 0,
maxD < 10 ? 1 : 0,
maxD < 16 ? 1 : 0);
}
return 0;
}
🔑判据为什么是"严格小于"?B 进制里可用的数字是 0 ~ B−1,共 B 个。所以每一位都必须 ≤ B − 1,也就是 < B。例如八进制只能用 0 ~ 7,出现 8 就不合法。
📖 关键几行怎么看
代码作用为什么这样写
c - '0'数字字符转数值'0' 的 ASCII 是 48,相减即得数值
c - 'A' + 10字母转数值A 对应 10,所以减 'A' 后加 10
maxD < 2 ? 1 : 0三目判断一行输出一个结论,简洁
for (int i = 0; s[i]; i++)遍历字符串以 '\0' 为结束标志,字符串题常用写法
⚠️三个坑:① 把十六进制基数写成 15(应该是 16);② 输出顺序不是"二进制、八进制、十进制、十六进制";③ 用 <= 代替 <,会把 GG(最大数字 16)误判成合法十六进制数。
写完程序后,用这些数据自查一遍:
输入答案考察点
15A6F0 0 0 1含 F(15),只可能是十六进制
10111 1 1 1全是 0/1,四种都可能
12345670 1 1 1最大 7,八进制起可能
123456780 0 1 1最大 8,八进制不行了
FF0 0 0 1最大 15
GG0 0 0 0最大 16,连十六进制都不满足(要求 < 16)
✅自查清单:① 拿到的是最大数字吗?② 比较用的是严格小于吗?③ 四个输出顺序对吗?
🚨 易错点清单
⚠️边界写成 <=:必须严格小于。GG 的最大数字是 16,16 < 16 不成立,所以输出 0 0 0 0。
⚠️字母转换公式写错:是 c - 'A' + 10,漏掉 +10 会把 F 算成 5。
⚠️输出顺序记错:题目要求按 二进制、八进制、十进制、十六进制 的顺序。
时间复杂度
O(N × L)
空间复杂度
O(L)
N 最大
1000
L 最大
10
时间怎么算的?
每个字符串遍历一次求最大数字,O(L)
N 个字符串共 O(N × L)
最坏 1000 × 10 = 10⁴ 次
空间都用在哪?
只需要存当前字符串(长度 ≤ 10)。
✅ 最多 1 万次字符处理,瞬间完成。
// 字符与数值互转(进制题必备)
int charToVal(char c) {
if (c >= '0' && c <= '9') return c - '0';
return c - 'A' + 10; // A=10 … Z=35
}
char valToChar(int v) {
if (v < 10) return char('0' + v);
return char('A' + v - 10);
}
// 判断一个串在 B 进制下是否合法
bool validInBase(const string &s, int B) {
for (char c : s) if (charToVal(c) >= B) return false;
return true;
}
// 任意进制转十进制(了解即可)
long long toDecimal(const string &s, int B) {
long long r = 0;
for (char c : s) r = r * B + charToVal(c);
return r;
}
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
字符与数值互转数字/字母统一映射到数值所有进制相关题目
"边界即判据"用最大数字判断进制合法性进制判断、编码校验题
严格小于合法数字范围是 0 ~ B−1所有涉及"取值范围"的判断
🌟思考题:如果题目改成"判断字符串是否恰好是某进制的规范表示"(比如不允许前导零、且首位不能是 0),判据要加什么条件?(提示:再加一条"如果长度 > 1 则首位不能是 '0'"即可。)
#include <bits/stdc++.h>
using namespace std;
// 字符 -> 数值:'0'~'9' 为 0~9,'A'~'Z' 为 10~35
int charToVal(char c) {
if (c >= '0' && c <= '9') return c - '0';
return c - 'A' + 10;
}
int main() {
int N;
scanf("%d", &N);
char s[20];
while (N--) {
scanf("%s", s);
int maxD = 0;
for (int i = 0; s[i]; i++) {
int v = charToVal(s[i]);
if (v > maxD) maxD = v;
}
// 依次判断 2、8、10、16 进制是否可能
printf("%d %d %d %d\n",
maxD < 2 ? 1 : 0,
maxD < 8 ? 1 : 0,
maxD < 10 ? 1 : 0,
maxD < 16 ? 1 : 0);
}
return 0;
}// 字符与数值互转(进制题必备)
int charToVal(char c) {
if (c >= '0' && c <= '9') return c - '0';
return c - 'A' + 10; // A=10 … Z=35
}
char valToChar(int v) {
if (v < 10) return char('0' + v);
return char('A' + v - 10);
}
// 判断一个串在 B 进制下是否合法
bool validInBase(const string &s, int B) {
for (char c : s) if (charToVal(c) >= B) return false;
return true;
}
// 任意进制转十进制(了解即可)
long long toDecimal(const string &s, int B) {
long long r = 0;
for (char c : s) r = r * B + charToVal(c);
return r;
}$(x \operatorname{and} y) + (x \operatorname{or} y) = 2025
其中 \operatorname{and} 表示二进制按位与运算,\operatorname{or} 表示二进制按位或运算。如果不存在满足条件的 y,则输出 -1$。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 1025 | 1000 |
$(x \operatorname{and} y) + (x \operatorname{or} y) = 2025
其中:
- \operatorname{and} 表示按位与运算,运算符为 \&。
- \operatorname{or} 表示按位或运算,运算符为 |$。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定整数 x,找最小的正整数 y,使得
(x and y) + (x or y) = 2025
其中 AND 是按位与(&),OR 是按位或(|)。如果不存在满足条件的 y,输出 −1。
💡人话翻译:别急着枚举 y(那个范围太大了)。这题的钥匙是一个恒等式:(x AND y) + (x OR y) = x + y。等式一旦化简,答案就一目了然了。
🔍 关键词提取
按位与按位或位运算恒等式化简
已知条件
项目说明
输入一行一个整数 x
输出最小的正整数 y,或 −1
数据范围0 ≤ x < 2025
关键恒等式(x & y) + (x | y) = x + y
需要解决的问题
怎么化简等式?用恒等式把左边换成 x + y,方程立刻变成 x + y = 2025
y 是多少?y = 2025 − x,答案唯一
什么时候输出 −1?当 2025 − x ≤ 0 时(本题数据保证 x < 2025,所以总是有解)
📥 读入
读入整数 x
范围 0 ≤ x < 2025
不需要循环枚举
计算用 int 足够
🔑 恒等式
(x&y) + (x|y) = x + y
逐位相加可证
与"1的个数"无关
是本题唯一钥匙
🧮 求解
x + y = 2025
y = 2025 − x
答案唯一
y 必然 ≥ 1
⚠️ 边界
x = 0 → y = 2025
x = 2024 → y = 1
x ≥ 2025 时无解
本题保证有解
位运算的特点是可以逐位拆开看。对某一位,设 x 的该位是 a、y 的该位是 b,两者都只能取 0 或 1。把四种情况全部列出来:
x 的该位 ay 的该位 ba AND ba OR bAND + ORa + b是否相等
000000✅
010111✅
100111✅
111122✅
四种情况全部成立,说明每一位都满足;而位与位之间没有进位干扰(这一位的结果不依赖其它位),所以整体相加也相等:
(x AND y) + (x OR y) = x + y
🔑这个恒等式的直觉:两位都是 1 时,AND 贡献 1、OR 贡献 1,加起来 2;一位是 1 时,AND 给 0、OR 给 1,加起来 1;两位都是 0 时都是 0。所以 AND + OR 恰好把每个 1 数了两遍,等于 x + y。
🧮 用样例验证:x = 1025
样例输入 x = 1025,输出 1000。我们用两种方式对照。
1
方法一:套恒等式
x + y = 2025 → y = 2025 − 1025 = 1000
✅ y = 1000
2
方法二:硬验证
1025 的二进制 = 10000000001₂
1000 的二进制 = 1111101000₂
AND = 10000000000₂ = 1024
OR = 1111101001₂ = 1001
1024 + 1001 = 2025 ✓
✅ 恒等式成立,答案正确
x计算 2025 − x输出
020252025
102510001000
202411
2025(超范围)0 → 不是正整数−1
⚠️为什么不用枚举?y 理论上可以取到很大(要满足 x + y = 2025 才是解),但暴力枚举 y 从 1 开始一位一位地试位运算,既慢又没有意义——化简之后答案根本不需要搜索。
🟢 套恒等式(推荐) 推荐
把左边化简为 x + y,直接解出 y = 2025 − x
时间 O(1)
一行表达式
不依赖数据范围
还能写成通用形式
💡通用写法:y = target − x,若 y ≤ 0 则输出 −1。本题把 target 换成任意数都成立。
🟠 枚举 y 并验证等式
从 y = 1 开始逐个试 (x AND y) + (x OR y)
需要知道枚举上界
上界不好确定(y 可以很大)
单次验证 O(log) 位
实际上可能枚举不到解
⚠️为什么不可行:满足条件的 y 可能远大于 2025?不——由恒等式可知 y = 2025 − x 是唯一解。但在不知道恒等式的情况下,枚举范围无法确定,容易写成死循环。
📈 性能对比
方案运算量代码量
套恒等式1 次减法3 行
枚举验证上界不明10 行以上
输入 x,程序会给出 y = 2025 − x,并逐位展示 (x AND y) + (x OR y) 确实等于 2025。
输入 x
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
int x;
scanf("%d", &x);
// 利用恒等式 (x & y) + (x | y) = x + y
// 原式等价于 x + y = 2025
int y = 2025 - x;
if (y >= 1) printf("%d\n", y);
else printf("-1\n");
return 0;
}
🔑为什么输出 −1 的分支几乎不会走到?题目保证 x < 2025,所以 2025 − x ≥ 1 恒成立。但把判断写上更稳妥——万一数据范围变了,代码依然正确。这是"防御性编程"的好习惯。
📖 关键几行怎么看
代码作用为什么这样写
int y = 2025 - x;直接求解恒等式化简后的唯一解
if (y >= 1)判断是否为正整数y = 0 不是正整数
printf("-1\n")输出无解题目要求的特殊值
⚠️别被"最小"两个字带偏:题目说"最小的正整数 y",看起来需要搜索最小解;但恒等式决定了 y 只有一个可能值,所以它自动就是最小的。
写完程序后,用这些数据自查一遍:
输入答案考察点
10251000题面样例
02025x = 0 时 y 取到最大
20241y 取到最小的正整数 1
12024普通情况
2025−1超出数据范围,验证 −1 分支
✅自查清单:① 用的是 (x AND y) + (x OR y) 吗?② y 是否要求 ≥ 1?③ 无解时输出 −1 吗?
🚨 易错点清单
⚠️真的去枚举 y:不知道上界时容易写成死循环。本题必须用恒等式化简。
⚠️把 y = 0 当成合法:题目要求 y 是正整数,所以 2025 − x = 0 时要输出 −1。
⚠️笔误写成 x + y == 2025 以外的式子:恒等式左边是 AND + OR,注意别写成 AND − OR 或 AND × OR。
时间复杂度
O(1)
空间复杂度
O(1)
运算量
1 次减法
枚举需求
无
时间怎么算的?
只需一次减法运算
没有任何循环,与数据规模无关
所以是常数时间 O(1)
空间都用在哪?
只用 x、y 两个整数变量。
✅ 这题的价值不在效率,而在发现并运用位运算恒等式——把一道看起来要搜索的题变成一行减法。
// 常用位运算恒等式(都很有用)
// (x & y) + (x | y) = x + y AND + OR 抵消
// (x | y) - (x & y) = x ^ y 异或 = 或 - 与
// x & y = (x + y - (x ^ y)) / 2 由上面两式推得
// x | y = (x + y + (x ^ y)) / 2
// 常用位运算操作
int lowbit = x & (-x); // 取最低位的 1
int cnt1 = __builtin_popcount(x);
bool pow2 = (x > 0) && ((x & (x - 1)) == 0); // 判断 2 的幂
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
位运算逐位分析把每一位的 4 种情况列全所有位运算等式/不等式的证明
恒等式化简(x&y)+(x|y) → x+y位运算与算术混合的题目
防御性编程把 −1 分支写上以防万一所有有"无解"输出的题目
🌟思考题:如果题目改成 (x AND y) − (x OR y) = 2025,还能化简吗?先用逐位表格列出四种情况,你会发现 AND − OR 只能取 0 或 −1,所以左边永远是非正数,绝不可能等于正的 2025 —— 答案直接是"无解"。
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
scanf("%d", &x);
// 利用恒等式 (x & y) + (x | y) = x + y
// 原式等价于 x + y = 2025
int y = 2025 - x;
if (y >= 1) printf("%d\n", y);
else printf("-1\n");
return 0;
}// 常用位运算恒等式(都很有用) // (x & y) + (x | y) = x + y AND + OR 抵消 // (x | y) - (x & y) = x ^ y 异或 = 或 - 与 // x & y = (x + y - (x ^ y)) / 2 由上面两式推得 // x | y = (x + y + (x ^ y)) / 2 // 常用位运算操作 int lowbit = x & (-x); // 取最低位的 1 int cnt1 = __builtin_popcount(x); bool pow2 = (x > 0) && ((x & (x - 1)) == 0); // 判断 2 的幂
给定 n 个非负整数 c_1, c_2, …, c_n 代表所传输的数据,它们的校验码取决于这些整数在二进制下 1 的数量之和的奇偶性。如果这些整数在二进制下共有奇数个 1,那么校验码为 1;否则校验码为 0。你能求出这些整数的校验码吗?
第二行,n 个非负整数 c_1, c_2, …, c_n,表示所传输的数据。
第一个整数表示 c_1, c_2, …, c_n 在二进制下 1 的总数量;
第二个整数表示校验码(0 或 1)。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 4 71 69 83 80 | 13 1 |
| 2 | 6 1 2 4 8 16 32 | 6 0 |
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定 n 个非负整数 c₁, c₂, …, cₙ。它们的校验码取决于这些整数在二进制下 1 的数量之和的奇偶性:
如果共有奇数个 1,校验码为 1
否则(偶数个 1),校验码为 0
输出两个整数:1 的总个数、校验码。
💡人话翻译:把每个数都写成二进制,数一数一共有多少个 1,记这个总和为 S。然后看 S 是奇数还是偶数:奇数输出 1,偶数输出 0。这题是"数位统计"的入门题。
🔍 关键词提取
二进制popcount奇偶判断位运算
已知条件
项目说明
输入第一行 n;第二行 n 个非负整数
输出两个整数:1 的总个数、校验码
数据范围1 ≤ n ≤ 100
数值范围0 ≤ cᵢ ≤ 255(即最多 8 位二进制)
需要解决的问题
怎么数一个数里有几个 1?三种常见写法:逐位移位、x &= x - 1 技巧、库函数 __builtin_popcount
怎么判断奇偶?对总和取模 2,或看最低位 S & 1
0 怎么办?0 的二进制里没有 1,贡献 0,不需要特判
📥 读入
n 和 n 个数
总和 total = 0
每个数最多 8 位
循环累加
🔍 数 1 的方法
逐位:x & 1 后右移
快速:x &= x − 1
库函数:popcount
三种都对
✅ 判奇偶
total 是奇数 → 输出 1
total 是偶数 → 输出 0
等价于 total & 1
total % 2 也行
⚠️ 注意点
0 不做特殊处理
输出两个数用空格分隔
先输出总数再输出校验码
顺序别写反
把每个数拆成二进制,数一数各有几个 1。
1
71 的二进制
71 = 64 + 4 + 2 + 1 = 1000111₂
数一数:1 0 0 0 1 1 1 → 有 4 个 1
贡献 4
2
69 的二进制
69 = 64 + 4 + 1 = 1000101₂
1 0 0 0 1 0 1 → 有 3 个 1
贡献 3
3
83 的二进制
83 = 64 + 16 + 2 + 1 = 1010011₂
1 0 1 0 0 1 1 → 有 4 个 1
贡献 4
4
80 的二进制
80 = 64 + 16 = 1010000₂
1 0 1 0 0 0 0 → 有 2 个 1
贡献 2
5
汇总判断
总数 = 4 + 3 + 4 + 2 = 13
13 是奇数
✅ 校验码 = 1,输出 "13 1"
📊 逐个统计
数值二进制1 的个数累计
71100011144
69100010137
831010011411
801010000213
🔑13 是奇数 → 校验码 1。如果总和是偶数,校验码就是 0,这就是"偶校验"的含义:让 1 的总个数保持偶数。
🧮 样例 2:1 2 4 8 16 32,答案 6 0
这组数据都是 2 的幂,每个数的二进制里恰好只有一个 1。
数值二进制1 的个数
111
2101
41001
810001
16100001
321000001
💡观察:2 的幂(1, 2, 4, 8, 16, …)在二进制里必定只有 1 个 1,这是个很实用的性质。6 个数 → 总数 6 → 偶数 → 校验码 0。
🟢 x &= x − 1 技巧(推荐) 推荐
每次消掉最低位的 1,循环次数 = 1 的个数
循环次数等于 1 的个数
本题最多 8 次
不需要移位运算
代码短
💡原理:x − 1 会把最低位的那个 1 变成 0、并把它右边的 0 全部变成 1,两者相与就恰好消掉最低位的 1。
🔵 __builtin_popcount
GCC 内置函数,直接返回 1 的个数
一行搞定,最快
但属于编译器扩展
有些评测环境不支持
考试时慎用
⚠️提示:GESP/NOI 通常用 GCC,可以放心用;但为了保险,建议同时会写手写版本。
📈 性能对比
写法本题运算量可移植性
x &= x − 1最多 800 次⭐⭐⭐⭐⭐
逐位移位最多 800 次⭐⭐⭐⭐⭐
popcount100 次⭐⭐⭐(依赖编译器)
输入若干个 0 ~ 255 的整数,程序会给出每个数的二进制、1 的个数,以及总校验码。
输入
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int total = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
// 数二进制中 1 的个数:每次消掉最低位的 1
while (x > 0) {
x &= (x - 1);
total++;
}
}
int check = total % 2; // 奇数 -> 1,偶数 -> 0
printf("%d %d\n", total, check);
return 0;
}
🔑为什么 x &= x - 1 能数出 1 的个数?
举例 x = 12 = 1100₂:
x − 1 = 1011₂,相与得 1000₂(消掉了最低位的 1)
x − 1 = 0111₂,相与得 0000₂(又消掉一个 1)
共执行 2 次 → 12 里有 2 个 1。循环次数正好等于 1 的个数。
📖 三种写法对照
写法代码特点
逐位移位while (x) { c += x & 1; x >>= 1; }最直观,固定循环位数次
消位技巧while (x) { x &= x - 1; c++; }循环次数 = 1 的个数,效率更高
库函数c = __builtin_popcount(x);一行完成,但依赖 GCC 扩展
⚠️注意输出顺序:题目要求先输出"1 的总数量",再输出"校验码"。写成 printf("%d %d", check, total) 就反了。
写完程序后,用这些数据自查一遍:
输入答案考察点
1
00 00 里没有 1,总数 0 是偶数
1
11 1单个 1,奇数
1
2558 0255 = 11111111₂,8 个 1
4
71 69 83 8013 1题面样例 1
6
1 2 4 8 16 326 0题面样例 2,都是 2 的幂
✅自查清单:① 0 会不会被少数或多数?② 输出顺序对不对?③ 用 total % 2 求校验码了吗?
🚨 易错点清单
⚠️把 0 当成特殊情况:0 的二进制没有 1,用 while (x > 0) 自动跳过,不需要特判;如果用 do-while 就会多加一次。
⚠️输出顺序写反:先总数、后校验码。
⚠️校验码判断写错:"总数为奇数 → 1",即 total % 2,不要写成 (total + 1) % 2。
时间复杂度
O(n × 位数)
空间复杂度
O(1)
n 最大
100
每数位数
最多 8
时间怎么算的?
外层循环 n 个数
内层用 x &= x − 1 或移位,最多循环"二进制位数"次(本题 ≤ 8)
合计 O(n × 位数),最坏 100 × 8 = 800 次
空间都用在哪?
只需要 total 和循环变量两个整数。
✅ 最坏不到 1000 次操作,任何写法都远远够快。
// 数 1 的三种写法
int countOnes1(int x) { int c=0; while(x){ c += x & 1; x >>= 1; } return c; }
int countOnes2(int x) { int c=0; while(x){ x &= (x-1); c++; } return c; }
int countOnes3(int x) { return __builtin_popcount(x); }
// 判断奇偶的三种写法(等价)
bool odd1 = (total % 2 == 1);
bool odd2 = (total & 1);
bool odd3 = (total % 2 != 0);
// 相关位运算技巧
// x & -x 取最低位的 1
// x | (x-1) 把最低位起的 0 全变 1
// x ^ (x-1) 取最低位 1 及其右边的所有位
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
二进制表示把十进制拆成 0/1 序列进制转换、位运算、状态压缩
x &= x − 1 技巧快速数 1 的个数位计数、判断是否为 2 的幂
奇偶判断总数取模 2校验码、奇偶分类、布隆过滤思想
🌟思考题:奇偶校验只能检测出"奇数个位出错",如果传输中同时错了 2 位,校验码就发现不了。有没有更强的校验方式?(提示:查 CRC 校验、汉明码,汉明码能定位并纠正 1 位错误。)
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int total = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
// 数二进制中 1 的个数:每次消掉最低位的 1
while (x > 0) {
x &= (x - 1);
total++;
}
}
int check = total % 2; // 奇数 -> 1,偶数 -> 0
printf("%d %d\n", total, check);
return 0;
}// 数 1 的三种写法
int countOnes1(int x) { int c=0; while(x){ c += x & 1; x >>= 1; } return c; }
int countOnes2(int x) { int c=0; while(x){ x &= (x-1); c++; } return c; }
int countOnes3(int x) { return __builtin_popcount(x); }
// 判断奇偶的三种写法(等价)
bool odd1 = (total % 2 == 1);
bool odd2 = (total & 1);
bool odd3 = (total % 2 != 0);
// 相关位运算技巧
// x & -x 取最低位的 1
// x | (x-1) 把最低位起的 0 全变 1
// x ^ (x-1) 取最低位 1 及其右边的所有位二进制位从右向左编号为 0,1,2,…。若某个整数的二进制表示中没有第 k 位,则认为它的第 k 位为 0。
请你求出满足条件的二进制位数量。
- 第二行 n 个非负整数 a_1,a_2,…,a_n。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 3 13 7 15 | 2 |
三个整数的二进制表示分别为 (1101)_2、(0111)_2 和 (1111)_2。
其中第 0 位和第 2 位均为 1,因此答案为 2。
数据范围
2≤ n≤ 20000,0≤ a_i≤ 10^9。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定 n 个非负整数。把它们都转换为二进制后,请统计有多少个二进制位在所有整数中均为 1。
二进制位从右向左编号 0、1、2……;若某个整数没有第 k 位,则视为 0。
例如 13、7、15 的二进制分别是 1101、0111、1111,第 0 位和第 2 位都是 1,所以答案是 2。
💡人话翻译:把所有的数叠在一起看,找出那些"每一位上都写着 1"的列。这恰好就是"全部按位与"的结果:AND 只有在所有数该位都是 1 时才为 1。
🔍 关键词提取
按位与 AND数二进制中 1 的个数逐位判定位运算
已知条件
项目说明
输入第一行 n;第二行 n 个非负整数
输出所有整数公共为 1 的位数
数据范围2 ≤ n ≤ 20000
数值范围0 ≤ aᵢ ≤ 10⁹(最多 30 位)
需要解决的问题
两种思路?① 逐位检查"是否所有数的这一位都是 1";② 直接对所有数做按位与,再数结果里 1 的个数
哪种更好?第二种代码更短,因为 AND 运算天然表达了"所有数都为 1"
要注意什么?aᵢ 可达 10⁹,30 位足够;用 int 即可(10⁹ < 2³⁰)
📥 读入
n 个整数
可达 10⁹(约 30 位)
int 足够
n 可达 20000
🔗 两种思路
思路一:逐位检查所有数
思路二:全部按位与
两者等价
思路二更简洁
🔢 数 1 的个数
x &= x − 1 循环
或 __builtin_popcount
或逐位移位
最多 30 次
⚠️ 易错点
误以为要统计"任意数为1"
用 int 但 aᵢ 超范围(本题不会)
n = 2 的边界
含 0 时答案必为 0
把三个数按位对齐写出来,逐列看是否"全是 1"。
位号13 = 11017 = 011115 = 1111全是 1?
第 3 位101❌(7 是 0)
第 2 位111✅
第 1 位011❌(13 是 0)
第 0 位111✅
1
逐位检查
第 0 位:13、7、15 都是 1 ✅
第 1 位:13 是 0,不满足 ❌
第 2 位:全都是 1 ✅
第 3 位:7 是 0,不满足 ❌
✅ 满足的位有第 0 位和第 2 位,共 2 个
2
用 AND 验证
13 AND 7 = 1101 & 0111 = 0101
0101 AND 15 = 0101 & 1111 = 0101
结果 0101 中有 2 个 1
✅ 与逐位检查结果一致
🔑为什么"全部 AND"等价于"逐位检查"?AND 的规则是"两位都为 1 结果才是 1"。把所有数依次 AND 起来,某一位最终为 1 ⟺ 每一个数在该位都是 1。这正好就是题目要的条件。
🧮 几个边界情形
输入二进制AND 结果答案说明
1 11 / 111两个相同的 1
7 7 7111 反复1113完全相同的数
5 0101 / 000只要有一个 0,答案必为 0
8 4 2 11000 / 0100 / 0010 / 000100没有一位重合
6 7110 / 1111102公共的两位
💡一个重要推论:只要序列里出现了 0,那么 AND 的结果必然是 0(0 的每一位都是 0),答案就是 0。可以据此提前返回。
🟢 全局 AND 再数 1(推荐) 推荐
把所有数依次按位与,最后统计结果中 1 的个数
时间 O(n)
代码 8 行
逻辑最贴切题意
不需要关心位数上限
💡实现要点:先把答案初始化为第一个数,然后依次与后面的数做 AND,最后用 x &= x − 1 数 1 的个数。
🟠 逐位扫描
对第 0 ~ 30 位,各自检查是否所有数该位都为 1
时间 O(n × 30)
代码略长
需要知道位数上限
结果等价
⚠️也能过:n = 20000 时 20000 × 30 = 6 × 10⁵ 次运算,完全可行。但从表达力上看,AND 写法更直接。
📈 性能对比
方案运算量(n=20000)代码量
全局 AND约 2 × 10⁴ 次约 8 行
逐位扫描约 6 × 10⁵ 次约 15 行
输入若干非负整数,程序会列出它们的二进制、逐步求 AND,并统计公共为 1 的位数。
输入
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int res;
scanf("%d", &res); // 先读第一个数作为初始值
for (int i = 1; i < n; i++) {
int x;
scanf("%d", &x);
res &= x; // 依次按位与,等价于"所有数都为 1 的位"
}
// 统计 res 中 1 的个数
int cnt = 0;
while (res > 0) {
res &= (res - 1); // 每次消掉最低位的 1
cnt++;
}
printf("%d\n", cnt);
return 0;
}
🔑为什么 res 要用第一个数初始化,而不是 0?如果初始化成 0,那么 0 AND 任何数 = 0,结果永远是 0,答案就永远错了。AND 运算的"单位元"是全 1,不是 0,所以必须用第一个数(或全 1 的掩码)来初始化。
📖 关键几行怎么看
代码作用为什么这样写
scanf("%d", &res)读第一个数当初始值AND 不能用 0 初始化
res &= x累积按位与一步就表达"与所有数都成立"
res &= (res - 1)消掉最低位的 1循环次数等于 1 的个数
while (res > 0)数 1 的循环res 变成 0 就说明数完了
⚠️两个坑:① 把 res 初始化为 0,导致答案永远是 0;② 理解成"有多少个位至少在一个数里是 1"(那应该用 OR,而题目要求的是所有数都为 1,所以用 AND)。
写完程序后,用这些数据自查一遍:
输入答案考察点
3
13 7 152题面样例
2
1 11两个 1,公共位只有第 0 位
3
7 7 73完全相同的数
2
5 00含 0 时答案必为 0
4
8 4 2 10没有任何一位重合
2
6 72110 与 111 的公共位
✅自查清单:① res 用第一个数初始化了吗?② 用的是 AND 不是 OR 吗?③ 数 1 的循环写对了吗?
🚨 易错点清单
⚠️res 初始化为 0:0 AND 任何数都是 0,答案永远为 0。必须用第一个数初始化。
⚠️把 AND 写成 OR:题目要的是"所有数都为 1",对应 AND;OR 得到的是"至少一个数为 1",含义完全不同。
⚠️位数上限假设过窄:aᵢ 可达 10⁹,需要考虑到第 29 位左右,不要只想到 8 位。
时间复杂度
O(n)
空间复杂度
O(1)
n 最大
20000
位数
最多 30
时间怎么算的?
读入并 AND:n − 1 次位运算
数 1 的个数:最多 30 次
合计 O(n)
空间都用在哪?
只用 res 一个变量,不需要保存整个数组。
✅ 2 万次运算,瞬间完成;这题考的是认出不变量:"公共为 1"就是按位与。
// 位运算"归纳"三个常用操作
int AND_all = a[0]; for (int i=1;i<n;i++) AND_all &= a[i]; // 所有位都为 1
int OR_all = a[0]; for (int i=1;i<n;i++) OR_all |= a[i]; // 至少一个为 1
int XOR_all = a[0]; for (int i=1;i<n;i++) XOR_all ^= a[i]; // 出现奇数次的位
// 数 1 的个数
int cnt1(int x){ int c=0; while(x){ x &= (x-1); c++; } return c; }
// 判断第 k 位是否为 1
bool bitK(int x, int k) { return (x >> k) & 1; }
// 注意:AND 的初始值不能用 0(0 会把一切抹平)
// 若必须初始化,用全 1 掩码:
int MASK = ~0; // 全 1
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
按位与的归纳AND 所有数 = 公共为 1 的位公共子串位、权限交集、状态压缩
按位或的归纳OR 所有数 = 至少一个为 1 的位权限并集、字母出现标记
位计数技巧x &= x−1所有需要统计二进制 1 的题
🌟思考题:如果把问题改成"有多少个位至少在一个数里是 1",代码要改哪一处?答案会变大还是变小?(提示:把 AND 改成 OR 即可,答案一定不会变小——因为"至少一个"的条件比"全部"更宽松。)
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int res;
scanf("%d", &res); // 先读第一个数作为初始值
for (int i = 1; i < n; i++) {
int x;
scanf("%d", &x);
res &= x; // 依次按位与,等价于"所有数都为 1 的位"
}
// 统计 res 中 1 的个数
int cnt = 0;
while (res > 0) {
res &= (res - 1); // 每次消掉最低位的 1
cnt++;
}
printf("%d\n", cnt);
return 0;
}// 位运算"归纳"三个常用操作
int AND_all = a[0]; for (int i=1;i<n;i++) AND_all &= a[i]; // 所有位都为 1
int OR_all = a[0]; for (int i=1;i<n;i++) OR_all |= a[i]; // 至少一个为 1
int XOR_all = a[0]; for (int i=1;i<n;i++) XOR_all ^= a[i]; // 出现奇数次的位
// 数 1 的个数
int cnt1(int x){ int c=0; while(x){ x &= (x-1); c++; } return c; }
// 判断第 k 位是否为 1
bool bitK(int x, int k) { return (x >> k) & 1; }
// 注意:AND 的初始值不能用 0(0 会把一切抹平)
// 若必须初始化,用全 1 掩码:
int MASK = ~0; // 全 1②编程打卡 · 点一下就能勾选
- 完成 B3868《进制判断》,跑通全部样例
- 完成 B4261《2025》,跑通全部样例
- 完成 B4358《奇偶校验》,跑通全部样例
- 完成 B4577《公共二进制位》,跑通全部样例
- 对比题解里的参考代码,找出自己写法的差异
数组与下标
①本日知识点 · 数组与下标
下标 0 起,先画下标与值的对应表,再写循环。
本组 11 道题全部来自 GESP 真题,按「数组与下标」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。
如果 x 是完全平方数,则存在非负整数 y 使得 y × y = x。
第二入行包含 n 个非负整数 A_1, A_2, … A_n,表示序列 A 包含的非负整数。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 5 1 4 3 3 5 | 3 |
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定含 n 个非负整数的序列 A,求有多少对下标组合 ⟨i, j⟩(1 ≤ i < j ≤ n)使得 Aᵢ + Aⱼ 是完全平方数。
如果 x 是完全平方数,则存在非负整数 y 使 y × y = x。
💡人话翻译:两两配对(共 n(n−1)/2 对),把每对的和算出来,看它是不是某个整数的平方(如 0、1、4、9、16、25 …)。统计满足条件的对数。
🔍 关键词提取
枚举数对完全平方数判定浮点精度long long
已知条件
项目说明
输入第一行 n;第二行 n 个非负整数
输出满足条件的对数
数据范围1 ≤ n ≤ 1000
数值范围0 ≤ Aᵢ ≤ 10⁵
和的范围最大 2 × 10⁵,其平方根约 447
需要解决的问题
怎么枚举所有数对?两重循环:外层 i,内层 j 从 i+1 开始
怎么判完全平方?int s = sqrt(x); 后检查 s * s == x
会不会有精度问题?会有!sqrt 返回浮点数,结果可能差 1,要截断后再回代验证
📥 读入
n 和 n 个数
用 long long 更稳
和可能到 2×10⁵
编号从 0 或 1 都行
🔁 枚举数对
外层 i 从 0 到 n−2
内层 j 从 i+1 到 n−1
保证 i < j 不重不漏
共 n(n−1)/2 对
✅ 判平方
s = (int)sqrt(x)
检查 s * s == x
必要时 s±1 再验一次
不要直接用 sqrt 比较
⚠️ 易错点
sqrt 浮点误差漏解
i、j 重复计数
忘记 0 也是完全平方数
int 溢出风险
n = 5,共有 5 × 4 / 2 = 10 对。我们逐对算和、判平方。
数对AᵢAⱼAᵢ + Aⱼ是否完全平方数
(1,2)145❌(2² = 4,3² = 9)
(1,3)134✅ 2² = 4
(1,4)134✅ 2² = 4
(1,5)156❌
(2,3)437❌
(2,4)437❌
(2,5)459✅ 3² = 9
(3,4)336❌
(3,5)358❌
(4,5)358❌
1
注意第 3、4 对
A 里有两个 3(下标 3 和 4)
它们和 1 配对都得到 4,所以要各算一次
答案是 3 对而不是 2 对
❗ 下标不同的相同数值要分别计数
🔑为什么是"下标对"而不是"数值对"?题目说的是 ⟨i, j⟩ 下标组合,所以 A₃ = 3 与 A₄ = 3 是两个不同的元素,分别与 1 组成的数对要各算一次。写双重循环时天然满足这个要求。
🧮 关于 sqrt 的精度问题
直接比较 sqrt(x) == (int)sqrt(x) 是有风险的,我们用一个具体例子说明。
检查方式代码结果
错误写法if (sqrt(x) == (int)sqrt(x))浮点误差可能让 9 算成 2.9999999
正确写法int s = (int)sqrt(x); if (s * s == x)✅ 用整数乘法回验
更保险for (s-1; s+1; s++) if (s*s == x)容忍 ±1 的误差,最稳
⚠️为什么会有误差?sqrt 返回 double,像 9、16 这种数在某些实现下可能返回 2.9999999999999996,直接 (int) 截断就变成 2,平方后是 4 ≠ 9,于是漏掉一个正确答案。正确做法是截断后用整数乘法回验。
🟢 枚举数对 + 回验(推荐) 推荐
双重循环枚举所有数对,用 sqrt 截断后回验
时间 O(n²)
n = 1000 时约 5 × 10⁵ 对
不需要额外空间
代码最直白
💡为什么够用:n ≤ 1000 时总共约 50 万对,每对做一次 sqrt 和乘法,总运算量约 10⁶,完全够快。
🟠 先打平方数表
把 0 ~ 447 的平方预先算好放进数组,用标记数组 O(1) 判断
判平方变成查表 O(1)
总复杂度仍是 O(n²)
节省的是常数因子
代码略长
⚠️什么时候值得:当 n 很大(如 10⁵,需要用更高级算法)或需要频繁判断时,打表会更快。本题规模小,直接算就够了。
📈 性能对比
方案判平方代价代码量
sqrt + 回验一次开方约 12 行
打平方表一次查表约 20 行
输入一组非负整数,程序会枚举所有数对并标出哪些和是完全平方数。
输入
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
long long a[1005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) { // j 从 i+1 开始,保证 i < j 且不重复
long long sum = a[i] + a[j];
long long s = (long long)sqrt((double)sum);
// 回验 ±1,彻底规避浮点误差
if (s * s == sum) ans++;
else if ((s + 1) * (s + 1) == sum) ans++;
else if (s > 0 && (s - 1) * (s - 1) == sum) ans++;
}
}
printf("%lld\n", ans);
return 0;
}
🔑为什么 j 从 i + 1 开始?这样每对 ⟨i, j⟩ 只会被检查一次,既满足题目要求的 i < j,又不会重复计数。如果 j 从 0 开始,同一对会被算两次。
📖 关键几行怎么看
代码作用为什么这样写
for (j = i + 1; ...)枚举数对保证 i < j,且每对只算一次
(long long)sqrt((double)sum)开平方截断取整,避免浮点直接比较
s * s == sum回验用整数乘法验证,是判平方的正确姿势
(s±1) * (s±1) == sum误差兜底容忍 sqrt 差 1 的情况,最保险
⚠️三个坑:① 直接用 sqrt(x) == (int)sqrt(x) 判断,可能因浮点误差漏解;② j 从 0 开始,导致每对重复计数(答案翻倍);③ 忽略 0 也是完全平方数(0 = 0 × 0),当两个数都是 0 时和是 0,应该计数。
写完程序后,用这些数据自查一遍:
输入答案考察点
5
1 4 3 3 53题面样例
2
1 31只有一对,1 + 3 = 4
2
1 201 + 2 = 3 不是完全平方数
2
0 010 是完全平方数(0 = 0 × 0)
3
0 1 320+1=1 ✅、0+3=3 ❌、1+3=4 ✅ → 共 2 对
3
1 1 102 不是完全平方数
✅自查清单:① 内层循环从 i+1 开始吗?② 判平方用的是整数乘法回验吗?③ 0 的情况算对了吗?
🚨 易错点清单
⚠️sqrt 精度漏解:必须截断后用整数乘法回验,必要时还要试 s±1。
⚠️j 从 0 开始:会让每个数对被算两次,答案翻倍。正确的内层起点是 i + 1。
⚠️忽略 0:0 是完全平方数,两个 0 相加得 0 应该计数。
⚠️用 int 存和:本题最大 2 × 10⁵ 不会溢出,但如果数据放大就要用 long long。
时间复杂度
O(n²)
空间复杂度
O(n)
n 最大
1000
数对总数
约 5 × 10⁵
时间怎么算的?
外层 i 共 n 次
内层 j 平均 n/2 次
总对数 n(n−1)/2,n = 1000 时约 5 × 10⁵
每对做一次开方,总运算量约 10⁶
空间都用在哪?
需要保存整个序列以便两两配对,空间 O(n)。
✅ 约 50 万对数、每次一次开方,总运算量 10⁶ 量级,轻松通过。
// 判断完全平方数的三种写法
bool isSquare1(long long x) {
long long s = (long long)sqrt((double)x);
return s * s == x || (s + 1) * (s + 1) == x;
}
bool isSquare2(long long x) { // 完全避免浮点
long long s = 0;
while (s * s < x) s++;
return s * s == x; // 慢,但绝对准确
}
bool isSquare3(long long x, const vector<char> &mark) {
return x < (long long)mark.size() && mark[x]; // 打表查
}
// 打平方表(适合值域不大的情况)
const int MAXV = 200005;
vector<char> sqMark(MAXV, 0);
for (long long i = 0; i * i < MAXV; i++) sqMark[i * i] = 1;
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
枚举数对j = i+1 起,不重不漏所有两两配对、组合计数题
完全平方数判定sqrt 截断 + 整数回验平方数、立方数判定
浮点误差防范用整数运算回验结果所有涉及 sqrt、pow 的题目
🌟思考题:如果 n 放大到 10⁵,两重循环就超时了。能不能用"枚举平方数"反过来做?(提示:和的范围是 0 ~ 2 × 10⁵,完全平方数只有约 448 个。枚举每个平方数 S,把问题变成"有多少对之和等于 S",用哈希表统计每个值出现次数即可。)
#include <bits/stdc++.h>
using namespace std;
long long a[1005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) { // j 从 i+1 开始,保证 i < j 且不重复
long long sum = a[i] + a[j];
long long s = (long long)sqrt((double)sum);
// 回验 ±1,彻底规避浮点误差
if (s * s == sum) ans++;
else if ((s + 1) * (s + 1) == sum) ans++;
else if (s > 0 && (s - 1) * (s - 1) == sum) ans++;
}
}
printf("%lld\n", ans);
return 0;
}// 判断完全平方数的三种写法
bool isSquare1(long long x) {
long long s = (long long)sqrt((double)x);
return s * s == x || (s + 1) * (s + 1) == x;
}
bool isSquare2(long long x) { // 完全避免浮点
long long s = 0;
while (s * s < x) s++;
return s * s == x; // 慢,但绝对准确
}
bool isSquare3(long long x, const vector<char> &mark) {
return x < (long long)mark.size() && mark[x]; // 打表查
}
// 打平方表(适合值域不大的情况)
const int MAXV = 200005;
vector<char> sqMark(MAXV, 0);
for (long long i = 0; i * i < MAXV; i++) sqMark[i * i] = 1;第二行包含 n 个数字,代表序列 A。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 5 0 -2 -1 0 1 2 | -2 -2 0 2 2 |
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定包含 n 个数字的序列 A = [a₁, a₂, …, aₙ]。请把其中大于 k 的数字都替换为序列的最大值,把小于 k 的数字都替换为序列的最小值,输出替换后的序列。
💡人话翻译:先把原序列的最大和最小找出来(这一步必须在替换之前完成),然后逐个判断:比 k 大就换成最大值,比 k 小就换成最小值,等于 k 的原样不动。
🔍 关键词提取
求最大值求最小值原地替换负数处理
已知条件
项目说明
输入第一行 n、k;第二行 n 个整数
输出替换后的 n 个整数
数据范围1 ≤ n ≤ 10⁵
数值范围|k|, |aᵢ| ≤ 10⁵,可能为负
需要解决的问题
极值什么时候算?必须在替换之前把原始序列的最大值和最小值求出来
等于 k 怎么办?题目只说了"大于"和"小于",等于 k 的保持不变
极值本身会被替换吗?会被替换,但最大值替换成最大值等于没变,最小值同理,所以不影响结果
📥 读入
n 和 k
n 个整数存进数组
注意可能有负数
用 int 就够
📏 先求极值
遍历一遍求 max
遍历一遍求 min
必须在替换前算完
这是本题关键顺序
🔁 逐个替换
aᵢ > k → 改成 max
aᵢ < k → 改成 min
aᵢ == k → 不动
边判断边输出也行
⚠️ 注意点
极值与 k 的大小关系不定
输出用空格分隔
行末可以有空格但最好没有
n 很大要注意效率
先算极值:最大值是 2,最小值是 −2。
1
确定极值
扫描一遍:max = 2(最后一个元素)
min = −2(第一个元素)
max = 2,min = −2
2
逐个判断
a₁ = −2 < 0 → 替换为 min = −2(恰好不变)
a₂ = −1 < 0 → 替换为 min = −2
a₃ = 0 == k → 保持不变,仍为 0
a₄ = 1 > 0 → 替换为 max = 2
a₅ = 2 > 0 → 替换为 max = 2(恰好不变)
得到 [−2, −2, 0, 2, 2]
3
输出
按顺序输出,空格分隔
✅ −2 −2 0 2 2
📊 逐个判断表
原值与 k = 0 比较替换为结果
−2小于min = −2−2
−1小于min = −2−2
0等于不替换0
1大于max = 22
2大于max = 22
🔑为什么"先求极值"不能省?如果一边替换一边更新极值,被改过的元素会影响 max/min 的计算,结果就错了。正确顺序是:先完整扫一遍求极值,再扫第二遍替换。
🧮 再看两个边界情形
极值和 k 的大小关系不固定,代码不能做任何假设。
情形n、k、Amax / min结果说明
k 比所有数都大n=3, k=100, A=[1,2,3]max=3, min=1全都 < k → 全变 1结果全是最小值
k 比所有数都小n=3, k=−100, A=[1,2,3]max=3, min=1全都 > k → 全变 3结果全是最大值
所有数都等于 kn=3, k=5, A=[5,5,5]max=5, min=5全部不替换保持原样
⚠️不要假设 max ≥ k ≥ min:题面没有这个保证。k 完全可能比所有元素都大或都小,这时结果会变成"全是同一个值"。上面的表就是这几种边界。
🟢 两遍扫描(推荐) 推荐
第一遍求 max/min,第二遍替换
时间 O(n)
逻辑最清晰
不会受替换影响
空间 O(n) 存数组
💡为什么推荐:把"求极值"和"替换"两件事彻底分开,顺序上的正确性一目了然,不会写出隐蔽的 bug。
🟠 边读入边记极值
读入时就顺便更新 max/min,之后再统一替换
本质仍是两遍(读 + 替换)
少一次遍历但代码稍绕
需要保存整个数组
收益很小
⚠️注意:这种写法的前提是"读入阶段不做任何替换",否则极值会被污染。容易写着写着就混在一起了。
📈 性能对比
方案遍历次数清晰度
两遍扫描2 次⭐⭐⭐⭐⭐
边读边记1.5 次⭐⭐⭐
第一行输入 k,第二行输入序列(空格分隔),程序会先求极值再逐个替换。
输入:第一行 k,第二行序列0
-2 -1 0 1 2
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int a[MAXN];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
// 第一遍:求出原序列的最大值和最小值(必须在替换前完成)
int mx = a[0], mn = a[0];
for (int i = 1; i < n; i++) {
if (a[i] > mx) mx = a[i];
if (a[i] < mn) mn = a[i];
}
// 第二遍:按规则替换
for (int i = 0; i < n; i++) {
if (a[i] > k) a[i] = mx;
else if (a[i] < k) a[i] = mn;
// 等于 k 时什么都不做
}
for (int i = 0; i < n; i++) {
if (i) printf(" ");
printf("%d", a[i]);
}
printf("\n");
return 0;
}
🔑输出技巧:用 if (i) printf(" ") 控制空格,可以避免"行末多一个空格"。虽然多数评测会忽略行末空格,但严格比对时会判错,养成不留行末空格的习惯。
📖 关键几行怎么看
代码作用为什么这样写
int mx = a[0], mn = a[0];初始化极值用第一个元素初始化,避免设成 0 在负数场景下出错
for (i = 1; ...)求极值从第 2 个开始即可
a[i] > k / a[i] < k判断替换两个分支都用严格比较,等于 k 自然落到"不处理"
if (i) printf(" ");控制分隔符第一个元素前面不输出空格
⚠️初始化极值的陷阱:如果写成 int mx = 0, mn = 0;,当所有数字都是负数时,max 会错误地保持 0(因为它比所有数都大)。必须用第一个元素初始化。
写完程序后,用这些数据自查一遍:
输入答案考察点
5 0
−2 −1 0 1 2−2 −2 0 2 2题面样例
1 5
77单元素:max = min = 7
3 100
1 2 31 1 1k 比所有数都大 → 全是 min
3 −100
1 2 33 3 3k 比所有数都小 → 全是 max
3 5
5 5 55 5 5全部等于 k → 不变
4 0
−3 −1 2 4−3 −3 4 4负数与正数混合,max = 4、min = −3
✅自查清单:① 极值用第一个元素初始化了吗?② 求极值在替换之前吗?③ 等于 k 的分支处理了吗?④ 行末有没有多余空格?
🚨 易错点清单
⚠️用 0 初始化极值:全是负数时 max 会错成 0。必须用 a[0] 初始化。
⚠️先替换再求极值:顺序反了,极值会被替换后的值污染。
⚠️把"等于 k"也一起处理了:题目只说大于和小于,等于 k 的必须保持原值。
时间复杂度
O(n)
空间复杂度
O(n)
n 最大
10⁵
遍历次数
2 ~ 3 次
时间怎么算的?
求极值一遍 O(n)
替换一遍 O(n)
输出一遍 O(n)
合计仍是 O(n)
空间都用在哪?
需要保存整个序列以便二次遍历,所以空间是 O(n);n ≤ 10⁵ 时约 400 KB,完全没问题。
✅ 10⁵ 规模下三次遍历约 30 万次操作,轻松通过。
// 求极值的正确初始化方式
int mx = a[0], mn = a[0]; // 用第一个元素初始化(最稳)
// 不要写成 int mx = 0, mn = 0; ——负数场景会错
// 也可以用算法库(要求数组非空)
int mx = *max_element(a, a + n);
int mn = *min_element(a, a + n);
// 输出时不带行末空格的标准写法
for (int i = 0; i < n; i++) {
if (i) printf(" ");
printf("%d", a[i]);
}
printf("\n");
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
求极值一趟扫描记录最大最小统计类、范围判断类题目
两阶段处理先收集信息,再统一修改需要"原始数据"的替换/映射题
无行末空格输出用 if (i) 控制分隔符所有多元素输出题
🌟思考题:如果把规则改成"大于 k 的替换为大于 k 的元素中的最小值",代码要增加什么?(提示:需要在第一遍扫描时同时统计"大于 k 的元素"的极值,而不能先替换再算。)
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int a[MAXN];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
// 第一遍:求出原序列的最大值和最小值(必须在替换前完成)
int mx = a[0], mn = a[0];
for (int i = 1; i < n; i++) {
if (a[i] > mx) mx = a[i];
if (a[i] < mn) mn = a[i];
}
// 第二遍:按规则替换
for (int i = 0; i < n; i++) {
if (a[i] > k) a[i] = mx;
else if (a[i] < k) a[i] = mn;
// 等于 k 时什么都不做
}
for (int i = 0; i < n; i++) {
if (i) printf(" ");
printf("%d", a[i]);
}
printf("\n");
return 0;
}// 求极值的正确初始化方式
int mx = a[0], mn = a[0]; // 用第一个元素初始化(最稳)
// 不要写成 int mx = 0, mn = 0; ——负数场景会错
// 也可以用算法库(要求数组非空)
int mx = *max_element(a, a + n);
int mn = *min_element(a, a + n);
// 输出时不带行末空格的标准写法
for (int i = 0; i < n; i++) {
if (i) printf(" ");
printf("%d", a[i]);
}
printf("\n");1. 在数组 a 中找到最大的整数,记其下标为 k。如果有多个最大值,那么选择其中下标最大的。
2. 从数组 a 所有不为零的整数中找到最小的整数 a_j。
3. 将第一步找出的 a_k 减去 a_j。
例如,数组 a = [2, 3, 4] 需要 7 次操作变成 [0, 0, 0]:
$
[2, 3, 4] arrow [2, 3, 2] arrow [2, 1, 2] arrow [2, 1, 1] arrow [1, 1, 1] arrow [1, 1, 0] arrow [1, 0, 0] arrow [0, 0, 0]
小 A 想知道,对于给定的数组 a,需要多少次操作才能使得 a 中的整数全部变成 0。可以证明,a$ 中整数必然可以在有限次操作后全部变成 0。你能帮他计算出答案吗?
第二行,n 个非负整数 a_1, a_2, …, a_n,表示数组 a 中的整数。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 3 2 3 4 | 7 |
| 2 | 5 1 3 2 2 5 | 13 |
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定 n 个非负整数。重复以下操作直到全部为 0:
找到最大的整数,记下标为 k(若有多个最大值,取下标最大的那个)
在所有非零整数中找到最小的整数 aⱼ
把 aₖ 减去 aⱼ
例如 [2, 3, 4] 需要 7 次操作变成 [0, 0, 0]。求操作次数。
💡人话翻译:题目已经把规则说得非常清楚了,而且数据范围极小(n ≤ 100,每个数 ≤ 100),所以不需要找规律,照着规则老实模拟就行。这正是这道题的考点:把文字规则准确翻译成代码。
🔍 关键词提取
规则模拟找最大值找最小非零值while 循环
已知条件
项目说明
输入第一行 n;第二行 n 个非负整数
输出全部变成 0 所需的操作次数
数据范围1 ≤ n ≤ 100,0 ≤ aᵢ ≤ 100
多解处理多个最大值时取下标最大的
终止保证题目说明必然能在有限次后全部归零
需要解决的问题
怎么保证会结束?每次操作都让总和至少减少 1(aₖ 减去一个正数),总和有限 → 必然结束
操作次数上界是多少?总和 ≤ 100 × 100 = 10⁴,所以最多 10⁴ 次操作,模拟完全可行
三个步骤的顺序能换吗?不能。必须先定位最大值和最小非零值,再执行减法,否则会用到已经被修改的数据
📥 读入
n 和数组 a
计数器 cnt = 0
总和 sum 用来判终止
注意 0 要排除在最小值候选外
🔍 找两个位置
找最大值(下标最大)
找最小非零值
两个都要扫一遍
都是 O(n)
➖ 执行减法
a[k] 减去 a[j]
cnt 加 1
可能变成 0 也可能还是正数
再回到循环开头
⛔ 终止条件
全部元素都是 0
等价于总和为 0
每次至少减 1
最多 10⁴ 次
题面已经给出了变化过程,我们把它拆解成"每一步选了什么"。
第几步数组状态最大值(下标最大)最小非零值减法动作
初始[2, 3, 4]———
1[2, 3, 2]4(下标 3)24 − 2 = 2
2[2, 1, 2]3(下标 2)23 − 2 = 1
3[2, 1, 1]2(下标 3)12 − 1 = 1
4[1, 1, 1]2(下标 1)12 − 1 = 1
5[1, 1, 0]1(下标 3)11 − 1 = 0
6[1, 0, 0]1(下标 2)11 − 1 = 0
7[0, 0, 0]1(下标 1)11 − 1 = 0
🔑注意第 1 步:数组里只有一个 4,所以最大值下标是 3;而最小非零值是 2(下标 1 或 3),不是 0 —— 如果把 0 也算进最小值,减法就变成"什么都不减",程序会死循环。
🧮 样例 2:[1, 3, 2, 2, 5],答案 13
这组数据更细致地考察"多个最大值 + 下标最大"和"最小非零值是 1"的情形。
1
最小值一直是 1
只要数组里还有 1,最小非零值就是 1
每一次操作都相当于"最大值 − 1"
所以数组会缓慢地逐个归零
2
中间几步的关键选择
第 3 步时数组为 [1, 3, 2, 2, 3],最大值 3 出现在下标 2 和下标 5
按规则取下标最大的 → 选下标 5
所以变成 [1, 3, 2, 2, 2]
✅ 这一步区分了对错解法
3
收尾阶段
当数组变成 [1, 1, 1, 1, 1] 后,
每次操作会让下标最大的那个 1 变成 0
5 个 1 需要 5 步全部清零
✅ 累计共 13 步
阶段数组状态说明
初始[1, 3, 2, 2, 5]
第 1 ~ 4 步[1, 3, 2, 2, 4] → [1, 3, 2, 2, 3] → [1, 3, 2, 2, 2] → [1, 2, 2, 2, 2]最大值一路减 1
第 5 ~ 8 步[1, 2, 2, 2, 1] → [1, 2, 2, 1, 1] → [1, 2, 1, 1, 1] → [1, 1, 1, 1, 1]注意下标最大的先被减
第 9 ~ 13 步[1, 1, 1, 1, 0] → [1, 1, 1, 0, 0] → [1, 1, 0, 0, 0] → [1, 0, 0, 0, 0] → [0, 0, 0, 0, 0]逐个清零
🔑为什么这题不用找数学规律?数据范围小到可以硬模拟(最多约 10⁴ 次操作 × 100 个数 = 10⁶ 次判断),而且规则里的"下标最大"这类细节用公式很难直接表达。模拟是唯一稳妥的选择。
🟢 纯模拟(推荐) 推荐
照着三步规则循环执行,直到总和为 0
最坏约 10⁶ 次操作
代码直接对应题面,不易错
不用推导任何公式
n、aᵢ 范围小,稳过
💡为什么够用:操作次数上界是"总和"(≤ 10⁴),每次操作扫两遍数组 O(n),总计 10⁶ 量级,一眨眼就跑完。
🟠 找数学规律
有人会想:这和"更相减损术"有关吗?能否用 gcd 直接算?
本题的规则带"下标最大"约束
只对部分数据成立
公式难以覆盖所有情况
风险高、收益低
⚠️结论:这题确实有更相减损术的影子(每次减最小非零值),但"取下标最大的最大值"让规律变得复杂,不值得为此冒险。
📈 性能对比
方案运算量推荐度
纯模拟约 10⁶ 次⭐⭐⭐⭐⭐
数学规律约 10² 次⭐⭐(易错)
输入数组(空格分隔),程序会按规则逐步模拟,并显示每一步的数组状态。
输入
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int a[105];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
long long cnt = 0;
while (true) {
// 判断是否已经全部为 0
bool allZero = true;
for (int i = 0; i < n; i++) if (a[i] != 0) { allZero = false; break; }
if (allZero) break;
// ① 找最大值,下标要取最大的(用 >= 才能取到更靠后的)
int k = 0;
for (int i = 0; i < n; i++) if (a[i] >= a[k]) k = i;
// ② 在所有非零元素中找最小值
int j = -1;
for (int i = 0; i < n; i++)
if (a[i] > 0 && (j == -1 || a[i] < a[j])) j = i;
// ③ 相减并计数
a[k] -= a[j];
cnt++;
}
printf("%lld\n", cnt);
return 0;
}
🔑两个容易写错的细节:① 找最大值时用 >= 而不是 > —— 这样遇到相同的最大值会自动取到更靠后的下标,正好符合题意;② 找最小值时必须加 a[i] > 0 的条件,把 0 排除在外。
📖 关键几行怎么看
代码作用为什么这样写
if (a[i] != 0) allZero = false;判断是否全部归零只要有一个非零就继续循环
if (a[i] >= a[k]) k = i;取下标最大的最大值>= 是本题的关键细节
a[i] > 0 && ...排除 0最小非零值不能是 0,否则死循环
long long cnt计数本题最多约 10⁴ 次,int 也够,写 long long 更保险
⚠️死循环陷阱:如果找最小值时忘了排除 0,当数组里还有非零元素但最小值是 0 时,减法相当于没减,循环永远不结束。
写完程序后,用这些数据自查一遍:
输入答案考察点
3
2 3 47题面样例 1
5
1 3 2 2 513题面样例 2,考察下标最大的最大值
1
00已经是全 0,一次都不用做
1
51单个元素:5 − 5 = 0
2
2 22两个相同值:各减一次 2
2
1 12最小值恒为 1,逐个清零
✅自查清单:① 最小值是否排除了 0?② 最大值是否用了 >=?③ 终止条件是不是"全部为 0"?
🚨 易错点清单
⚠️找最小值时没排除 0:会导致减法无效、程序死循环。
⚠️找最大值时用了严格大于:写成 > 会取到第一个最大值,而题目要求取最后一个,结果会偏大或偏小。
⚠️先做减法再找最小值:三步必须按顺序执行,如果先把 aₖ 改小,可能会改变"最小值是谁"的判断。
时间复杂度
O(次数 × n)
空间复杂度
O(n)
最坏次数
约 10⁴
最坏运算
约 10⁶
时间怎么算的?
每次操作要扫两遍数组(找最大、找最小),代价 O(n)
操作次数上界是"数组总和",因为每次操作至少让总和减少 1
总和 ≤ 100 × 100 = 10⁴,所以总运算量 ≤ 10⁴ × 100 = 10⁶
空间都用在哪?
只需要一个长度 n 的数组保存当前状态,n ≤ 100。
✅ 最坏 10⁶ 次操作,C++ 几毫秒内完成,模拟法完全够用。
// 更相减损术:求最大公约数的"减法版"
int gcdBySub(int a, int b) {
while (a != b) {
if (a > b) a -= b; else b -= a;
}
return a;
}
// 数组的"全部归零"判断可以简写成总和判断
int sum = 0;
for (int i = 0; i < n; i++) sum += a[i];
// 只要 sum > 0 就继续
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
规则模拟把文字描述的三步准确翻译成代码所有"操作流程"类题目
找最大/最小值一次遍历同时记录值和下标数组处理、统计题
while + 终止判断用"总和是否为 0"控制循环模拟类、博弈类题目
🌟思考题:如果把规则改成"每次都减去最小非零值,但只对最大值操作一次",结果会不会不同?(提示:当有多个相同的最大值时,题目要求只减其中一个,这和"把所有最大值都减一遍"是不同的。)
#include <bits/stdc++.h>
using namespace std;
int a[105];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
long long cnt = 0;
while (true) {
// 判断是否已经全部为 0
bool allZero = true;
for (int i = 0; i < n; i++) if (a[i] != 0) { allZero = false; break; }
if (allZero) break;
// ① 找最大值,下标要取最大的(用 >= 才能取到更靠后的)
int k = 0;
for (int i = 0; i < n; i++) if (a[i] >= a[k]) k = i;
// ② 在所有非零元素中找最小值
int j = -1;
for (int i = 0; i < n; i++)
if (a[i] > 0 && (j == -1 || a[i] < a[j])) j = i;
// ③ 相减并计数
a[k] -= a[j];
cnt++;
}
printf("%lld\n", cnt);
return 0;
}// 更相减损术:求最大公约数的"减法版"
int gcdBySub(int a, int b) {
while (a != b) {
if (a > b) a -= b; else b -= a;
}
return a;
}
// 数组的"全部归零"判断可以简写成总和判断
int sum = 0;
for (int i = 0; i < n; i++) sum += a[i];
// 只要 sum > 0 就继续商店里共有 N 件文具,每件文具都有一个种类编号(从 1 到 M)和价格。
小杨的预算有限,他想了一个聪明的办法:对于每种文具,他只买最便宜的那一件(如果同种文具有多件价格相同且都是最便宜的,他只会购买其中的一件)。请你帮小杨计算出,买齐这 M 种文具一共需要花费多少钱。
之后 N 行,每行两个正整数 K_i 和 P_i,分别代表第 i 件文具的种类编号和它的价格。数据保证每个种类至少有一件文具可供购买。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 2 5 1 1 1 2 1 1 2 3 2 10 | 4 |
文具清单如下:
- 文具 1:种类 1,价格 1
- 文具 2:种类 1,价格 2
- 文具 3:种类 1,价格 1
- 文具 4:种类 2,价格 3
- 文具 5:种类 2,价格 10
小杨的选择过程:对于种类 1:有三件商品,价格分别为 1, 2, 1。其中最便宜的价格是 1。对于种类 2:有两件商品,价格分别为 3, 10。其中最便宜的价格是 3。
计算总价:小杨购买这两类文具的总花费为 1 + 3 = 4。
数据范围
对于所有测试点,保证 1 ≤q M ≤q N ≤q 10^5,1 ≤q K_i ≤q M,1 ≤q P_i ≤q 10^3。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
老师请小杨去文具店购买 M 种不同的文具。商店里共有 N 件文具,每件文具都有一个种类编号(1 到 M)和价格。
小杨的预算有限,他想了一个聪明的办法:对于每种文具,他只买最便宜的那一件(如果同种文具有多件价格相同且都是最便宜的,他只会购买其中的一件)。请你帮小杨计算出,买齐这 M 种文具一共需要花费多少钱。
💡人话翻译:把 N 件商品按"种类"分组,每组挑出最便宜的那件,然后把 M 件最便宜商品的价格加起来。注意是 M 种都要买到,不是挑 M 件。
🔍 关键词提取
分组统计求最小值数组当桶累加求和
已知条件
项目说明
输入第一行 M、N;随后 N 行每行 K、P(种类编号、价格)
输出买齐 M 种文具的总花费
数据范围1 ≤ M ≤ N ≤ 10⁵
种类编号1 ≤ K ≤ M
价格范围1 ≤ P ≤ 1000
重要保证每个种类至少有一件文具可买
需要解决的问题
怎么按种类分组?用数组下标当种类编号:best[K] 表示种类 K 的最低价格
初始值设多少?价格最大是 1000,把初始值设成比它大的数(如 1001)即可
怎么求总和?边读边更新最低价,最后把 best[1..M] 累加
📥 读入与准备
读入 M、N
数组 best[1..M]
全部初始化为 1001
下标即种类编号
🔄 边读边更新
读入一件商品的 K、P
若 P < best[K]
则 best[K] = P
否则忽略这件
➕ 汇总
遍历 best[1..M]
全部累加
输出总价
保证每组非空
⚠️ 注意点
价格是正整数
初始化要足够大
总和 ≤ 1000 × 10⁵
int 够用
样例数据:2 5,随后 5 行分别是 1 1、1 2、1 1、2 3、2 10。
1
初始化
best[1] = 1001,best[2] = 1001(足够大的哨兵值)
等待更新
2
读入 1 1(种类 1,价格 1)
1 < best[1] = 1001
best[1] 更新为 1
3
读入 1 2(种类 1,价格 2)
2 < best[1] = 1 不成立
忽略,best[1] 仍为 1
4
读入 1 1(种类 1,价格 1)
1 < 1 不成立(相等也不更新)
忽略,best[1] 仍为 1
5
读入 2 3(种类 2,价格 3)
3 < best[2] = 1001
best[2] 更新为 3
6
读入 2 10(种类 2,价格 10)
10 < 3 不成立
忽略,best[2] 仍为 3
7
最后求和
best[1] + best[2] = 1 + 3
✅ 总价 = 4
📊 分组结果一览
种类该种类的所有价格最低价是否买它
11、2、11✅ 买
23、103✅ 买
🔑关键点:同一件商品只跟"自己种类"的最低价比较,不同种类之间互不影响。所以用数组下标当种类编号是最自然的做法。
🟢 桶数组(推荐) 推荐
用 best[种类] 记录该种类的最低价,读入时实时更新
时间复杂度 O(N + M)
空间 O(M)
一次遍历,边读边更新
代码最短,约 15 行
💡为什么它最优:每件商品只看一眼,不需要保存,也不需要排序,是典型的"一遍扫描"解法。
🟠 排序后分组
把所有商品按 (种类, 价格) 排序,每种取第一件
时间复杂度 O(N log N)
空间 O(N) 保存所有商品
需要写比较函数
n = 10⁵ 也能过,但没必要
⚠️注意:排序法要额外的 O(N) 空间存全部商品,而桶数组只用一个长度为 M 的数组。
📈 性能对比
N 的规模桶数组排序法结论
1,000约 1 千次约 1 万次都能过
100,000(本题上限)约 10 万次约 170 万次桶数组明显更省
第一行输入 M N,之后 N 行每行输入"种类编号 价格"。程序会分组求最低价并汇总。
输入数据2 5
1 1
1 2
1 1
2 3
2 10
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
const int MAXP = 1001; // 价格上限 1000,用 1001 当"无穷大"
int best[100005];
int main() {
int M, N;
scanf("%d %d", &M, &N);
for (int i = 1; i <= M; i++) best[i] = MAXP; // 初始化为哨兵值
for (int i = 0; i < N; i++) {
int k, p;
scanf("%d %d", &k, &p);
if (p < best[k]) best[k] = p; // 只保留每种的最低价
}
int total = 0;
for (int i = 1; i <= M; i++) total += best[i]; // 每种都必须买,直接加
printf("%d\n", total);
return 0;
}
🔑哨兵值的选择:初始化必须比任何合法价格都大。题目保证价格 ≤ 1000,所以用 1001 最省事。养成习惯:初始化值要看数据范围来定,不要凭感觉写 0 或 -1。
📖 关键几行怎么看
代码作用为什么这样写
best[i] = MAXP初始化桶保证第一次遇到任何价格都会更新
if (p < best[k]) best[k] = p;实时更新最低价一遍扫描完成,不用保存所有商品
total += best[i]累加题目保证每种至少一件,所以不会有哨兵值残留
⚠️如果用贪心"买最便宜的 M 件"会错:那样可能某种买了两件、另一种一件没买。题目要求的是每种各一件。
写完程序后,用这些数据自查一遍:
输入答案考察点
1 1
1 55只有一种,只有一件
2 2
1 10
2 2030每种恰好一件
2 5
1 1
1 2
1 1
2 3
2 104题面样例
3 4
3 7
1 2
2 9
3 718种类乱序出现,仍要正确分桶
2 3
1 1000
2 1000
1 9991999价格取到上限 1000
✅自查清单:① 桶数组是否开到 M + 5 以上?② 初始化值是否大于 1000?③ 求和是从 1 加到 M 吗?
🚨 易错点清单
⚠️把"买最便宜的 M 件"当答案:题目是"每种各买一件最便宜的",不是"买最便宜的整体 M 件"。
⚠️初始化写成 0:这样 p < best[k] 永远不成立,最低价永远是 0,答案也就错了。
⚠️数组开小:种类编号最大是 M(≤ 10⁵),数组要开到 10⁵ + 5,不能按 N 或者按"实际出现过的种类数"来开。
时间复杂度
O(N + M)
空间复杂度
O(M)
N 最大
10⁵
运算次数
约 10⁵
时间怎么算的?
读入 + 更新最低价:N 次
最后求和:M 次
合计 O(N + M),因为 M ≤ N,可以看作 O(N)
空间都用在哪?
只用一个长度为 M + 1 的数组记录每种的最低价,不需要保存全部商品,所以空间是 O(M)。
✅ N = 10⁵ 时操作约 10 万次,瞬间完成。
// 桶统计通用套路:下标当"键",数组元素当"值"
int best[100005]; // 求最小
int cnt[100005]; // 求次数
long long sum[100005]; // 求每类的和
for (int i = 1; i <= M; i++) best[i] = 1001; // 求最小要初始化成"无穷大"
// 求次数则初始化为 0(全局数组默认就是 0)
cnt[k]++;
sum[k] += p;
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
数组当桶用下标存种类编号计数排序、桶排序、词频统计
哨兵初始化设一个比所有合法值都"极值"的初值求最小值、求最大值、DP 的边界
一遍扫描边读边算,不保存原始数据读入量很大但只需汇总的题目
🌟思考题:如果把题目改成"每种买最贵的那件",代码要改哪几个地方?(提示:初始化要改成比 0 还小的数,比较符号要反过来。)
#include <bits/stdc++.h>
using namespace std;
const int MAXP = 1001; // 价格上限 1000,用 1001 当"无穷大"
int best[100005];
int main() {
int M, N;
scanf("%d %d", &M, &N);
for (int i = 1; i <= M; i++) best[i] = MAXP; // 初始化为哨兵值
for (int i = 0; i < N; i++) {
int k, p;
scanf("%d %d", &k, &p);
if (p < best[k]) best[k] = p; // 只保留每种的最低价
}
int total = 0;
for (int i = 1; i <= M; i++) total += best[i]; // 每种都必须买,直接加
printf("%d\n", total);
return 0;
}// 桶统计通用套路:下标当"键",数组元素当"值" int best[100005]; // 求最小 int cnt[100005]; // 求次数 long long sum[100005]; // 求每类的和 for (int i = 1; i <= M; i++) best[i] = 1001; // 求最小要初始化成"无穷大" // 求次数则初始化为 0(全局数组默认就是 0) cnt[k]++; sum[k] += p;
他有一本密码本,密码本告诉你:每个数字应该变成哪个数字。
数字一共有 10 个:0、1、2、3、4、5、6、7、8、9。
密码本会依次告诉你:
- 0 要变成什么
- 1 要变成什么
- 2 要变成什么
- ……
- 9 要变成什么
请你按照密码本,把原来的每个数字都换成新的数字,然后输出。
第一行:一个整数,表示有多少个数字需要加密;
第二行:这些需要加密的数字;
第三行:密码本,一共 10 个数字。
这 10 个数字的意思是:
- 第 1 个数字:表示 0 加密后变成什么;
- 第 2 个数字:表示 1 加密后变成什么;
- 第 3 个数字:表示 2 加密后变成什么;
- ……
- 第 10 个数字:表示 9 加密后变成什么。
也就是:把输入第二行里的每个数字,都按照输入第三行的密码本换掉后输出。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 7 0 2 0 3 4 1 9 9 0 1 2 3 4 5 6 7 8 | 9 1 9 2 3 0 8 |
$0 2 0 3 4 1 9
第三行密码本是:
9 0 1 2 3 4 5 6 7 8
它的意思是:
- 0 变成 9
- 1 变成 0
- 2 变成 1
- 3 变成 2
- 4 变成 3
- 5 变成 4
- 6 变成 5
- 7 变成 6
- 8 变成 7
- 9 变成 8
所以:
- 0 变成 9
- 2 变成 1
- 0 变成 9
- 3 变成 2
- 4 变成 3
- 1 变成 0
- 9 变成 8
最后得到:
9 1 9 2 3 0 8
数据范围
需要加密的数字个数不超过 20000 个,且均为 0 到 9;密码本中的数字不重复,且均为 0 到 9$。
· 下标从 0 起,先画「下标 ↔ 值」的对应表再写循环。
写完后可到洛谷
B4555 对照题解。- 取出正整数 n 的末位,记作 x;
- 将 x 平方之后,保留个位,放于 n 的首位之前(如果是 0,则数字不保留前导 0);
上述两步合计为一次操作。例如有一个正整数 142,它可以进行如下操作:
- 取出末尾的 2,原正整数变为 14;
- 2^2=4,放于 14 首位之前成为 414,第一次操作完成;
- 取出末尾的 4,原正整数变为 41;
- 4^2=16,保留个位的 6,放于 41 的首位成为 641,第二次操作完成;
- 以此类推……
现在小洛想知道,对于一个正整数 n,能否进行不超过 q 次操作让其变为正整数 m。请你帮帮他。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 123 611 10 | 912 491 149 114 611 |
| 2 | 123 231 12345 | -1 |
对于所有数据,数据保证 1≤q n,m≤q 10^9,1 ≤q q ≤q 10^6。
· 把规则一步步翻译成代码,用变量记住当前状态。
· 先把「初值 / 条件 / 更新」三件事写清,再数内层循环跑几次;输出题一定要在草稿上列表。
写完后可到洛谷
B3996 对照题解。第二行包含 M 个整数,分别为 M 次报出的编号。约定所有编号是小于 N 的非负整数。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 3 3 0 2 1 | 3 |
| 2 | 3 5 0 0 0 0 0 | 1 2 |
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
班上有 N 位同学,编号从 0 到 N − 1。老师让到场的同学报出自己的编号,报到的人可能重复报很多次。请找出没有到场的同学编号,按从小到大输出,空格分隔。
如果所有同学都到场,输出 N。
💡人话翻译:准备 N 个"打卡格子",每听到一个编号就把对应格子打上勾(重复报也只是一个勾)。最后看哪些格子没打勾——那些就是没来的。注意"全到"要输出 N,而不是什么都不输出。
🔍 关键词提取
标记数组去重遍历输出特殊输出
已知条件
项目说明
输入第一行 N、M;第二行 M 个报出的编号
输出未到场编号(升序空格分隔),或 N(全到)
数据范围2 ≤ N, M ≤ 1000
编号范围小于 N 的非负整数
重复同一编号可能被报多次
需要解决的问题
怎么记录到场?布尔数组 arrived[编号] = true,重复报也无所谓
怎么找没到的?从 0 到 N−1 扫一遍,标记为 false 的就是没到
全到的特例?如果没有任何编号未到,输出 N(这是题目特别规定的)
📥 读入
N 位同学、M 次报号
编号 0 ~ N−1
可能大量重复
标记数组初始全 false
✅ 打标记
每读一个编号 x
arrived[x] = true
重复报不产生影响
O(M)
🔍 扫一遍
i 从 0 到 N−1
arrived[i] 为 false 就输出 i
升序自然满足
O(N)
⚠️ 特殊要求
全到时要输出 N
不是输出空行
也不是输出 0
行末不加空格
三个编号都被报过,说明全到。
报号标记情况
0arrived[0] = true
2arrived[2] = true
1arrived[1] = true
1
扫描 0 ~ 2
arrived[0] = true → 跳过
arrived[1] = true → 跳过
arrived[2] = true → 跳过
一个都没输出
✅ 触发"全到"规则,输出 N = 3
输出:3 ✓
🧮 样例 2:N = 3,报号 0 0 0 0 0
五次数都报的是 0 号,1 号和 2 号没来。
报号标记情况说明
第 1 次 0arrived[0] = true
第 2 ~ 5 次 0arrived[0] 已经是 true重复报不影响结果
1
扫描 0 ~ 2
arrived[0] = true → 跳过
arrived[1] = false → 输出 1
arrived[2] = false → 输出 2
✅ 输出 1 2
输出:1 2 ✓
🔑"重复报"是这题的干扰项:标记数组天然去重——同一个编号报一百次,arrived 也只是一个 true。所以不需要任何额外去重逻辑。
🟢 布尔标记数组(推荐) 推荐
用 arrived[N] 记录到场情况,扫一遍输出未到
时间 O(N + M)
空间 O(N)
天然去重
代码 15 行
💡为什么推荐:编号范围恰好是 0 ~ N−1,和数组下标一一对应,这是"用数组当集合"的教科书用法。
🟠 用 set 容器
把报到的编号插入 set,最后检查哪些不在里面
时间 O(M log M)
空间比数组大
功能上等价
本题属于杀鸡用牛刀
⚠️什么时候用 set:当编号范围很大或稀疏时(比如编号可能到 10⁹),数组开不下才需要 set。本题 N ≤ 1000,数组最简单。
📈 性能对比
方案时间代码量
布尔数组O(N + M)约 15 行
set 容器O(M log M)约 20 行
第一行输入 N 和 M,第二行输入 M 个报出的编号,程序会列出未到场的同学。
输入:第一行 N M,第二行报号序列3 5
0 0 0 0 0
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
bool arrived[1005];
int main() {
int N, M;
scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) {
int x;
scanf("%d", &x);
arrived[x] = true; // 重复报也只标记一次
}
bool anyMissing = false;
bool first = true;
for (int i = 0; i < N; i++) {
if (!arrived[i]) {
if (!first) printf(" ");
printf("%d", i);
first = false;
anyMissing = true;
}
}
if (!anyMissing) printf("%d", N); // 全到:输出 N
printf("\n");
return 0;
}
🔑这道题唯一的"陷阱"是那个特殊输出:当所有同学都到场时,题目要求输出 N。如果不加这个分支,程序会输出一个空行,直接判错。读题时一定要把"如果……则……"这类特殊规则圈出来。
📖 关键几行怎么看
代码作用为什么这样写
arrived[x] = true标记到场直接置真,无需判断之前是否已标记
if (!arrived[i])找未到场从 0 到 N−1 扫描保证升序
if (!first) printf(" ")控制空格避免行末和行首多余空格
if (!anyMissing) printf("%d", N)特殊输出全到时输出 N,这是题目规定的
⚠️三个坑:① 忘了"全到输出 N"这条特殊规则;② 输出时用 printf("%d ", i) 导致行末多空格(多数评测能过,但严格比对会错);③ 数组开成 N 大小却访问下标 N−1 之外(本题保证编号 < N,安全)。
写完程序后,用这些数据自查一遍:
输入答案考察点
3 3
0 2 13题面样例 1:全到输出 N
3 5
0 0 0 0 01 2题面样例 2
2 2
0 12最小规模,全到
3 2
0 01 2只有 0 到场
4 4
1 1 2 20 3首尾两位没到,输出应按编号升序
✅自查清单:① 用标记数组去重了吗?② 输出是从小到大吗?③ 全到时输出 N 了吗?
🚨 易错点清单
⚠️忘记"全到输出 N":这样样例 1 会输出一个空行,直接判错。
⚠️输出顺序没保证:必须从编号 0 开始扫描,才能保证从小到大;不能按报号顺序输出。
⚠️把"重复报"当成需要特殊处理:布尔数组天然去重,不需要任何额外判断。
时间复杂度
O(N + M)
空间复杂度
O(N)
N, M 最大
1000
运算量
2000 次
时间怎么算的?
标记阶段遍历 M 个报号
扫描阶段遍历 N 个编号
合计 O(N + M)
最坏 2000 次操作
空间都用在哪?
一个长度为 N 的布尔数组记录到场情况。
✅ 数据规模很小,任何写法都瞬间完成;这题的考点是"重复报号"的干扰和"全到输出 N"的特殊规则。
// 用数组当"集合"的标准写法(编号范围 [0, N) 时最省事)
bool inSet[1005];
inSet[x] = true; // 插入
if (inSet[x]) { /* 存在 */ } // 查询
// 输出时避免行末空格
bool first = true;
for (int i = 0; i < N; i++) {
if (cond(i)) {
if (!first) printf(" ");
printf("%d", i);
first = false;
}
}
// 当值域很大时改用 set 或 map
set<int> st;
st.insert(x);
if (st.count(x)) { /* 存在 */ }
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
标记数组用下标当集合元素去重、存在性判断、计数
升序输出从 0 扫到 N−1所有要求"按编号从小到大输出"的题
特殊输出规则"如果……则输出……"读题时务必圈出这类附加规则
🌟思考题:如果题目改成"输出到场次数恰好为 1 次的编号",标记数组就不够用了——该怎么改?(提示:把 bool 换成 int 计数数组,统计每个编号被报了几次,最后筛出计数等于 1 的。)
#include <bits/stdc++.h>
using namespace std;
bool arrived[1005];
int main() {
int N, M;
scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) {
int x;
scanf("%d", &x);
arrived[x] = true; // 重复报也只标记一次
}
bool anyMissing = false;
bool first = true;
for (int i = 0; i < N; i++) {
if (!arrived[i]) {
if (!first) printf(" ");
printf("%d", i);
first = false;
anyMissing = true;
}
}
if (!anyMissing) printf("%d", N); // 全到:输出 N
printf("\n");
return 0;
}// 用数组当"集合"的标准写法(编号范围 [0, N) 时最省事)
bool inSet[1005];
inSet[x] = true; // 插入
if (inSet[x]) { /* 存在 */ } // 查询
// 输出时避免行末空格
bool first = true;
for (int i = 0; i < N; i++) {
if (cond(i)) {
if (!first) printf(" ");
printf("%d", i);
first = false;
}
}
// 当值域很大时改用 set 或 map
set<int> st;
st.insert(x);
if (st.count(x)) { /* 存在 */ }接下来是 t 组测试用例。对于每组测试用例,一共两行。
其中,第一行包含一个正整数 n;第二行包含 n 个正整数,代表序列 A。
Yes,否则输出 No。| # | 输入 | 输出 |
|---|---|---|
| 1 | 2 3 1 2 4 5 1 2 3 4 5 | Yes No |
对于第⼀组数据,对于 a_3=4,满足 a_3 是 a_1 和 a_2 的倍数。
【数据范围】
对于全部数据,保证有 1≤q t≤q 10,1≤q n≤q 10^5,1≤q a_i≤q 10^9。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定包含 n 个正整数的序列 A。请判断是否存在下标 i,使得 aᵢ 是序列 A 中所有数的倍数。
本题包含多组测试数据。
💡人话翻译:要找一个"老大",它得能被序列里每一个数整除。注意是"是所有数的倍数",不是"与某个数成倍数关系"。
🔍 关键词提取
整除判断最大值性质多组测试剪枝优化
已知条件
项目说明
输入第一行 t;每组两行:n 和 n 个正整数
输出每组一行 Yes 或 No
数据范围t ≤ 10,n ≤ 10⁵
数值范围1 ≤ aᵢ ≤ 10⁹
需要解决的问题
要试几个候选?只试最大值就够了!
为什么?如果某数 x 是所有数的倍数,那 x ≥ 每个数 → x 必然是最大值
怎么判整除?对每个 aₖ 检查 max % aₖ == 0,有一个不成立就输出 No
📥 读入
读 n 和序列
同时记录最大值 max
用 long long 存
数组可省
🧠 关键推理
若 x 是所有数的倍数
则 x ≥ 每个数
所以 x 只能是最大值
候选唯一 → 只试一个
✅ 验证
对每个 aₖ 检查 max % aₖ == 0
有一个不整除就 No
全部整除就 Yes
O(n) 完成
⚠️ 易错点
枚举所有候选导致 O(n²) 超时
把"是某个数的倍数"当成条件
n = 1 时必然 Yes
多组数据忘了重置 max
样例答案依次是 Yes、No。
1
第 1 组:[1, 2, 4]
最大值 max = 4
检查 4 % 1 = 0 ✅
4 % 2 = 0 ✅
4 % 4 = 0 ✅
全部整除
✅ Yes(4 是 1、2、4 的倍数)
2
第 2 组:[1, 2, 3, 4, 5]
最大值 max = 5
5 % 1 = 0 ✅
5 % 2 = 1 ❌ ← 已经失败了
(后面 5 % 3、5 % 4 也不用再看)
❌ No
🔑 关键推理:候选只有最大值一个
"x 是所有数的倍数"意味着对每个 aₖ 都有 x % aₖ == 0,也就是 x ≥ aₖ。既然 x 不小于序列中的任何一个数,x 就必须是最大值(最大值本身也是唯一的候选身份)。
思路候选个数复杂度结果
枚举每个 aᵢ 当候选n 个O(n²)n = 10⁵ 时超时
只试最大值1 个O(n)稳过
🔑这个推理的价值:把 O(n²) 直接降到 O(n),而且推理只用到一个最朴素的性质——"倍数不会比原数小"。很多优化都是从这种朴素的单调性质来的。
🟢 只试最大值(推荐) 推荐
求 max,然后逐个检查 max % aₖ
每组 O(n)
一遍求 max、一遍验证
不需要存整个数组
推理清晰、代码极短
💡额外好处:因为不需要回头看旧数据,可以边读边求 max,第二遍再验证(或者干脆存数组)。
🟠 枚举每个元素当候选
对每个 aᵢ,检查它是否整除所有 aₖ
每组 O(n²)
n = 10⁵ 时约 10¹⁰ 次
t = 10 时彻底超时
而且大部分候选一看就不可能
⚠️注意:其实在暴力枚举时也能加"必须是最大值"的剪枝,但那就等价于正解了——不如直接写成正解。
📈 性能对比
方案单组复杂度n = 10⁵ 运算量
只试最大值O(n)约 2 × 10⁵ 次
枚举所有候选O(n²)约 10¹⁰ 次(超时)
输入一个正整数序列,程序会取出最大值并逐个验证它能否整除所有数。
输入
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
int mx = 0; // 元素都是正整数,从 0 开始取最大安全
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] > mx) mx = a[i];
}
bool ok = true;
for (int i = 0; i < n; i++) {
if (mx % a[i] != 0) { ok = false; break; }
}
printf("%s\n", ok ? "Yes" : "No");
}
return 0;
}
🔑为什么 mx 可以初始化为 0?题目保证 aᵢ 都是正整数(≥ 1),所以 0 一定比它们都小,不会成为错误的"最大值"。如果数据里可能有负数,就必须改用 a[0] 初始化。
📖 关键几行怎么看
代码作用为什么这样写
if (a[i] > mx) mx = a[i];求最大值边读边更新,不用第二次遍历求 max
mx % a[i] != 0整除判断余数为 0 说明能整除
break;提前退出发现一个不满足就可以定 No,省时间
int mx类型选择aᵢ ≤ 10⁹ 未超 int 上限,int 足够
⚠️两个坑:① 枚举所有元素当候选,写出 O(n²) 导致超时;② 理解错题意——题目要的是"是所有数的倍数",不是"与某个数存在倍数关系"。
写完程序后,用这些数据自查一遍:
输入答案考察点
1
3
1 2 4Yes题面样例,4 是所有人的倍数
1
5
1 2 3 4 5No5 不能整除 2
1
1
7Yesn = 1 时必然 Yes(唯一的数必是自身倍数)
1
3
6 3 9No最大值 9,但 9 % 6 ≠ 0
1
4
1 1 1 1Yes全部相等时,任何数都是所有数的倍数
2
3
1 2 4
3
2 3 6Yes
No多组数据,考察 max 是否重置
✅自查清单:① 只检查了最大值吗?② max 每组重置了吗?③ 判断用的是 max % aᵢ == 0 吗?
🚨 易错点清单
⚠️枚举所有候选:写出 O(n²),n = 10⁵ 时超时。要利用"候选只能是最大值"这个推理。
⚠️多组数据忘记重置 max:第二组的 max 会继承上一组的值,结果全错。必须写在 while (t--) 内部。
⚠️把 mx 初始化为 -1 却又用 unsigned:虽然本题用 0 或 -1 都可以(正数),但类型混用容易出意外。
时间复杂度
O(t × n)
空间复杂度
O(n)
t 最大
10
n 最大
10⁵
时间怎么算的?
求最大值一遍 O(n)
验证整除一遍 O(n)
每组 O(n),总计 O(t × n)
最坏 10 × 10⁵ = 10⁶ 次,非常快
空间都用在哪?
需要保存整组数据做第二轮验证,空间 O(n);如果想省空间,也可以把数据存起来后再验证(本题必须回头看,所以数组是必要的)。
✅ 最坏 10⁶ 次取模运算,瞬间完成;如果写成 O(n²) 则必然超时。
// 求最大值的正确初始化
int mx = 0; // 全是正数时可用 0
// int mx = a[0]; // 通用写法(可能有负数时用这个)
// int mx = INT_MIN; // 也通用
// 整除判断
if (mx % a[i] == 0) { /* 能整除 */ }
// 更一般的"候选唯一性"思路示例:
// 求第二大值、判断某个数是否是唯一最大 等
// 都依赖于"先确定候选范围,再验证"的套路
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
最大值性质"是所有数的倍数" ⇒ 必为最大值求众数候选、唯一性判断
候选剪枝把 O(n²) 枚举缩成 O(n)所有"找满足条件元素"的题目
整除判断a % b == 0因数、倍数、约数类题目
🌟思考题:如果题目改成"是否存在一个数是所有数的因数",候选该是谁?(提示:因数不会比原数大,所以候选也只能是最小值——把"最大值"换成"最小值"即可,推理完全对称。)
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
int mx = 0; // 元素都是正整数,从 0 开始取最大安全
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] > mx) mx = a[i];
}
bool ok = true;
for (int i = 0; i < n; i++) {
if (mx % a[i] != 0) { ok = false; break; }
}
printf("%s\n", ok ? "Yes" : "No");
}
return 0;
}// 求最大值的正确初始化
int mx = 0; // 全是正数时可用 0
// int mx = a[0]; // 通用写法(可能有负数时用这个)
// int mx = INT_MIN; // 也通用
// 整除判断
if (mx % a[i] == 0) { /* 能整除 */ }
// 更一般的"候选唯一性"思路示例:
// 求第二大值、判断某个数是否是唯一最大 等
// 都依赖于"先确定候选范围,再验证"的套路小杨想请你判断序列 a 是否是平衡的。
接下来是 t 组测试用例。对每组测试用例,一共两行。
第一行包含一个正整数 n,表示序列长度。
第二行包含 n 个正整数,代表序列 a。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 3 3 1 2 3 4 2 3 1 4 5 1 2 3 4 5 | Yes Yes No |
- 对第一组测试用例,令 i = 2,有 1 + 2 = 3,因此序列是平衡的。
- 对第二组测试用例,令 i = 2,有 2 + 3 = 1 + 4,因此序列是平衡的。
- 对第三组测试用例,不存在满足要求的 i。
数据规模与约定
对全部的测试数据,保证 1 ≤q t ≤q 100,1 ≤q n, a_i ≤q 10000。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定含 n 个正整数的序列 a。如果存在正整数 i(1 ≤ i < n)使得第 1 到第 i 个数字之和等于第 i+1 到第 n 个数字之和,则称该序列是平衡的。请判断给定的序列是否平衡。
本题包含多组测试数据。
💡人话翻译:找一条"分割线",把它插在序列中间某处,让线左边的和与线右边的和相等。线不能插在两端(左右两边都必须至少有一个数)。
🔍 关键词提取
前缀和多组测试枚举分割线总和不变量
已知条件
项目说明
输入第一行 t;每组两行:n 和 n 个数
输出每组一行 Yes 或 No
数据范围t ≤ 100,1 ≤ n, aᵢ ≤ 10000
切分限制1 ≤ i < n,两边都必须非空
需要解决的问题
怎么快速算两边和?先求总和 total,维护左段和 left,右段和 = total − left
要不要每次都重新求和?不要!那是 O(n²);用前缀和滚动更新,一遍 O(n)
i 能取到 n 吗?不能,题目要求 i < n,所以右段至少有一个元素
📥 每组准备
读入 n 和序列
求总和 total
left = 0
注意多组数据要重置
🔁 枚举 i
i 从 1 到 n − 1
left 累加 aᵢ
right = total − left
相等即 Yes
✅ 早期退出
找到就输出 Yes
没有则输出 No
每组独立判断
别忘换行
⚠️ 易错点
i 取到 n(右段为空)
每组忘重置 left
每轮重新求和导致超时
n = 1 时必然 No
样例答案依次是 Yes、Yes、No。我们逐组算出总和,再一个个试分割线。
1
第 1 组:[1, 2, 3]
total = 6
i = 1:left = 1,right = 6 − 1 = 5 → 1 ≠ 5 ❌
i = 2:left = 1 + 2 = 3,right = 6 − 3 = 3 → 相等 ✅
✅ Yes(分割线在 2 与 3 之间)
2
第 2 组:[2, 3, 1, 4]
total = 10
i = 1:left = 2,right = 8 → ❌
i = 2:left = 5,right = 5 → 相等 ✅
✅ Yes
3
第 3 组:[1, 2, 3, 4, 5]
total = 15
i = 1:1 vs 14 ❌
i = 2:3 vs 12 ❌
i = 3:6 vs 9 ❌
i = 4:10 vs 5 ❌
(i 最大只能到 4,因为 i < n = 5)
❌ No,所有分割线都失败
📊 逐组验算表
组序列totali = 1i = 2i = 3i = 4结论
1[1, 2, 3]61/5 ❌3/3 ✅——Yes
2[2, 3, 1, 4]102/8 ❌5/5 ✅6/4 ❌—Yes
3[1, 2, 3, 4, 5]151/14 ❌3/12 ❌6/9 ❌10/5 ❌No
🔑一个有趣的观察:左右相等的条件是 total 能被 2 整除且存在前缀和恰好等于 total / 2。所以如果 total 是奇数,答案一定是 No——这是一个可以提前退出的剪枝。
🟢 前缀和滚动(推荐) 推荐
先求 total,再一遍遍历维护 left
每组 O(n)
总共 O(t × n)
不需要额外数组
代码 8 行
💡为什么推荐:右段和 = total − left,不需要每次重新求和。这是"前缀和"思想最基础的应用。
🟠 双重循环暴力
对每个 i 分别求左段和、右段和
每组 O(n²)
n = 10⁴ 时约 10⁸ 次
t = 100 时严重超时
完全没必要
⚠️注意:本题 n 可达 10⁴、t 可达 100,暴力法最坏 10¹⁰ 次运算,必然超时。
📈 性能对比
方案单组复杂度n = 10⁴ 运算量
前缀和O(n)约 10⁴ 次
双重循环O(n²)约 10⁸ 次(超时)
输入一个正整数序列,程序会逐个试分割线并显示左右两边的和。
输入
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
int a[10005];
long long total = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
total += a[i];
}
bool ok = false;
long long left = 0;
for (int i = 1; i < n; i++) { // i 表示左段长度,最大 n-1
left += a[i - 1]; // 左段和滚动累加
long long right = total - left; // 右段和 = 总和 - 左段和
if (left == right) { ok = true; break; }
}
printf("%s\n", ok ? "Yes" : "No");
}
return 0;
}
🔑为什么用 long long?n ≤ 10⁴、aᵢ ≤ 10⁴,总和最大 10⁸ —— 其实 int 也放得下,但如果数据范围放大到 10⁵ 就会溢出。涉及累加的题目,用 long long 是零成本的好习惯。
📖 关键几行怎么看
代码作用为什么这样写
total += a[i]读入时求和顺便完成,不用再遍历一次
for (i = 1; i < n; i++)枚举分割线i 是左段长度,最大只能到 n−1
left += a[i - 1]滚动更新左段和每轮加上刚并入左段的那个元素
right = total - left右段和用减法代替重新求和,这是关键优化
⚠️三个坑:① 循环写成 i <= n,会让右段为空(和为 0);② left 定义在 while 外面,下一组数据继承了上一组的和;③ 每个 i 都重新求右段和,导致 O(n²) 超时。
写完程序后,用这些数据自查一遍:
输入答案考察点
1
2
1 1Yes两数相等,i = 1
1
4
2 3 1 4Yesi = 2 时 5 = 5
1
5
1 2 3 4 5No题面样例,所有分割线都失败
1
1
7Non = 1 时没有合法 i(i 必须 < n)
1
3
1 1 1Nototal = 3 是奇数,不可能平分
2
3
1 2 3
2
5 5Yes
Yes多组数据,考察状态重置
✅自查清单:① i 的范围是 1 ~ n−1 吗?② left 每组重置了吗?③ 右段和用的是减法吗?
🚨 易错点清单
⚠️忘记重置 left:多组数据时 left 必须每组重新置 0,否则第二组结果会错。
⚠️i 取到 n:i 必须 < n,写成 i <= n 时当 i = n 会出现 left = total、right = 0,误判为不平衡或错误相等。
⚠️每组都重新求右段和:right 用 total − left 直接算,不要写内层循环。
⚠️total 是奇数时还继续算:可以提前输出 No,但即使不剪枝,正常枚举也不会出错。
时间复杂度
O(t × n)
空间复杂度
O(n)
t 最大
100
n 最大
10⁴
时间怎么算的?
每组先读入求和 O(n)
再枚举分割线 O(n)
合计每组 O(n),所有组 O(t × n)
最坏 100 × 10⁴ = 10⁶ 次,轻松通过
空间都用在哪?
需要保存整组序列以便第二轮枚举,空间 O(n)。其实也可以读入时就把前缀和算好、边读边判,省掉数组(但要注意读完才能确定 total)。
✅ 最坏 10⁶ 次操作,瞬间完成;如果写成 O(n²) 则会超时,这是本题的考察点。
// 前缀和的两种常见用法
// 1) 滚动维护(本题用法,O(1) 空间)
long long left = 0;
for (int i = 1; i < n; i++) {
left += a[i - 1];
long long right = total - left;
}
// 2) 预先打表(多次查询区间和时更方便)
long long pre[100005];
pre[0] = 0;
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + a[i - 1];
// 区间 [l, r] 的和 = pre[r+1] - pre[l]
// 判断能否平分的小剪枝
if (total % 2 != 0) { printf("No\n"); continue; }
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
前缀和用 total − left 求右段和区间和查询、子数组和问题
滚动变量只保留当前左段和降低空间复杂度
奇偶剪枝总和为奇数时直接判否平分问题、配对问题的快速判断
🌟思考题:如果题目改成"能否分成三段等和",该怎么做?(提示:total 必须能被 3 整除,目标段和是 total / 3;一遍扫描累计,每当累到目标值就记一次数,最后看能否凑够 3 段。)
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
int a[10005];
long long total = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
total += a[i];
}
bool ok = false;
long long left = 0;
for (int i = 1; i < n; i++) { // i 表示左段长度,最大 n-1
left += a[i - 1]; // 左段和滚动累加
long long right = total - left; // 右段和 = 总和 - 左段和
if (left == right) { ok = true; break; }
}
printf("%s\n", ok ? "Yes" : "No");
}
return 0;
}// 前缀和的两种常见用法
// 1) 滚动维护(本题用法,O(1) 空间)
long long left = 0;
for (int i = 1; i < n; i++) {
left += a[i - 1];
long long right = total - left;
}
// 2) 预先打表(多次查询区间和时更方便)
long long pre[100005];
pre[0] = 0;
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + a[i - 1];
// 区间 [l, r] 的和 = pre[r+1] - pre[l]
// 判断能否平分的小剪枝
if (total % 2 != 0) { printf("No\n"); continue; }具体来说,第一行需要输出 MON TUE WED THU FRI SAT SUN,分别表示星期一到星期日。接下来若干行中依次输出这个月所包含的日期,日期的个位需要和对应星期几的缩写最后一个字母对齐。例如,2025 年 9 月 1 日是星期一,在输出九月的日历时,1 号的个位 1 就需要与星期一 MON 的最后一个字母 N 对齐。九月的日历输出效果如下:
MON TUE WED THU FRI SAT SUN 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
你能帮助小 A 完成日历的制作吗?
| # | 输入 | 输出 |
|---|---|---|
| 1 | 9 | MON TUE WED THU FRI SAT SUN 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
| 2 | 6 | MON TUE WED THU FRI SAT SUN
1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 |
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
制作 2025 年每个月的日历。第一行输出 MON TUE WED THU FRI SAT SUN,接下来依次输出该月日期,日期的个位要与对应星期缩写最后一个字母对齐。
例如 2025 年 9 月 1 日是星期一,则 1 号的个位要与 MON 的最后一个字母 N 对齐。
💡人话翻译:本质是两件事——① 算出这个月 1 号是星期几(记为偏移量);② 按每列 4 个字符的宽度把 1 到该月最后一天排出来。注意 2025 年是平年,2 月只有 28 天。
🔍 关键词提取
日期推算闰年判定格式化输出列对齐
已知条件
项目说明
输入一行一个正整数 m(1 ~ 12)
输出2025 年 m 月的日历
年份固定2025 年,平年(2 月 28 天)
表头MON TUE WED THU FRI SAT SUN
对齐规则日期的个位与星期缩写的末字母对齐
需要解决的问题
每月几天?打表:31、28、31、30、31、30、31、31、30、31、30、31
1 号是星期几?已知 2025-01-01 是星期三,累加前面各月天数再对 7 取模
怎么对齐?表头每个缩写占 3 字符 + 1 空格分隔,所以每个日期用 %3d 输出、后面跟一个空格
怎么换行?每输出 7 格换一行,行尾空格要处理掉
📥 准备数据
days[1..12] 打表
2025 年非闰年
2 月固定 28 天
已知 1 月 1 日星期三
🧮 算星期
累加 m-1 个月的总天数
总天数 mod 7
再加上基准星期三
得到 1 号的列号
📤 格式化
表头固定 27 字符
每个日期 printf("%3d ")
满 7 个换行
行尾空格去掉
⚠️ 易错点
闰年不要漏判
偏移量要取模
列数从 0 数还是 1 数
行末空格
基准:2025 年 1 月 1 日是星期三(对应表头第 3 列,从 0 开始编号的话是下标 2)。
1
9 月 1 日
前面 1 ~ 8 月总天数 = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 = 243
243 mod 7 = 5(243 = 34 × 7 + 5)
星期三往后数 5 天:三 → 四 → 五 → 六 → 日 → 一
✅ 9 月 1 日是星期一,与题面一致
2
6 月 1 日
前面 1 ~ 5 月总天数 = 31 + 28 + 31 + 30 + 31 = 151
151 mod 7 = 4(151 = 21 × 7 + 4)
星期三往后数 4 天:三 → 四 → 五 → 六 → 日
✅ 6 月 1 日是星期日,所以样例 2 第一行只有 1 个数字,且落在最后一列
📊 样例 2 的排布(6 月,30 天)
行MONTUEWEDTHUFRISATSUN
第 1 行——————1
第 2 行2345678
........................
第 5 行30——————
🔑关键:偏移量就是"这个月 1 号前面要空几格"。6 月空 6 格,9 月空 0 格。所以只要算出偏移,其余全是机械排版。
🟢 累加天数 + 打表 推荐
用数组存每月天数,把前 m-1 个月加起来对 7 取模
时间 O(12),实际是常数
空间 O(1)
逻辑和后文解释完全对应
不容易算错
💡为什么推荐:年份固定为 2025,甚至可以把 12 个月的偏移量直接打表写死,连算都不用算。
🔵 蔡勒公式
用蔡勒(Zeller)公式直接由年月日算出星期
通用性最强,能处理任意年份
公式长、易抄错
本题年份固定,属于过度设计
⚠️注意:蔡勒公式要处理 1 月 2 月"算作上一年"的特例,三级考试用它很容易出错。
📈 性能对比
方案代码量出错概率
累加打表约 20 行低
蔡勒公式约 10 行(但公式长)中高
输入月份(1 ~ 12),立刻看到这个月的日历排布,并标出 1 号所在列。
输入月份
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
int m;
scanf("%d", &m);
// 2025 年是平年,2 月 28 天
int days[13] = {0, 31,28,31,30,31,30,31,31,30,31,30,31};
// 2025-01-01 是星期三;下面算 m 月 1 日的偏移(周一为 0)
int acc = 0;
for (int i = 1; i < m; i++) acc += days[i];
int offset = (2 + acc) % 7; // 2 代表星期三
printf("MON TUE WED THU FRI SAT SUN\n");
int col = 0; // 当前行已输出几列
for (int i = 0; i < offset; i++) { // 1 号之前先空出若干格
printf(" "); // 3 位数字 + 1 个空格
col++;
}
for (int d = 1; d <= days[m]; d++) {
printf("%3d ", d); // 右对齐 3 位,再跟 1 个空格
col++;
if (col == 7) { printf("\n"); col = 0; }
}
if (col != 0) printf("\n"); // 最后一行不足 7 列时补换行
return 0;
}
🔑为什么用 %3d 加一个空格?表头 MON TUE ... 中每个缩写占 3 个字符,后面跟 1 个空格,所以一整列宽 4 个字符。日期用 %3d 右对齐后再补一个空格,个位就会正好落在该列最后一个字符的位置上,与表头末字母对齐。
📖 关键几行怎么看
代码作用为什么这样写
days[13] = {0, 31, 28, ...}每月天数表下标 1 对应 1 月,写起来最直观
offset = (2 + acc) % 7算 1 号星期2 = 星期三,acc 是前面月份总天数
printf(" ")输出空列4 个空格正好等于一列的宽度
printf("%3d ", d)输出日期右对齐 3 位 + 1 空格 = 一列 4 字符
if (col == 7)换行每行固定 7 列(周一到周日)
⚠️行末空格问题:上面写法每行末尾会多一个空格。绝大多数评测会忽略行末空格,但若严格比对,可以改成"先把一行拼成字符串,去掉尾部空格再输出"——这样最稳。
写完程序后,用这些数据自查一遍:
输入答案考察点
9见样例 1偏移 0,1 号在周一
6见样例 2偏移 6,1 号在周日
11 号在周三基准月,偏移 = 2
2只有 28 天考察平年 2 月
1231 天年末月份
✅自查清单:① 2 月是 28 吗?② offset 取模了吗?③ 表头是从 MON 开始的吗?④ 每行是不是 7 列?
🚨 易错点清单
⚠️把 2 月当成 29 天:2025 年是平年(2025 ÷ 4 有余数),2 月只有 28 天。闰年判定要写成 (y%4==0 && y%100!=0) || y%400==0。
⚠️偏移量没取模:累计天数可能大于 7,必须 % 7 后才能当列号。
⚠️把星期顺序搞反:表头是从周一开始的,如果按"周日在前"的日历习惯写,整体会错一列。
⚠️最后一行没换行:输出结束时也要保证有换行符,否则可能被判格式错误。
时间复杂度
O(1)
空间复杂度
O(1)
月份数
12
输出行数
最多 6
时间怎么算的?
算偏移:最多累加 11 个数
输出日期:最多 31 个
都是常数级,与输入规模无关,所以是 O(1)
空间都用在哪?
只需要一个长度 13 的数组存每月天数,其余都是几个整数变量。
✅ 输入只有 12 种可能,任何写法都能瞬间出结果,重点是格式要完全正确。
// 闰年判定(能处理任意年份的通用写法)
bool isLeap(int y) {
return (y % 4 == 0 && y % 100 != 0) || (y % 400 == 0);
}
// 按天累加算星期(通用版,基准 2000-01-01 是星期六)
int weekdayOf(int y, int m, int d) {
int days[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
if (isLeap(y)) days[2] = 29;
int acc = 0;
for (int i = 1; i < m; i++) acc += days[i];
acc += d - 1;
return (5 + acc) % 7; // 5 代表星期六(周一为 0)
}
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
每月天数打表days[] 数组 + 下标对齐所有日历、日期类题目
累加取模求星期天数差 mod 7日期推算、星期计算
格式化对齐输出%3d + 空格凑成固定列宽表格输出、图案输出、成绩单排版
🌟思考题:如果题目改成"输出 2026 年 m 月",代码要改哪几个地方?(提示:2025 年有 365 天,365 mod 7 = 1,所以 2026 年 1 月 1 日变成星期四,基准从 2 改成 3 即可。)
#include <bits/stdc++.h>
using namespace std;
int main() {
int m;
scanf("%d", &m);
// 2025 年是平年,2 月 28 天
int days[13] = {0, 31,28,31,30,31,30,31,31,30,31,30,31};
// 2025-01-01 是星期三;下面算 m 月 1 日的偏移(周一为 0)
int acc = 0;
for (int i = 1; i < m; i++) acc += days[i];
int offset = (2 + acc) % 7; // 2 代表星期三
printf("MON TUE WED THU FRI SAT SUN\n");
int col = 0; // 当前行已输出几列
for (int i = 0; i < offset; i++) { // 1 号之前先空出若干格
printf(" "); // 3 位数字 + 1 个空格
col++;
}
for (int d = 1; d <= days[m]; d++) {
printf("%3d ", d); // 右对齐 3 位,再跟 1 个空格
col++;
if (col == 7) { printf("\n"); col = 0; }
}
if (col != 0) printf("\n"); // 最后一行不足 7 列时补换行
return 0;
}// 闰年判定(能处理任意年份的通用写法)
bool isLeap(int y) {
return (y % 4 == 0 && y % 100 != 0) || (y % 400 == 0);
}
// 按天累加算星期(通用版,基准 2000-01-01 是星期六)
int weekdayOf(int y, int m, int d) {
int days[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
if (isLeap(y)) days[2] = 29;
int acc = 0;
for (int i = 1; i < m; i++) acc += days[i];
acc += d - 1;
return (5 + acc) % 7; // 5 代表星期六(周一为 0)
}A 表示 10、F 表示 15。如果扩展到用 Z 表示 35,岂不是可以表示 36 进制数了嘛!所以,你需要帮助她写一个程序,完成十进制转 R 进制(2≤ R≤ 36)的工作。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 123 25 | 4N |
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
十六进制中 A 表示 10、F 表示 15。如果扩展到用 Z 表示 35,就可以表示 36 进制数了。请完成十进制转 R 进制(2 ≤ R ≤ 36)的工作。
例如输入 123 和 25,输出 4N。
💡人话翻译:反复做"除以 R 取余数",把余数从后往前拼起来就是答案。余数 0 ~ 9 用数字字符表示,10 ~ 35 用 A ~ Z 表示。
🔍 关键词提取
除基取余逆序拼接字符映射表边界处理
已知条件
项目说明
输入第一行 N,第二行 R
输出N 的 R 进制表示
数值范围1 ≤ N ≤ 10⁶
进制范围2 ≤ R ≤ 36
字符映射0 ~ 9 用数字,10 ~ 35 用 A ~ Z
需要解决的问题
怎么转换?N 反复除以 R,记录每次的余数,最后把余数序列倒过来
余数 10 怎么变成字符?准备一个字符串 "0123456789ABC…Z",用余数当下标直接查
N 是 0 怎么办?本题 N ≥ 1,但规范写法应该特判输出 "0"
📥 读入
读 N 和 R
R 在 2 ~ 36
N 可达 10⁶
用 int 就够
🔁 除法循环
N 除以 R 得商和余数
余数当"低位"先得到
商作为下一轮的被除数
直到商为 0
🔤 字符映射
建表 "0-9A-Z"
余数当数组下标
要 .c_str() 或直接整串
10 → A、35 → Z
🔚 输出
余数序列要倒序
可以边算边往前面插
或存数组后逆序输出
N = 0 特判
反复做"除 25 取余",把余数倒过来拼。
1
第 1 轮
123 ÷ 25 = 4 余 23
23 对应的字符是 N(A = 10、B = 11 … N = 23)
商 4 作为下一轮的被除数
得到最低位 N
2
第 2 轮
4 ÷ 25 = 0 余 4
4 对应的字符是 4
商为 0,循环结束
得到次低位 4
3
倒序拼接
余数出现顺序是 23、4
倒过来就是 4、23
对应字符 4 和 N
✅ 结果 4N
轮次被除数÷ 25 的商余数余数对应的字符
1123423N
24044
倒序拼接:4 + N = 4N ✓(验算:4 × 25 + 23 = 100 + 23 = 123)
🧮 字符映射表怎么建
36 进制需要 36 个字符,正好用 "0123456789ABC…Z" 这个长度 36 的串。
余数对应字符说明
0 ~ 90 ~ 9直接用数字字符
10A十进制的 10 在十六进制里就是 A
15F十六进制最大值
23N本题样例用到的
35Z36 进制的最大值
🔑为什么把字符表写成一个字符串最方便?因为 "0123456789ABC...Z"[余数] 正好就是该余数对应的字符,一个下标运算解决映射,不用写任何 if-else。
🟢 字符表取下标(推荐) 推荐
准备 36 个字符的字符串,用余数当下标
时间 O(log_R N)
映射只需一次下标
扩展到 36 进制毫无压力
代码 12 行
💡循环次数:N ≤ 10⁶、R ≥ 2 时最多约 20 次除法,所以运算量极小。
🟠 用 if-else 判断余数范围
余数小于 10 输出数字,否则输出对应字母
多一个分支但也不难
只支持到 36 进制
可读性尚可
两者都行
⚠️对比:分支写法要多写 if (r < 10) 这样的判断,字符表写法更统一,也不容易在边界(余数 = 9 或 10)出错。
📈 性能对比
方案代码量边界风险
字符表约 12 行低
if 分支约 15 行中
输入两个整数:N 和 R(用空格分隔),程序会展示除基取余的每一步。
输入 N 和 R
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
int N, R;
scanf("%d %d", &N, &R);
// 字符表:余数 0~35 直接当下标查
const string DIG = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
if (N == 0) { printf("0\n"); return 0; } // 特判 0
string ans = "";
while (N > 0) {
int r = N % R;
ans = DIG[r] + ans; // 关键:插到最前面,实现"逆序"
N /= R;
}
printf("%s\n", ans.c_str());
return 0;
}
🔑ans = DIG[r] + ans 这一行为什么能实现逆序?每算出一个新余数(它是更高的一位),就把它拼到当前字符串的前面。这样一轮轮下来,最终顺序自然就对了,不用再单独做一次 reverse。
📖 关键几行怎么看
代码作用为什么这样写
const string DIG = "0-9A-Z"字符映射表一共 36 个字符,余数直接当下标
if (N == 0)特判 00 的循环一次都不会执行,会输出空串,必须单独处理
ans = DIG[r] + ans逆序拼接新余数是高位,插到前面
N /= R更新被除数整数除法自动取整
⚠️三个坑:① 忘了特判 N = 0,会输出空行;② 用 ans += DIG[r] 顺序拼接,得到的是倒序结果(低位在前),必须反转;③ 字符表只写到 F(只支持 16 进制),本题要求支持到 36 进制,必须写到 Z。
写完程序后,用这些数据自查一遍:
输入答案考察点
123 254N题面样例
10 21010转二进制
255 16FF转十六进制
1 21最小输入
1000000 36LFLS最大规模 + 最大进制
35 36Z正好用到字符表最后一个
✅自查清单:① 字符表够 36 个吗?② 拼接顺序对吗(新余数插前面)?③ 特判 0 了吗?
🚨 易错点清单
⚠️忘了特判 N = 0:循环体一次都不执行,会输出空字符串。本题 N ≥ 1 所以不影响,但规范写法要加上。
⚠️顺序拼接:ans += DIG[r] 得到的是低位在前,必须写 ans = DIG[r] + ans 或最后 reverse。
⚠️字符表不全:只写到 F 就只能处理 16 进制,36 进制需要完整的 0-9A-Z。
时间复杂度
O(log_R N)
空间复杂度
O(log_R N)
N 最大
10⁶
循环次数
最多约 20
时间怎么算的?
每轮做一次除法和一次取余
N 每次缩小 R 倍,所以循环 log_R N 次
N = 10⁶、R = 2 时最多约 20 次
空间都用在哪?
需要存下结果字符串,长度就是转换后的位数 log_R N。
✅ 最多 20 次循环,任何写法都瞬间完成。
// 十进制转任意进制(2 ~ 36)的标准模板
string toBase(int n, int base) {
const string DIG = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
if (n == 0) return "0";
string ans;
while (n > 0) { ans = DIG[n % base] + ans; n /= base; }
return ans;
}
// 任意进制转十进制
int toDecimal(const string &s, int base) {
const string DIG = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int r = 0;
for (char c : s) r = r * base + (int)DIG.find(c);
return r;
}
// 用 <bitset> 或 printf 直接输出(仅限 2/8/16 进制)
// printf("%o", n); 八进制
// printf("%X", n); 十六进制
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
除基取余反复除 R 记录余数所有进制转换题
字符表映射用值当下标查字符编码、映射、查表类问题
插前面实现逆序ans = c + ans需要逆序输出的场景
🌟思考题:如果要反过来——把 R 进制字符串转成十进制,该怎么写?(提示:从左到右累乘:result = result × R + 当前位的值,这是上面 toDecimal 的思路,比逐位加幂次更简洁。)
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, R;
scanf("%d %d", &N, &R);
// 字符表:余数 0~35 直接当下标查
const string DIG = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
if (N == 0) { printf("0\n"); return 0; } // 特判 0
string ans = "";
while (N > 0) {
int r = N % R;
ans = DIG[r] + ans; // 关键:插到最前面,实现"逆序"
N /= R;
}
printf("%s\n", ans.c_str());
return 0;
}// 十进制转任意进制(2 ~ 36)的标准模板
string toBase(int n, int base) {
const string DIG = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
if (n == 0) return "0";
string ans;
while (n > 0) { ans = DIG[n % base] + ans; n /= base; }
return ans;
}
// 任意进制转十进制
int toDecimal(const string &s, int base) {
const string DIG = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int r = 0;
for (char c : s) r = r * base + (int)DIG.find(c);
return r;
}
// 用 <bitset> 或 printf 直接输出(仅限 2/8/16 进制)
// printf("%o", n); 八进制
// printf("%X", n); 十六进制②编程打卡 · 点一下就能勾选
- 完成 B3957《完全平方数》,跑通全部样例
- 完成 B4066《数字替换》,跑通全部样例
- 完成 B4413《数组清零》,跑通全部样例
- 完成 B4450《小杨的智慧购物》,跑通全部样例
- 完成 B4555《加密》,跑通全部样例
- 完成 B3996《小洛的数字游戏》,跑通全部样例
- 完成 B3842《春游》,跑通全部样例
- 完成 B4004《寻找倍数》,跑通全部样例
- 完成 B4038《平衡序列》,跑通全部样例
- 完成 B4414《日历制作》,跑通全部样例
- 完成 B3849《进制转换》,跑通全部样例
- 对比题解里的参考代码,找出自己写法的差异
字符串处理(上)
①本日知识点 · 字符串处理(上)
本组 6 道题全部来自 GESP 真题,按「字符串处理(上)」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。
小杨只学了长度单位和重量单位,具体来说:
- 长度单位包括千米(km)、米(m)、毫米(mm),它们之间的关系是:1km = 1000m = 1000000mm。
- 重量单位包括千克(kg)、克(g)、毫克(mg),它们之间的关系是:1kg = 1000g = 1000000mg。
小杨的作业只涉及将更大的单位转换为更小的单位,也就是说,小杨的作业只会包含如下题型:米转换为毫米,千米转换为毫米,千米转换为米,克转换为毫克,千克转换为毫克,千克转换为克。
现在,请你帮忙完成单位转换的程序。
接下来 N 行,每行一个字符串,表示转换单位的题目,格式为 x 单位 1 = ? 单位 2。其中,x 为一个不超过 1000 的非负整数, 单位 1 和 单位 2 分别为两个单位的英文缩写,保证它们都是长度单位或都是重量单位,且 单位 1 比 单位 2 更大。
例如,如果题目需要你将 1km 转换为 mm,则输入为 1 km = ? mm。
保证 1≤ N ≤ 1000。
例如,如果题目需要你将 1km 转换为 mm,则输入为 1 km = ? mm。则你需要输出 1 km = 1000000 mm。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 2 1 km = ? mm 1 m = ? mm | 1 km = 1000000 mm 1 m = 1000 mm |
| 2 | 5 100 m = ? mm 1000 km = ? m 20 kg = ? g 200 g = ? mg 0 kg = ? mg | 100 m = 100000 mm 1000 km = 1000000 m 20 kg = 20000 g 200 g = 200000 mg 0 kg = 0 mg |
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
小杨的作业只涉及把大单位换成小单位,包含以下 6 种题型:
长度:1 km = 1000 m,1 m = 1000 mm,1 km = 1000000 mm
重量:1 kg = 1000 g,1 g = 1000 mg,1 kg = 1000000 mg
输入每行形如 x 单位1 = ? 单位2,输出时把 ? 换成答案,其余部分一字不差地输出。
例如输入 1 km = ? mm,输出 1 km = 1000000 mm。
💡人话翻译:这题有两件事:① 从字符串里"抠出"数字和两个单位名;② 用换算表算出答案,然后照原格式打印回去。注意输出格式必须和输入完全一致,只有 ? 被替换。
🔍 关键词提取
字符串解析单位换算表格式化输出整数运算
已知条件
项目说明
输入第一行 N;随后 N 行每题一条
输出N 行,把 ? 换成答案
数据范围1 ≤ N ≤ 1000
数值范围x 是不超过 1000 的非负整数
单位关系1 km = 1000 m = 1000000 mm;重量同理
方向保证单位 1 一定比单位 2 大(大换小)
需要解决的问题
怎么把字符串拆开?用 scanf("%d %s = ? %s") 这类格式直接读,比手动切分省事
怎么换算?把每个单位换算成"最小单位"的系数,答案 = x × 系数[单位1] ÷ 系数[单位2]
会不会除不尽?不会。因为单位 1 更大,系数[单位1] 一定是 系数[单位2] 的整数倍
📥 解析输入
读 N
每题读 x、u1、u2
用 scanf 格式串直接切
不用手动 split
📊 系数表
以最小单位为基准
mm = 1、m = 1000、km = 1000000
mg = 1、g = 1000、kg = 1000000
同名单位共用一张表
🧮 计算
答案 = x × 系数[u1] / 系数[u2]
大换小 ⇒ 结果放大
整数除法不会有余数
用 long long 更稳
🖨️ 输出
照原格式打印
把 ? 换成答案
其余字符一字不差
每行一个结果
先看输入格式怎么解析,再看怎么算。
1
题目一:1 km = ? mm
解析得到 x = 1、单位1 = km、单位2 = mm
查系数:系数[km] = 1000000,系数[mm] = 1
答案 = 1 × 1000000 ÷ 1 = 1000000
✅ 输出:1 km = 1000000 mm
2
题目二:1 m = ? mm
x = 1、单位1 = m、单位2 = mm
系数[m] = 1000,系数[mm] = 1
答案 = 1 × 1000 ÷ 1 = 1000
✅ 输出:1 m = 1000 mm
📊 系数表(以最小单位为 1)
单位类别换算系数说明
mm长度1基准(最小)
m长度10001 m = 1000 mm
km长度10000001 km = 1000000 mm
mg重量1基准(最小)
g重量10001 g = 1000 mg
kg重量10000001 kg = 1000000 mg
🔑为什么用"统一基准"而不是写 6 个分支?如果写成 if (u1=="km" && u2=="m") ans = x*1000; ...,要写 6 条甚至更多分支,还容易漏。用系数表后,一行公式通吃所有组合,新增单位也只需加一行数据。
🧮 样例 2:五道题速查
这组数据 x 取到 1000,考察数值范围。
输入系数比答案输出
100 m = ? mm1000 ÷ 1 = 1000100000100 m = 100000 mm
1000 km = ? m1000000 ÷ 1000 = 100010000001000 km = 1000000 m
20 kg = ? g1000000 ÷ 1000 = 10002000020 kg = 20000 g
200 g = ? mg1000 ÷ 1 = 1000200000200 g = 200000 mg
0 kg = ? mg0 × 1000000 = 000 kg = 0 mg
⚠️0 是合法输入:x 可以取 0,此时答案就是 0。别写"x 必须为正"之类的假设。另外注意答案最大可能是 1000 × 1000000 = 10⁹,刚好在 int 边界附近,用 long long 最保险。
🟢 系数表(推荐) 推荐
每个单位映射到一个换算系数,用统一公式算
时间 O(N)
公式只有一行
新增单位只需加数据
不会漏分支
💡实现方式:用 map<string,long long> 存"单位名 → 系数",读入后用两个 [] 取系数即可。
🟠 写 6 个 if 分支
对每种题型单独判断
6 条分支容易漏写
代码冗长
改题目就要重写
还容易写错倍数
⚠️注意:单位是"字符串",用 if 比较字符串要写 u1 == "km" 这样,6 种组合 × 2 个类别很容易出错。
📈 性能对比
方案分支数出错概率
系数表0(统一公式)低
if 分支6 ~ 12 条中高
每行输入一条题目(格式:x 单位1 = ? 单位2),程序会算出答案并按原格式输出。
输入题目(每行一条)1 km = ? mm
1 m = ? mm
100 m = ? mm
20 kg = ? g
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
// 单位名 -> 相对最小单位的系数
map<string, long long> ratio = {
{"mm", 1}, {"m", 1000}, {"km", 1000000},
{"mg", 1}, {"g", 1000}, {"kg", 1000000}
};
int N;
scanf("%d", &N);
while (N--) {
long long x;
char u1[10], u2[10];
// 直接按格式读:数字 空格 单位 空格 = 空格 ? 空格 单位
scanf("%lld %s = ? %s", &x, u1, u2);
long long ans = x * ratio[u1] / ratio[u2];
// 输出时把 ? 换成答案,其余照抄
printf("%lld %s = %lld %s\n", x, u1, ans, u2);
}
return 0;
}
🔑用 scanf 的格式串跳过固定字符:"%lld %s = ? %s" 里的 = 和 ? 会按字面匹配并跳过,这样就不用手动切分字符串了。这是格式化输入最实用的技巧之一。
📖 关键几行怎么看
代码作用为什么这样写
map<string,long long> ratio系数表用 map 让"单位名"直接当键,取系数写 ratio[u1]
scanf("%lld %s = ? %s", ...)解析输入格式串里的 = 和 ? 会被自动跳过
x * ratio[u1] / ratio[u2]计算答案先乘后除,因为大换小一定整除
printf("%lld %s = %lld %s\n", ...)原样输出把解析出的部分重新拼回去,格式与输入一致
⚠️两个坑:① 用 int 存答案:最大 1000 × 1000000 = 10⁹,接近 int 上限,建议 long long;② 输出时多输出或漏输出空格,必须严格保持 x 单位1 = 答案 单位2 这个格式。
写完程序后,用这些数据自查一遍:
输入答案考察点
1 km = ? mm1 km = 1000000 mm跨两级换算
1 m = ? mm1 m = 1000 mm相邻单位
100 m = ? mm100 m = 100000 mmx 大于 1
1000 km = ? m1000 km = 1000000 mx 取到上限 1000
0 kg = ? mg0 kg = 0 mgx = 0 是合法输入
1 kg = ? g1 kg = 1000 g重量单位
✅自查清单:① 系数表覆盖 6 个单位了吗?② 用的是 long long 吗?③ 输出格式与输入一致吗?
🚨 易错点清单
⚠️手动切分字符串:自己写 split 容易在 =、? 前后的空格上出错,用 scanf 格式串更稳。
⚠️用 int 存答案:最大值 10⁹ 接近 int 上限,运算中一旦再加就会溢出,用 long long。
⚠️输出格式不一致:题目要求"其余部分一字不差",空格、等号、问号的位置都必须还原正确。
时间复杂度
O(N)
空间复杂度
O(1)
N 最大
1000
运算量
1000 次
时间怎么算的?
每条题目做一次解析、一次乘除
map 查表是 O(log 6),可视为常数
合计 O(N)
空间都用在哪?
系数表只有 6 项,是固定大小,不需要额外空间。
✅ N ≤ 1000,任何实现都瞬间完成;这题的难点在字符串解析和格式还原。
// scanf 格式串跳过固定字符的用法
scanf("%lld %s = ? %s", &x, u1, u2); // 输入 "1 km = ? mm"
// 也可以跳过多余空格:%*s 跳过一个"单词"
// 用 map 做"名字 -> 数值"的映射
map<string, long long> ratio;
ratio["km"] = 1000000;
// 取值:ratio[u1](不存在时自动插入 0,要小心)
// 更安全的写法:先判断存在性
if (ratio.find(u1) == ratio.end()) { /* 未知单位 */ }
// 整数乘除注意顺序
long long ans = x * ratio[u1] / ratio[u2]; // 先乘后除
// 不要写成 x / ratio[u2] * ratio[u1],会因整除丢精度
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
scanf 格式串按字面跳过 = 和 ?所有"固定格式输入"的题目
map 当换算表字符串键 → 数值单位换算、字典查询、编码映射
先乘后除a * b / c 而非 a / c * b所有涉及整除的题目
🌟思考题:如果题目改成"允许大换小也允许小换大",并且答案可能是小数(例如 1 mm = ? m = 0.001 m),代码要怎么改?(提示:系数表不用改,公式也不用改,但答案类型要从整数变成浮点数,并且要注意输出的小数位数。)
#include <bits/stdc++.h>
using namespace std;
int main() {
// 单位名 -> 相对最小单位的系数
map<string, long long> ratio = {
{"mm", 1}, {"m", 1000}, {"km", 1000000},
{"mg", 1}, {"g", 1000}, {"kg", 1000000}
};
int N;
scanf("%d", &N);
while (N--) {
long long x;
char u1[10], u2[10];
// 直接按格式读:数字 空格 单位 空格 = 空格 ? 空格 单位
scanf("%lld %s = ? %s", &x, u1, u2);
long long ans = x * ratio[u1] / ratio[u2];
// 输出时把 ? 换成答案,其余照抄
printf("%lld %s = %lld %s\n", x, u1, ans, u2);
}
return 0;
}// scanf 格式串跳过固定字符的用法
scanf("%lld %s = ? %s", &x, u1, u2); // 输入 "1 km = ? mm"
// 也可以跳过多余空格:%*s 跳过一个"单词"
// 用 map 做"名字 -> 数值"的映射
map<string, long long> ratio;
ratio["km"] = 1000000;
// 取值:ratio[u1](不存在时自动插入 0,要小心)
// 更安全的写法:先判断存在性
if (ratio.find(u1) == ratio.end()) { /* 未知单位 */ }
// 整数乘除注意顺序
long long ans = x * ratio[u1] / ratio[u2]; // 先乘后除
// 不要写成 x / ratio[u2] * ratio[u1],会因整除丢精度a 代表了正整数 1,字母 b 代表了正整数 2;对于每一个大写英文字母,该大写字母代表了一个负整数,即该字母的 ASCII 码的相反数,例如字母 A 代表了负整数 -65。小杨同学利用这种放缩对一个整数进行了加密并得到了一个由大写字母和小写字母组成的字符串,该字符串中每个字母所代表数字的总和即为加密前的整数,例如 aAc 对应的加密前的整数为 1+(-65)+3=-61。对于给定的字符串,请你计算出它对应的加密前的整数是多少。
第二行一个由大写字母和小写字母的字符串
T,代表加密后得到的字符串。| # | 输入 | 输出 |
|---|---|---|
| 1 | 3 aAc | -61 |
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
小杨发明了一种新型密码:
小写字母代表它在字母表中的位置:a 代表 1,b 代表 2 …… z 代表 26
大写字母代表它 ASCII 码的相反数:A 代表 −65
给定加密后的字符串,求所有字母代表的数字之和。
例如 aAc 对应 1 + (−65) + 3 = −61。
💡人话翻译:逐字符判断大小写,小写就转换成 1 ~ 26 里的一个数,大写就直接取它 ASCII 码的负值,然后把所有数字加起来。两类字符用的是完全不同的规则,别搞混。
🔍 关键词提取
字符与数字映射ASCII 码大小写分支累加求和
已知条件
项目说明
输入第一行 n;第二行一个大小写字母组成的字符串
输出所有字母代表数字之和
数据范围1 ≤ n ≤ 10⁵
小写规则a = 1,b = 2,…,z = 26
大写规则A = −65,B = −66,…,Z = −90(ASCII 码取负)
需要解决的问题
小写字母怎么转 1 ~ 26?c - 'a' + 1,例如 c 是 'c' 时得到 3
大写字母怎么转?直接 -(int)c,因为要的是 ASCII 码的相反数
怎么区分大小写?c >= 'a' 为真就是小写(大写字母的 ASCII 码更小)
📥 读入
读 n(其实可以不用)
读入字符串 T
逐字符处理
注意可能很长
🔡 小写分支
判断 c >= 'a'
值 = c − 'a' + 1
a→1、b→2、…、z→26
都是正数
🔠 大写分支
值 = −(int)c
A→−65、Z→−90
都是负数
别写成 c − 'A' + 1
➕ 累加
sum 用 long long
逐个加上去
最后输出 sum
注意负数输出
字符串三个字符,我们逐个判断并求值。
1
第 1 个字符:a(小写)
判断 c >= 'a' 成立 → 小写分支
值 = 'a' − 'a' + 1 = 0 + 1 = 1
贡献 +1
2
第 2 个字符:A(大写)
判断 c >= 'a' 不成立 → 大写分支
值 = −(int)'A' = −65
贡献 −65
3
第 3 个字符:c(小写)
小写分支:值 = 'c' − 'a' + 1 = 2 + 1 = 3
贡献 +3
4
求和
1 + (−65) + 3 = −61
✅ 输出 −61
字符大小写计算方式代表的值
a小写'a' − 'a' + 11
A大写−(int)'A'−65
c小写'c' − 'a' + 13
🔑注意大小写用的是完全不同的规则:小写是"字母表位置"(1 ~ 26),大写是"ASCII 码取负"(−65 ~ −90)。千万不要把大写也写成 c − 'A' + 1,那会得到 1 ~ 26 的正数,和题意完全不符。
🧮 再看几个边界
字符串逐字符值总和说明
a11最小值
z2626小写最大
A−65−65大写最小绝对值
Z−90−90大写最大绝对值
azAZ1 + 26 + (−65) + (−90)−128混合情形
💡结果可能为负:因为大写字母贡献的是 −65 这样的负数,所以答案完全可能是负数。不要以为"求和"就一定是正数。
🟢 逐字符分支(推荐) 推荐
遍历字符,按大小写走两条路径
时间 O(n)
空间 O(1)
代码 6 行
不需要额外数组
💡为什么推荐:小写是连续的一段 ASCII,用 c >= 'a' 一次判断就能分流,不需要写 52 个 if。
🟠 预打值表
把 52 个字母对应的值预先存进数组,直接查表
查表 O(1) 但结构更重
需要初始化 52 项
可读性反而下降
本题没必要
⚠️什么时候值得:如果映射关系没有规律(比如任意自定义编码),打表才划算。本题两条规则都很规整,直接算更好。
📈 性能对比
方案代码量可读性
逐字符分支约 6 行⭐⭐⭐⭐⭐
预打值表约 15 行⭐⭐⭐
输入一个大小写字母组成的字符串,程序会逐字符给出它代表的值并求总和。
输入字符串
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
char s[100005];
scanf("%s", s);
long long sum = 0;
for (int i = 0; i < n; i++) {
char c = s[i];
if (c >= 'a' && c <= 'z') {
sum += (c - 'a' + 1); // 小写:字母表位置 1 ~ 26
} else {
sum += -(int)c; // 大写:ASCII 码的相反数
}
}
printf("%lld\n", sum);
return 0;
}
🔑为什么用 long long 更稳?n ≤ 10⁵ 时最坏情况是全为 Z,总和约 −9 × 10⁶,int 其实放得下。但把 sum 写成 long long 是零成本的好习惯,尤其当数据范围不确定时。
📖 关键几行怎么看
代码作用为什么这样写
c >= 'a' && c <= 'z'判断小写小写字母的 ASCII 是连续的一段,区间判断最省事
c - 'a' + 1小写转 1 ~ 26减去 'a' 得到 0 ~ 25,再加 1
-(int)c大写转负数题目要求的是 ASCII 码的相反数
scanf("%s", s)读入字符串不含空格,%s 就够
⚠️最容易犯的错:把大写字母也按"字母表位置"处理,写成 c - 'A' + 1。那样 A 会得到 +1 而不是 −65,结果全错。题目对大写的定义是 ASCII 码取负,不是字母位置。
写完程序后,用这些数据自查一遍:
输入答案考察点
3
aAc−61题面样例
1
a1小写最小值
1
A−65大写:−65
1
Z−90大写最大值:−90
4
azAZ−1281 + 26 − 65 − 90 = −128,混合情形
3
ABC−198−65 − 66 − 67
✅自查清单:① 大小写判断对了?② 大写用的是 ASCII 负值吗?③ 输出格式是 %lld 吗?
🚨 易错点清单
⚠️大写用错规则:写成 c - 'A' + 1 会得到正数,必须用 -(int)c 取 ASCII 负值。
⚠️输出用了 %d:sum 是 long long,必须用 %lld。
⚠️忘了结果是负数:当大写字母多时答案就是负的,正常输出即可,不要做任何"取绝对值"之类的多余处理。
时间复杂度
O(n)
空间复杂度
O(n)
n 最大
10⁵
运算量
10⁵ 次
时间怎么算的?
遍历 n 个字符
每个字符做一次比较和一次加法
合计 O(n)
空间都用在哪?
需要存下整个字符串(长度 n),所以是 O(n);如果边读边算,可以做到 O(1)。
✅ 10⁵ 次运算,任何写法都是瞬间完成。
// 字符与数字的常见转换
int lowerValue(char c) { return c - 'a' + 1; } // a=1 … z=26
int upperIndex(char c) { return c - 'A'; } // A=0 … Z=25
int asciiNeg(char c) { return -(int)c; } // 题目用的大写规则
// 大小写判断(推荐手写,不依赖 locale)
bool isLower(char c) { return c >= 'a' && c <= 'z'; }
bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
// ASCII 码关键值
// '0' = 48 'A' = 65 'a' = 97
// 大写与小写相差 32:'a' - 'A' = 32
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
字符区间判断用小写字母连续区间分流所有大小写分类题
ASCII 码运算c - 'a' 得到 0 基下标字母转数字、密码类题目
多规则映射同一题里两套转换规则加密解密、编码转换题
🌟思考题:如果题目改成"大写字母代表它的字母表位置、小写字母代表 ASCII 码的相反数",代码要改哪两处?(提示:把两个分支的处理方式互换即可,其余不动。)
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
char s[100005];
scanf("%s", s);
long long sum = 0;
for (int i = 0; i < n; i++) {
char c = s[i];
if (c >= 'a' && c <= 'z') {
sum += (c - 'a' + 1); // 小写:字母表位置 1 ~ 26
} else {
sum += -(int)c; // 大写:ASCII 码的相反数
}
}
printf("%lld\n", sum);
return 0;
}// 字符与数字的常见转换
int lowerValue(char c) { return c - 'a' + 1; } // a=1 … z=26
int upperIndex(char c) { return c - 'A'; } // A=0 … Z=25
int asciiNeg(char c) { return -(int)c; } // 题目用的大写规则
// 大小写判断(推荐手写,不依赖 locale)
bool isLower(char c) { return c >= 'a' && c <= 'z'; }
bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
// ASCII 码关键值
// '0' = 48 'A' = 65 'a' = 97
// 大写与小写相差 32:'a' - 'A' = 32注:当偏移量是 26 的倍数时,每个大写字母经过偏移后会恰好回到原来的位置,即大写字母表 ABCDEFGHIJKLMNOPQRSTUVWXYZ 经过偏移后会保持不变。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 3 | DEFGHIJKLMNOPQRSTUVWXYZABC |
当偏移量是 3 的时候,大写字母 A 会替换成 D,大写字母 Z 会替换成 C,总体来看,大写字母表 ABCDEFGHIJKLMNOPQRSTUVWXYZ 会被替换成 DEFGHIJKLMNOPQRSTUVWXYZABC。
【数据范围】
对于全部数据,保证有 1≤q n≤q 100。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
所有大写字母都向后按一个固定数目偏移,偏移时把字母表视作首尾相接的环。例如偏移量为 3 时,A 变成 D,Z 变成 C,整个字母表 ABCDEFGHIJKLMNOPQRSTUVWXYZ 变为 DEFGHIJKLMNOPQRSTUVWXYZABC。
给定偏移量 n,输出移位后的字母表。
💡人话翻译:把 A ~ Z 这 26 个字母看成围成一圈,整体往后转 n 格,然后把转完的序列写出来。关键在于"转出 Z 之后要回到 A"——这就是取模的作用。
🔍 关键词提取
字母环形移位取模运算字符与数字互转边界回绕
已知条件
项目说明
输入一行一个正整数 n
输出一行 26 个大写字母
数据范围1 ≤ n ≤ 100
关键性质n 是 26 的倍数时,字母表不变
需要解决的问题
怎么处理"越过 Z 回到 A"?用取模:(位置 + n) % 26
n 比 26 大怎么办?先 n % 26,因为转 26 格等于没转
怎么输出?对每个位置输出一个字符,共 26 个
📥 读入
读入偏移量 n
n ≤ 100
先取 n % 26
避免多余旋转
🔄 移位模型
字母表是环形
位置 0 ~ 25 对应 A ~ Z
新位置 = (原位置 + n) % 26
取模实现回绕
🖨️ 输出
输出 26 个字符
顺序:原第 k 位变成第 (k+n)%26 位
或者直接输出起点之后的 26 个字母
末尾不用空格
⚠️ 边界
n = 26 → 原样输出
n = 52 → 原样输出
n = 1 → BCDE…ZA
n = 25 → ZABC…Y
规则:原字母位置 p 变成新位置 (p + 3) % 26。我们挑几个关键位置看,特别是临近边界的 W、X、Y、Z。
原字母原位置 pp + 3(p+3) % 26新字母说明
A033D普通前进
B144E普通前进
W222525Z刚好到 Z
X23260A越过 Z,回绕到 A
Y24271B越界 2 格
Z25282C越界 3 格
1
前半段:A ~ W
A→D、B→E、…、W→Z
这些字母加 3 后都没超过 Z
共 23 个字母普通过渡
2
边界处:X、Y、Z
X 的 23 + 3 = 26,取模后变 0 → A
Y 的 24 + 3 = 27,取模后变 1 → B
Z 的 25 + 3 = 28,取模后变 2 → C
❗ 这就是"字母表首尾相接"的体现
3
拼起来
前半段 DEFGHIJKLMNOPQRSTUVWXYZ
后半段 ABC
✅ DEFGHIJKLMNOPQRSTUVWXYZABC
🔑换个角度看更简单:移位后的字母表其实就是"从原第 n 个字母开始,把整圈读一遍"。n = 3 时从 D 开始读:DEFGHIJKLMNOPQRSTUVWXYZ 然后接 ABC。两种理解等价,选你顺手的写。
🧮 几个边界情况
nn % 26输出
11BCDEFGHIJKLMNOPQRSTUVWXYZA
33DEFGHIJKLMNOPQRSTUVWXYZABC
2525ZABCDEFGHIJKLMNOPQRSTUVWXY
260ABCDEFGHIJKLMNOPQRSTUVWXYZ(原样)
520ABCDEFGHIJKLMNOPQRSTUVWXYZ(原样)
10022WXYZABCDEFGHIJKLMNOPQRSTUV
💡n = 100 时为什么等于 n = 22?100 = 3 × 26 + 22,转 3 整圈等于没转,剩下的 22 才是有效偏移。所有"环形"问题都应该先取模。
🟢 逐位取模(推荐) 推荐
对 i = 0..25,输出 char('A' + (i + n) % 26)
时间 O(26)
一行循环搞定
天然处理回绕
不需要特判
💡为什么推荐:取模把"环形"这件事交给数学处理,代码里一个 if 都不用写。
🟠 字符串切片拼接
把字母表当作字符串,切成两段再交换位置
需要处理 n % 26 = 0 的特例
要小心 substr 的下标
两段拼接容易写错
本质还是要取模
⚠️注意:这种写法在 n 是 26 的倍数时,直接 substr(n) 会得到空串或越界,必须特判。
📈 性能对比
方案代码量边界处理
逐位取模约 5 行自动正确
切片拼接约 10 行需特判 n % 26 == 0
输入偏移量 n,立刻看到移位后的 26 个字母,并同时展示两种理解方式。
输入偏移量 n
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
n %= 26; // 转整圈等于没转,先取模
for (int i = 0; i < 26; i++) {
// 原第 i 位的字母,移位后落在 (i + n) % 26 位
char c = char('A' + (i + n) % 26);
printf("%c", c);
}
printf("\n");
return 0;
}
🔑取模为什么能处理回绕?例如 (23 + 3) % 26 = 26 % 26 = 0,正好回到 0(也就是 A)。取模把"超出 25 的部分"自动折回到开头,不需要写任何 if 判断。
📖 关键几行怎么看
代码作用为什么这样写
n %= 26;压缩偏移量转 26 格等于没转,先取模省事
char('A' + (i + n) % 26)算出新字母位置 0 对应 A,+n 后取模保证落在 0 ~ 25
for (i = 0; i < 26; i++)输出 26 个固定长度,不用 while
printf("%c", c)逐字符输出也可以用 putchar
⚠️两个坑:① 忘了取模 n % 26,虽然本题取模与否结果都对(因为 (i+n)%26 自动处理),但先取模能避免 n 很大时的意外;② 写成 char('A' + i + n % 26) 运算符优先级出错 —— % 的优先级高于 +,结果完全不同。
写完程序后,用这些数据自查一遍:
输入答案考察点
1BCDEFGHIJKLMNOPQRSTUVWXYZA偏移 1 格
3DEFGHIJKLMNOPQRSTUVWXYZABC题面样例
25ZABCDEFGHIJKLMNOPQRSTUVWXY偏移 25 格
26ABCDEFGHIJKLMNOPQRSTUVWXYZ26 的倍数 → 原样输出
52ABCDEFGHIJKLMNOPQRSTUVWXYZ52 = 2 × 26,同样是原样
100WXYZABCDEFGHIJKLMNOPQRSTUV100 % 26 = 22,等于偏移 22 格
✅自查清单:① 括号位置对吗((i+n) % 26)?② 输出了恰好 26 个字符吗?③ n = 26 时输出是原表吗?
🚨 易错点清单
⚠️运算符优先级写错:char('A' + i + n % 26) 会先算 n % 26,再依次加 i,导致结果错乱。务必写成 char('A' + (i + n) % 26)。
⚠️n 是 26 的倍数时输出空串:如果用的是"切片拼接"写法,substr(26) 会越界,必须特判。
⚠️多输出了换行或空格:题目要求一行 26 个字符,字符之间不能有空格。
时间复杂度
O(26)
空间复杂度
O(1)
输出长度
26
运算量
26 次
时间怎么算的?
固定输出 26 个字符
每次做一次加法和一次取模
与输入 n 的大小无关,所以是 O(1)(26 是常数)
空间都用在哪?
只需要循环变量和 n 两个整数。
✅ 固定 26 次运算,任何实现都是瞬间完成;这题考的是取模处理环形的思路。
// 字母环形的标准处理
char shift(char c, int n) { // 大写字母移位
return char('A' + (c - 'A' + n) % 26);
}
char shiftLower(char c, int n) { // 小写字母移位
return char('a' + (c - 'a' + n) % 26);
}
// 凯撒密码加密/解密
string caesar(const string &s, int n) {
string r;
for (char c : s) {
if (c >= 'A' && c <= 'Z') r += shift(c, n);
else r += c; // 非字母原样保留
}
return r;
}
// 取模的通用技巧:把任意整数折到 [0, m)
int mod(int x, int m) { return ((x % m) + m) % m; } // 处理负数
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
环形取模(i + n) % 26 处理回绕凯撒密码、循环数组、约瑟夫环
字符与数字互转c - 'A' 得位置,+'A' 得字符所有字母相关的题目
先取模再运算压缩到 [0, 26)所有周期性、循环类问题
🌟思考题:如果只对奇数位置的字母移位、偶数位置不变,代码怎么改?(提示:在循环里加 if (i % 2 == 1) 判断;这就是一些变种加密题的做法。)
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
n %= 26; // 转整圈等于没转,先取模
for (int i = 0; i < 26; i++) {
// 原第 i 位的字母,移位后落在 (i + n) % 26 位
char c = char('A' + (i + n) % 26);
printf("%c", c);
}
printf("\n");
return 0;
}// 字母环形的标准处理
char shift(char c, int n) { // 大写字母移位
return char('A' + (c - 'A' + n) % 26);
}
char shiftLower(char c, int n) { // 小写字母移位
return char('a' + (c - 'a' + n) % 26);
}
// 凯撒密码加密/解密
string caesar(const string &s, int n) {
string r;
for (char c : s) {
if (c >= 'A' && c <= 'Z') r += shift(c, n);
else r += c; // 非字母原样保留
}
return r;
}
// 取模的通用技巧:把任意整数折到 [0, m)
int mod(int x, int m) { return ((x % m) + m) % m; } // 处理负数1. 只能由 \texttt a \sim \texttt z 之间 26 个小写字母、\texttt A \sim \texttt Z 之间 26 个大写字母、0 \sim 9 之间 10 个数字以及 !@#$ 四个特殊字符构成。
2. 密码最短长度 :6 个字符,密码最大长度 :12 个字符。
3. 大写字母,小写字母和数字必须至少有其中两种,以及至少有四个特殊字符中的一个。
| # | 输入 | 输出 |
|---|---|---|
| 1 | seHJ12!@,sjdkffH$123,sdf!@&12HDHa!,123&^YUhg@! | seHJ12!@ sjdkffH$123 |
输入被英文逗号分为了四组被检测密码:seHJ12!@、sjdkffH$123、sdf!@&12HDHa!、123&^YUhg@!。其中 sdf!@&12HDHa! 长度超过 12 个字符,不合规;123&^YUhg@! 包含四个特殊字符之外的字符不合规。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
合规的密码需满足以下全部要求:
只能由 a ~ z、A ~ Z、0 ~ 9 以及 !@# 这四个特殊字符构成
长度在 6 到 12 之间(含两端)
大写字母、小写字母、数字这三类中至少包含两类,并且至少包含一个特殊字符
输入的若干密码用英文逗号分隔,按输入顺序输出其中所有合规的密码,每行一个。
💡人话翻译:四个条件要"全部"满足:① 字符都在白名单里;② 长度 6 ~ 12;③ 至少两类"字母/数字";④ 至少一个特殊字符。注意第 ③ 条是"三类中至少两类",不是三类都要有。
🔍 关键词提取
字符白名单长度约束多条件判定字符串分割
已知条件
项目说明
输入一行不含空格的字符串,用英文逗号分隔成多组密码
输入长度约定整行不超过 100
输出每行一个合规密码,按输入顺序
白名单大小写字母、数字、以及 !@# 四个特殊字符
长度范围6 ≤ 长度 ≤ 12
类别要求大/小写字母、数字这三类至少两类,且至少 1 个特殊字符
需要解决的问题
怎么拆分多组密码?按逗号切分,在 C++ 里可以用 getline(cin, s, ',') 或手动遍历
怎么判字符合法性?写个白名单函数逐字符检查
怎么统计类别数?用多个布尔标记,最后数有几个为真
📥 输入拆分
整行按逗号切分
逐组独立判定
保持输入顺序
可能有很多组
📋 四个条件
① 字符都在白名单
② 长度 6 ~ 12
③ 字母/数字≥两类
④ 至少 1 个特殊字符
🔍 判定手段
白名单函数 isAllowed
多个布尔标记
最后数类别个数
任一不满足即淘汰
⚠️ 易错点
把"至少两类"当成"三类都要"
忘了长度上限 12
漏掉特殊字符要求
输出顺序错乱
样例输入是 seHJ12!@,sjdkffH123,sdf!@&12HDHa!,123&^YUhg@!,我们逐组走一遍四个条件。
1
seHJ12!@(长度 8)
① 字符 s、e、H、J、1、2、!、@ 全在白名单 ✅
② 长度 8,在 6 ~ 12 之间 ✅
③ 含大写 H、J;含小写 s、e;含数字 1、2 → 三类都占了,至少两类 ✅
④ 含特殊字符 ! 和 @ ✅
✅ 合规,输出 seHJ12!@
2
sjdkffH123(长度 11)
① 字符 s、j、d、k、f、f、H、、1、2、3 全在白名单 ✅
② 长度 11 ✅
③ 含大写 H、含小写、含数字 ✅
④ 含特殊字符 ✅
✅ 合规,输出 sjdkffH123
3
sdf!@&12HDHa!(长度 13)
① 含 & —— 不在白名单里 ❌
② 长度 13 —— 超过 12 ❌
两个条件同时不满足
❌ 不合规(双重违规)
4
123&^YUhg@!
① 含 & 和 ^ —— 都不在白名单 ❌
所以直接淘汰,后面的条件不用再看
❌ 不合规
📊 四组判定汇总
密码长度在 6~12 内白名单类别数(需≥2)特殊字符结论
seHJ12!@8✅✅3(大/小/数)✅ ! @合规
sjdkffH12311✅✅3✅ $合规
sdf!@&12HDHa!13❌❌ 含 &3✅不合规
123&^YUhg@!12✅❌ 含 & ^3✅不合规
🔑最容易读错的是第 ③ 条:"大写字母、小写字母和数字必须至少有其中两种"——是三类里挑两类即可,不是必须三类齐全。例如 abcdef1!(全是小写 + 数字 + 特殊字符)就满足"两类"要求。
🟢 白名单 + 多标记(推荐) 推荐
写一个 isAllowed(c) 判字符合法性,同时用三个布尔标记记录类别
时间 O(总长度)
一次遍历同时得出①②③④
结构清晰不易漏
代码 25 行左右
💡为什么推荐:把"字符白名单"抽成函数,主循环只负责统计类别,两个关注点分离,改条件时互不影响。
🟠 用正则表达式
用一条正则匹配所有条件
写法极短
但正则容易写错、难调试
C++ 正则库较慢
考试环境不总是支持
⚠️建议:先把逻辑写清楚,用布尔标记的写法既好读又不易错;正则更适合用来校验,不适合初学者在考场上手写。
📈 性能对比
方案可读性出错概率
白名单 + 多标记⭐⭐⭐⭐⭐低
正则表达式⭐⭐⭐中
每行输入一个密码(可多行),程序会逐条检查四个条件并给出结论。
输入密码(每行一个)seHJ12!@
sjdkffH$123
sdf!@&12HDHa!
123&^YUhg@!
abcdef1!
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
// 判断字符是否在白名单内
bool isAllowed(char c) {
if (c >= 'a' && c <= 'z') return true;
if (c >= 'A' && c <= 'Z') return true;
if (c >= '0' && c <= '9') return true;
return c == '!' || c == '@' || c == '#' || c == '$';
}
bool isOK(const string &s) {
// 条件 2:长度必须在 6 ~ 12 之间
if (s.size() < 6 || s.size() > 12) return false;
bool hasUp = false, hasLow = false, hasDig = false, hasSpec = false;
for (char c : s) {
if (!isAllowed(c)) return false; // 条件 1:字符必须合法
if (c >= 'A' && c <= 'Z') hasUp = true;
else if (c >= 'a' && c <= 'z') hasLow = true;
else if (c >= '0' && c <= '9') hasDig = true;
else hasSpec = true;
}
// 条件 3:字母/数字三类中至少两类
int kinds = (hasUp ? 1 : 0) + (hasLow ? 1 : 0) + (hasDig ? 1 : 0);
if (kinds < 2) return false;
// 条件 4:至少一个特殊字符
return hasSpec;
}
int main() {
string line;
cin >> line; // 整行不含空格,直接读
string cur = "";
for (int i = 0; i <= (int)line.size(); i++) {
// 遇到逗号或到达末尾,就结算当前这一组密码
if (i == (int)line.size() || line[i] == ',') {
if (!cur.empty() && isOK(cur)) printf("%s\n", cur.c_str());
cur = "";
} else {
cur += line[i];
}
}
return 0;
}
🔑为什么整行可以直接 cin >> line?题目说"输入一行不含空格的字符串",所以 >> 不会截断。然后用一个循环按逗号切开,在一行里同时完成"切分"和"判定",不需要额外数组。
📖 关键几行怎么看
代码作用为什么这样写
isAllowed(c)字符白名单把合法性判断独立出来,主逻辑更清晰
s.size() < 6 || s.size() > 12长度条件6 和 12 都包含在内,用 < 和 > 配合
kinds = ...统计类别数三个布尔量相加,得到 0 ~ 3
kinds < 2至少两类注意不是"必须三类齐全"
⚠️四个坑:① 把第 ③ 条理解成"三类都必须有"(题目只要求至少两类);② 忘了长度上限 12,只检查了下限 6;③ 特殊字符集写多了(比如把 %、& 也算合法);④ 输出顺序没保持输入的先后。
写完程序后,用这些数据自查一遍:
输入答案考察点
seHJ12!@合规题面样例,8 位三类齐备
sjdkffH123合规题面样例,11 位
sdf!@&12HDHa!不合规含 &(非白名单)且长度 13
123&^YUhg@!不合规含 & 和 ^
abcdef1!合规只有小写 + 数字(两类)也满足条件 ③
Ab1!cd合规恰好 6 位,边界值
Ab1!c不合规只有 5 位,低于下限
✅自查清单:① 长度检查是 6 ~ 12 双端吗?② 类别要求是"至少两类"吗?③ 特殊字符只认 !@# 吗?④ 输出保持了输入顺序吗?
🚨 易错点清单
⚠️把"至少两类"当成"三类都要":abcdef1! 只有小写和数字两类,但它满足题目要求(至少两类 + 有特殊字符)。
⚠️漏掉长度上限:只检查了 ≥ 6,忘记 ≤ 12,会把 13 位的密码误判为合规。
⚠️特殊字符集写成"所有非字母数字":题目只允许 !@#$ 四个,&、^、% 都不合法。
⚠️用 getline 却忘了处理逗号:本题整行不含空格,用 cin >> 读整行再手动切分即可。
时间复杂度
O(L)
空间复杂度
O(L)
整行长度
≤ 100
运算量
≤ 100 次
时间怎么算的?
每个字符只被检查一次
整行长度不超过 100
所以是 O(L),实际运算量极小
空间都用在哪?
只需要当前密码的临时字符串。
✅ 本题数据极小,重点是把四个条件都写对,而不是追求效率。
// 字符分类判断(不依赖 locale,最稳)
bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
bool isLower(char c) { return c >= 'a' && c <= 'z'; }
bool isDigit(char c) { return c >= '0' && c <= '9'; }
// 按分隔符切分字符串的两种写法
// 写法一:用 stringstream(分隔符是空格)
stringstream ss(line); string seg;
while (ss >> seg) { /* 处理 seg */ }
// 写法二:手动遍历(分隔符任意,本题用逗号)
string cur;
for (int i = 0; i <= (int)line.size(); i++) {
if (i == (int)line.size() || line[i] == ',') {
/* 结算 cur */ cur = "";
} else cur += line[i];
}
// 统计"出现了几类字符"
int kinds = (hasUp?1:0) + (hasLow?1:0) + (hasDig?1:0);
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
多条件判定多个布尔标记 + 最后汇总合规检查、格式校验类题目
字符白名单抽成独立函数所有"只允许某些字符"的题
按分隔符切分手动遍历或 stringstream一行多组数据的输入处理
🌟思考题:如果题目改成"密码中不能出现连续 3 个相同字符",该怎么加判断?(提示:在遍历时记录"当前连续相同字符的个数",达到 3 就判不合规,这是很多真实网站的口令策略。)
#include <bits/stdc++.h>
using namespace std;
// 判断字符是否在白名单内
bool isAllowed(char c) {
if (c >= 'a' && c <= 'z') return true;
if (c >= 'A' && c <= 'Z') return true;
if (c >= '0' && c <= '9') return true;
return c == '!' || c == '@' || c == '#' || c == '$';
}
bool isOK(const string &s) {
// 条件 2:长度必须在 6 ~ 12 之间
if (s.size() < 6 || s.size() > 12) return false;
bool hasUp = false, hasLow = false, hasDig = false, hasSpec = false;
for (char c : s) {
if (!isAllowed(c)) return false; // 条件 1:字符必须合法
if (c >= 'A' && c <= 'Z') hasUp = true;
else if (c >= 'a' && c <= 'z') hasLow = true;
else if (c >= '0' && c <= '9') hasDig = true;
else hasSpec = true;
}
// 条件 3:字母/数字三类中至少两类
int kinds = (hasUp ? 1 : 0) + (hasLow ? 1 : 0) + (hasDig ? 1 : 0);
if (kinds < 2) return false;
// 条件 4:至少一个特殊字符
return hasSpec;
}
int main() {
string line;
cin >> line; // 整行不含空格,直接读
string cur = "";
for (int i = 0; i <= (int)line.size(); i++) {
// 遇到逗号或到达末尾,就结算当前这一组密码
if (i == (int)line.size() || line[i] == ',') {
if (!cur.empty() && isOK(cur)) printf("%s\n", cur.c_str());
cur = "";
} else {
cur += line[i];
}
}
return 0;
}// 字符分类判断(不依赖 locale,最稳)
bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
bool isLower(char c) { return c >= 'a' && c <= 'z'; }
bool isDigit(char c) { return c >= '0' && c <= '9'; }
// 按分隔符切分字符串的两种写法
// 写法一:用 stringstream(分隔符是空格)
stringstream ss(line); string seg;
while (ss >> seg) { /* 处理 seg */ }
// 写法二:手动遍历(分隔符任意,本题用逗号)
string cur;
for (int i = 0; i <= (int)line.size(); i++) {
if (i == (int)line.size() || line[i] == ',') {
/* 结算 cur */ cur = "";
} else cur += line[i];
}
// 统计"出现了几类字符"
int kinds = (hasUp?1:0) + (hasLow?1:0) + (hasDig?1:0);小杨有 n 个仅包含小写字母的字符串,他想请你编写程序判断每个字符串是否由两个长度至少为 2 的回文串前后拼接而成。
接下来 n 行,每行一个仅包含小写字母的字符串。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 4 abcd aabbb aaac abcdd | No Yes No No |
对于第 1,3,4 个字符串,都不是由两个长度至少为 2 的回文串前后拼接而成。
第 2 个字符串由回文串 \texttt{aa} 和 \texttt{bbb} 前后拼接而成,并且两个回文串长度都至少为 2。
数据规模与约定
对全部的测试数据,保证 1 ≤q n ≤q 10,且每个字符串的长度均不超过 100。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
一个字符串是回文串,当且仅当它从前往后读和从后往前读完全一样,例如 aabaa、ccddcc 是回文串,abcd 不是。
给定 n 个仅含小写字母的字符串,请判断每个字符串是否由两个长度至少为 2 的回文串前后拼接而成。是则输出 Yes,否则输出 No。
💡人话翻译:在原串上找一个"切分点",把字符串切成左右两段;要求左段是回文、右段也是回文,并且两段长度都 ≥ 2。切分点可以有很多个,只要有一个满足就输出 Yes。
🔍 关键词提取
回文判断枚举切分点子串长度约束双指针
已知条件
项目说明
输入第一行 n;随后 n 行每行一个小写字母串
输出每行一个 Yes 或 No
数据范围1 ≤ n ≤ 10,字符串长度 ≤ 100
长度约束两段长度都必须至少为 2
需要解决的问题
切分点能取哪些?左段长度 i 满足 2 ≤ i ≤ L − 2,这样两段长度都 ≥ 2
怎么判断回文?双指针从两端向中间夹,或反转后比较
整串是回文行不行?不行!必须能切成两段,整串回文不等于满足条件
📥 读入
n 个字符串
逐个独立判断
串长 L ≤ 100
L < 4 直接 No
✂️ 枚举切分
左段长度 i 从 2 开始
i 最大到 L − 2
保证右段也 ≥ 2
两段都要判
🔍 判回文
双指针 i、j 向中间夹
或反转后比较
O(段长)
两段都真才 Yes
⚠️ 易错点
漏掉长度 ≥ 2 的约束
整串回文误判为 Yes
i 的取值范围写错
L < 4 时无解
样例答案依次是 No、Yes、No、No。我们把每个串的所有切分点都试一遍。
1
abcd(长度 4)
L = 4,左段长度只能取 i = 2
左段 "ab":a 与 b 不同 → 不是回文
❌ 唯一切分点失败 → No
2
aabbb(长度 5)
i = 2:左段 "aa" 是回文 ✅,右段 "bbb" 是回文 ✅
两段长度分别是 2 和 3,都 ≥ 2 ✅
✅ 找到合法切分 → Yes
3
aaac(长度 4)
L = 4,只能取 i = 2
左段 "aa" 是回文 ✅,右段 "ac":a 与 c 不同 ❌
❌ 切分点失败 → No
4
abcdd(长度 5)
i = 2:左段 "ab" 不是回文 ❌
i = 3:左段 "abc" 不是回文 ❌
❌ 所有切分点都失败 → No
📊 逐个切分点检查表
字符串长度尝试的 i左段右段结论
abcd42ab ❌cd ❌No
aabbb52aa ✅bbb ✅Yes
aabbb53aab ❌bb ✅(已找到,无需再试)
aaac42aa ✅ac ❌No
abcdd52ab ❌cdd ❌No
abcdd53abc ❌dd ✅No
🔑注意 aabbb 的 i = 3 那行:左段 "aab" 不是回文,但右段 "bb" 是回文 —— 必须两段同时满足才算成功。只要找到一个 i 让两段都成立就可以立刻输出 Yes。
🟢 枚举所有切分点(推荐) 推荐
i 从 2 到 L−2,每轮判断两段是否回文
时间 O(L²)
L ≤ 100,最多试 98 个切分点
逻辑直白不易错
找到即可提前退出
💡为什么不用更聪明的做法:本题 n ≤ 10、L ≤ 100,规模极小,枚举足够快。把时间花在"写对"上更划算。
🟠 只检查长度与两端字符
试图用"首尾相同"之类的必要条件快速判断
必要条件不能当充分条件
"ab...ba" 也不一定两段都是回文
容易漏解
反而更慢(还要额外验证)
⚠️结论:回文性质没有简单的边界判据,老老实实枚举切分点 + 双指针判断最稳。
📈 性能对比
方案运算量(L=100)正确性
枚举切分点约 10⁴ 次字符比较✅ 完全正确
边界启发式不确定❌ 可能漏解
每行输入一个字符串,程序会枚举所有切分点并标出哪些能成功。
输入字符串(每行一个)abcd
aabbb
aaac
abcdd
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
// 判断 s 的 [l, r] 闭区间是否为回文
bool isPal(const string &s, int l, int r) {
while (l < r) {
if (s[l] != s[r]) return false;
l++; r--;
}
return true;
}
int main() {
int n;
scanf("%d", &n);
while (n--) {
string s;
cin >> s;
int L = (int)s.size();
bool ok = false;
// 左段长度为 i,则右段长度为 L - i,两者都必须 >= 2
for (int i = 2; i <= L - 2; i++) {
if (isPal(s, 0, i - 1) && isPal(s, i, L - 1)) {
ok = true;
break;
}
}
printf("%s\n", ok ? "Yes" : "No");
}
return 0;
}
🔑循环上界为什么是 L − 2?左段长度是 i,右段长度是 L − i。要求左段 ≥ 2 → i ≥ 2;要求右段 ≥ 2 → L − i ≥ 2 → i ≤ L − 2。两个条件合起来就是 2 ≤ i ≤ L − 2。如果写成 i ≤ L − 1,右段可能只剩 1 个字符,就会误判。
📖 关键几行怎么看
代码作用为什么这样写
isPal(s, l, r)闭区间判回文双指针从两端向中间夹,O(段长)
for (i = 2; i <= L - 2; i++)枚举左段长度同时保证两段长度都 ≥ 2
isPal(s,0,i-1) && isPal(s,i,L-1)两段都要是回文必须同时成立,用的是 &&
break提前退出找到一个合法切分就能定 Yes
⚠️三个坑:① 把整串是否是回文当成答案 —— 题目要求切成两段,即使整串回文(如 "abba")也可能不满足;② 忘记长度 ≥ 2 的约束,把 "aaa" 切成 "a"+"aa" 判成 Yes(实际应判 No);③ 循环写成 i < L,导致右段可能为空。
写完程序后,用这些数据自查一遍:
输入答案考察点
abcdNo题面样例
aabbbYes题面样例:aa + bbb
aaacNo左段回文但右段不是
abcddNo题面样例
aaaNo长度 3 无解(切成 a+aa 有段长为 1)
abbaNo整串是回文,但切不出两段回文
aaaaYesaa + aa
aabbYesaa + bb
✅自查清单:① 切分范围是 2 ~ L−2 吗?② 两段都用 && 连接吗?③ 长度 < 4 的串直接输出 No 吗?
🚨 易错点清单
⚠️把整串回文当答案:abba 整串是回文,但要切成两段("ab"+"ba" 或 "abb"+"a")都不满足,答案应是 No。
⚠️漏掉长度 ≥ 2:aaa 切成 "a"+"aa" 两段都是回文,但左段长度只有 1,不合法。
⚠️循环上界写错:必须是 i ≤ L − 2,写成 i ≤ L − 1 会让右段为空串(空串也算回文,造成误判)。
⚠️n 组数据忘了重置 ok:ok 要写在每组循环内部。
时间复杂度
O(n × L²)
空间复杂度
O(L)
L 最大
100
最坏运算
约 10⁵
时间怎么算的?
每个串最多枚举 L − 3 个切分点
每个切分点判断两段回文,合计 O(L)
单个串 O(L²),n 个串共 O(n × L²)
n=10、L=100 时约 10 × 100 × 100 = 10⁵ 次
空间都用在哪?
只需要字符串本身,双指针判断不需要额外空间。
✅ 最坏 10 万次字符比较,任何语言都是瞬间完成。
// 判断子串 [l, r] 是否回文(双指针)
bool isPal(const string &s, int l, int r) {
while (l < r && s[l] == s[r]) { l++; r--; }
return l >= r;
}
// 判断整个字符串是否回文(两种写法)
bool isPal1(const string &s) { return isPal(s, 0, (int)s.size() - 1); }
bool isPal2(string s) { string t = s; reverse(t.begin(), t.end()); return s == t; }
// 枚举所有切分点的通用骨架
for (int i = 1; i < (int)s.size(); i++) {
string left = s.substr(0, i);
string right = s.substr(i);
// 对 left、right 做判断
}
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
回文双指针两端向中间夹回文子串、回文判断类题目
枚举切分点s.substr(0,i) 与 s.substr(i)字符串拆分、区间划分类题目
区间参数化把 [l, r] 作为函数参数避免反复创建子串,写法更高效
🌟思考题:如果题目改成"切成三段回文串",该怎么做?(提示:两层枚举切分点 i、j,复杂度升到 O(L³);L ≤ 100 时约 10⁶ 次,仍然可行。)
#include <bits/stdc++.h>
using namespace std;
// 判断 s 的 [l, r] 闭区间是否为回文
bool isPal(const string &s, int l, int r) {
while (l < r) {
if (s[l] != s[r]) return false;
l++; r--;
}
return true;
}
int main() {
int n;
scanf("%d", &n);
while (n--) {
string s;
cin >> s;
int L = (int)s.size();
bool ok = false;
// 左段长度为 i,则右段长度为 L - i,两者都必须 >= 2
for (int i = 2; i <= L - 2; i++) {
if (isPal(s, 0, i - 1) && isPal(s, i, L - 1)) {
ok = true;
break;
}
}
printf("%s\n", ok ? "Yes" : "No");
}
return 0;
}// 判断子串 [l, r] 是否回文(双指针)
bool isPal(const string &s, int l, int r) {
while (l < r && s[l] == s[r]) { l++; r--; }
return l >= r;
}
// 判断整个字符串是否回文(两种写法)
bool isPal1(const string &s) { return isPal(s, 0, (int)s.size() - 1); }
bool isPal2(string s) { string t = s; reverse(t.begin(), t.end()); return s == t; }
// 枚举所有切分点的通用骨架
for (int i = 1; i < (int)s.size(); i++) {
string left = s.substr(0, i);
string right = s.substr(i);
// 对 left、right 做判断
}..... ****. ..... ..... .***. ****. ****. ****. .***. ****. ..... ..... .***. ****. .**** ****. ..... ****. ..... .....
小杨想请你将给定的数字 n 转换为对应的表示形式。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 12230 | ****..................... ****.****.****.****..***. ****.................***. ****..****.********..***. ****..................... |
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
小杨为数字 0、1、2、3 设计了一款表示形式,每个数字占用一个 5 × 5 的网格(字符为 * 和 .)。
给定一个仅由数字 0 ~ 3 组成的非负整数 n(0 ≤ n ≤ 10⁶),请把 n 转换为对应的表示形式输出:共 5 行,每行把 n 的每一位对应图案的同一行依次拼接起来。
💡人话翻译:四个数字各画好一张 5 行 5 列的"字模",然后像打字一样,把 n 的每一位的字模并排拼起来。输出固定 5 行,第 r 行 = 每一位字模第 r 行的连接。
🔍 关键词提取
二维字符数组字模打表按行拼接字符串读入
已知条件
项目说明
输入一行一个非负整数 n(仅含数字 0 ~ 3)
输出固定 5 行,每行长度 = 位数 × 5
数据范围0 ≤ n ≤ 10⁶
字符集只有 * 和 . 两种
需要解决的问题
字模存在哪里?用 string pat[4][5] —— 四张字模、每张 5 行
n 怎么读?读成字符串最方便:直接遍历每个字符就能拿到每一位数字
怎么拼行?外层循环 5 行,内层循环每个数位,输出该位字模的第 r 行
📥 读入
把 n 读成 string
每位是字符 '0' ~ '3'
数字 → 下标减 '0'
位数最多 7
🎨 字模表
pat[4][5] 存四张图案
每张 5 行、每行 5 字符
下标 0~3 对应数字 0~3
来自题面表格
🖨️ 输出
外层 r 从 0 到 4
内层遍历每一位
输出 pat[d][r]
每行末尾换行
⚠️ 注意点
用 %s 输出 string 要 .c_str()
n 可能有前导 0?
每行长度 = 位数 × 5
行末不要多空格
n 的各位依次是 1、2、2、3、0。我们先明确四张字模的样子(取自题面表格):
行号数字 0数字 1数字 2数字 3
第 1 行.....**...........
第 2 行....*.
第 3 行..*...........
第 4 行....*.
第 5 行.....**...........
1
第 1 行
数字 1 的第 1 行是 **.,其余四位(2、2、3、0)的第 1 行都是 .....
拼起来 = **. 后面接 4 组 .....(共 25 字符)
2
第 2 行
*. . . . ..(五段依次拼接)
= *......
3
第 3 行
*. ..... ..... ..... ..
= *..................
4
第 4 行
*. . . . ..
= *.....**.
5
第 5 行
**. 后面接 4 组 .....(共 25 字符)
= **.....................
把这 5 行输出来,正好就是题面样例:
**.....................
*......
*..................
*.....**.
**.....................
🔑看第 4 行第 2 段是 ".*":这说明数字 2 的第 4 行是 .(点在前),而数字 3 的第 4 行是 *.(点在最后)——两个数字只差这一行。细节必须逐位对齐,写错一个字符整题就错。
🟢 字模打表(推荐) 推荐
把四张 5×5 图案硬编码成字符串数组,按行拼接
时间 O(位数 × 5)
代码最直白
零出错风险
改题目只需改表
💡为什么打表最优:题面已经给出了完整图案,这是"给定数据"而不是"需要推导的规律"。打表是最贴合题意的写法。
🟠 找规律用公式画
试图找出每个数字每一行与行列号的公式关系
四个图案是人为设计的
很难找出简洁规律
推导成本极高
容易画错
⚠️结论:这四个字模是"设计出来"的,没有统一的数学规律。硬找规律是走错方向。
📈 性能对比
方案代码量出错概率
字模打表约 15 行极低
找公式不确定很高
输入一个仅含 0 ~ 3 的数字串,立刻得到它的点阵表示(与题面格式一致)。
输入数字
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
// 四张 5×5 字模:pat[数字][行号]
string pat[4][5] = {
{ ".....", "..", "..", ".*.", "....." }, // 0
{ "*.", ".", ".", ".", "*." }, // 1
{ ".....", "*.", ".....", ".*", "....." }, // 2
{ ".....", "*.", ".....", "*.", "....." } // 3
};
int main() {
string n;
cin >> n; // 用字符串读入,逐位处理最方便
for (int r = 0; r < 5; r++) { // 外层:5 行
for (int i = 0; i < (int)n.size(); i++) {
int d = n[i] - '0'; // 字符 -> 数字
printf("%s", pat[d][r].c_str());
}
printf("\n");
}
return 0;
}
🔑为什么读成字符串而不是整数?① 遍历每一位只需要按下标取字符,不用做除 10 取余;② 不用担心前导零被吞掉(虽然本题数据不一定有);③ 位数直接就是 n.size()。凡是"逐位处理"的题,优先考虑按字符串读。
📖 关键几行怎么看
代码作用为什么这样写
string pat[4][5]存四张字模第一维是数字,第二维是行号
int d = n[i] - '0'字符转数字字符 '0' 的 ASCII 是 48,减去它即得数值
pat[d][r].c_str()输出 stringprintf 的 %s 需要 C 风格字符串
printf("\n")换行固定 5 行,每行输出完就换行
⚠️两个易错点:① 内外层循环写反 —— 必须是"先按行、再按位",否则输出顺序全乱;② 混淆数字 2 和 3 的第 4 行(.* 与 *.),这是两张字模唯一的差别。
写完程序后,用这些数据自查一遍:
输入答案考察点
05 行共 5 字符单数字,只有 1 位
35 行共 5 字符单数字,检查 3 的字模
12230见题面样例题面样例,5 位数
1115 行全为 *. . *.全都是数字 1
235 行共 10 字符两位,检查 2 与 3 第 4 行的差别
✅自查清单:① 输出是不是固定 5 行?② 每行长度是不是"位数 × 5"?③ 2 和 3 的字模有没有抄反?
🚨 易错点清单
⚠️循环顺序写反:如果把"按位"放外层,会把第 1 位数字的 5 行都输完再输下一位,变成多块竖排图案,与题意完全不符。
⚠️2 和 3 的第 4 行搞混:数字 2 是 .*,数字 3 是 *.,抄错一个字符整题全错。
⚠️用 printf("%s", pat[d][r]) 编译报错:string 不能直接传给 %s,要写 .c_str();也可以用 cout << pat[d][r]; 更省事。
时间复杂度
O(L × 5)
空间复杂度
O(1)
位数 L
最多 7
输出字符数
L × 5
时间怎么算的?
外层固定 5 行
内层遍历 L 位数字
每步只输出一个 5 字符的片段
合计 5 × L 次输出,L ≤ 7 → 最多 35 段
空间都用在哪?
字模表是固定大小的常量数组,与输入规模无关,所以额外空间是 O(1)。
✅ 输出量极小,任何写法都是瞬间完成;这题考的是二维打表 + 循环顺序。
// 二维字模打表的通用结构
string font[字符种类数][行数];
// 逐位处理的标准写法(读成字符串)
string n; cin >> n;
for (int i = 0; i < (int)n.size(); i++) {
int d = n[i] - '0';
// 用 d 去查表
}
// 输出 string 的三种方式
printf("%s", s.c_str()); // C 风格
cout << s; // C++ 流(最简单)
fputs(s.c_str(), stdout); // 少用
// 字符与数字互转
int d = c - '0'; // 字符 -> 数字
char c = char(d + '0'); // 数字 -> 字符
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
二维字模打表用 pat[数字][行] 存图案点阵字、图形输出、图案打印类题目
逐位处理把数字读成字符串再遍历数位统计、数字拆分、大整数处理
循环嵌套顺序外层行、内层位所有"多块图案并排拼接"的输出题
🌟思考题:如果题目要在字模之间加一个空列做间隔,代码改哪里?(提示:在输出每位字模后多输出一个 .,但要注意最后一列后面不加,否则行末会多一个字符。)
****..................... ****.****.****.****..***. ****.................***. ****..****.********..***. ****.....................
#include <bits/stdc++.h>
using namespace std;
// 四张 5×5 字模:pat[数字][行号]
string pat[4][5] = {
{ ".....", ".***.", ".***.", ".***.", "....." }, // 0
{ "****.", "****.", "****.", "****.", "****." }, // 1
{ ".....", "****.", ".....", ".****", "....." }, // 2
{ ".....", "****.", ".....", "****.", "....." } // 3
};
int main() {
string n;
cin >> n; // 用字符串读入,逐位处理最方便
for (int r = 0; r < 5; r++) { // 外层:5 行
for (int i = 0; i < (int)n.size(); i++) {
int d = n[i] - '0'; // 字符 -> 数字
printf("%s", pat[d][r].c_str());
}
printf("\n");
}
return 0;
}// 二维字模打表的通用结构
string font[字符种类数][行数];
// 逐位处理的标准写法(读成字符串)
string n; cin >> n;
for (int i = 0; i < (int)n.size(); i++) {
int d = n[i] - '0';
// 用 d 去查表
}
// 输出 string 的三种方式
printf("%s", s.c_str()); // C 风格
cout << s; // C++ 流(最简单)
fputs(s.c_str(), stdout); // 少用
// 字符与数字互转
int d = c - '0'; // 字符 -> 数字
char c = char(d + '0'); // 数字 -> 字符②编程打卡 · 点一下就能勾选
- 完成 B3926《单位转换》,跑通全部样例
- 完成 B3956《字母求和》,跑通全部样例
- 完成 B4003《移位》,跑通全部样例
- 完成 B3843《密码合规》,跑通全部样例
- 完成 B4039《回文拼接》,跑通全部样例
- 完成 B4067《打印数字》,跑通全部样例
- 对比题解里的参考代码,找出自己写法的差异
字符串处理(下)
①本日知识点 · 字符串处理(下)
本组 7 道题全部来自 GESP 真题,按「字符串处理(下)」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。
- 密码至少包含 8 个字符(太短的密码容易被猜出来哦!)。
- 密码至少包含一个大写字母(A、B、C、...、Z 都可以)。
- 密码至少包含一个数字(0、1、2、3、...、9 都可以)。
例如:
- 密码 PAs1s2an 是安全密码(有 8 位、包含大写字母 P、A 和数字 1、2)。
- 密码 ab1da3cd 不是安全密码(没有大写字母)。
- 密码 Paabdbcd 不是安全密码(没有数字)。
- 密码 Pa2 不是安全密码(只有 3 位,太短了)。
对于每组密码,一行包含一个字符串,代表需要安全检测的密码。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 6 PAs1s2an 1a2bCql3 Pa12bsna ab1da3cd Paabdbcd Pa2 | Y Y Y N N N |
- 密码
PAs1s2an 是安全密码(有 8 位、包含大写字母 P、A 和数字 1、2)。- 密码
1a2bCq13 是安全密码(有 8 位、包含大写字母 C 和数字 1、2、3)。- 密码
Pa12bsna 是安全密码(有 8 位、包含大写字母 P 和数字 1、2)。- 密码
ab1da5cd 不是安全密码(没有大写字母)。- 密码
Paabdbcd 不是安全密码(没有数字)。- 密码
Pa2 不是安全密码(只有 3 位,太短了)。数据范围
对于所有测试点,保证 1 ≤q T ≤q 100,并且每组密码长度不超过 100 且至少为 1,每组密码仅由大小写字母和数字组成。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
一个安全的密码需要同时满足:
长度至少 8 个字符
至少包含一个大写字母(A ~ Z)
至少包含一个数字(0 ~ 9)
给定 T 组密码,逐组判断并输出 Y(安全)或 N(不安全)。
💡人话翻译:三个条件是"且"的关系,有一个不满足就是 N。注意题目没有要求小写字母,也没有要求特殊字符,别自己加条件(这是本题最容易多虑的地方)。
🔍 关键词提取
字符串遍历条件判定三个布尔标记多组输入
已知条件
项目说明
输入第一行 T;随后 T 行,每行一个密码
输出每组一行,Y 或 N
数据范围1 ≤ T ≤ 100
密码长度不超过 100,至少 1
字符集仅大小写字母和数字(不含空格、特殊符号)
需要解决的问题
怎么判断"含大写"?遍历字符,用 c >= 'A' && c <= 'Z'
怎么判断"含数字"?同理用 c >= '0' && c <= '9'
怎么组织条件?三个布尔变量分别记录,最后用 && 串联
📥 多组输入
读入 T
循环 T 次
每次读一个字符串
每次都要重置标记
🔍 三类字符
大写:A ~ Z
数字:0 ~ 9
长度:size() >= 8
无需检查小写
✅ 判定逻辑
三个布尔量
全部为真才是 Y
任一为假就是 N
条件之间是"且"
⚠️ 容易多想
不需要特殊字符
不需要大小写混合
不需要"不能重复"
题目说什么就判什么
样例 6 组密码,答案依次是 Y Y Y N N N。我们把每一组的判定过程摊开看。
1
PAs1s2an → Y
长度 8 ✅
含大写 P、A ✅
含数字 1、2 ✅
✅ 三项全满足
2
1a2bCql3 → Y
长度 8 ✅
含大写 C ✅
含数字 1、2、3 ✅
✅ 三项全满足
3
Pa12bsna → Y
长度 8 ✅
含大写 P ✅
含数字 1、2 ✅
✅ 三项全满足
4
ab1da3cd → N
长度 8 ✅
含大写:一个都没有 ❌
含数字 1、3 ✅
❌ 缺大写字母
5
Paabdbcd → N
长度 8 ✅
含大写 P ✅
含数字:一个都没有 ❌
❌ 缺数字
6
Pa2 → N
长度 3 ❌
含大写 P ✅
含数字 2 ✅
❌ 长度不够(只差这一项也是 N)
📊 判定一览
密码长度 ≥ 8含大写含数字结论
PAs1s2an✅✅✅Y
1a2bCql3✅✅✅Y
Pa12bsna✅✅✅Y
ab1da3cd✅❌✅N
Paabdbcd✅✅❌N
Pa2❌✅✅N
🔑观察:第 4、5、6 组各缺一项就变成 N,说明三个条件缺一不可——这正是"且"的含义。
🟢 一次遍历 + 三个标记 推荐
遍历字符串,同时更新 hasUpper / hasDigit 两个标记
时间复杂度 O(L),L 为密码长度
空间 O(1)
循环一次就能判完
代码最直观
💡为什么推荐:长度用 s.size() 直接取,大写和数字在一次循环里同时判断,没有重复扫描。
🟠 四个 count 函数分段判断
分别用 count_if / 手写计数判断大写个数、数字个数
时间复杂度仍是 O(L)
但字符串被扫了 2 ~ 3 遍
代码更长
常数更大,没必要
⚠️常见错误:用了 isupper() 但没注意 locale 影响,或者把 isdigit() 用在了非 ASCII 字符上。竞赛中直接比字符区间更稳。
📈 性能对比
写法扫描次数代码行数
三个标记(推荐)1 次约 12 行
分段判断2 ~ 3 次约 20 行
每行输入一个密码(可多行),逐行判定并标出是哪一项不满足。
输入密码(每行一个)PAs1s2an
ab1da3cd
Paabdbcd
Pa2
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
int T;
scanf("%d", &T);
while (T--) {
string s;
cin >> s;
bool hasUpper = false, hasDigit = false;
for (char c : s) {
if (c >= 'A' && c <= 'Z') hasUpper = true;
else if (c >= '0' && c <= '9') hasDigit = true;
}
bool ok = (s.size() >= 8) && hasUpper && hasDigit;
printf("%s\n", ok ? "Y" : "N");
}
return 0;
}
🔑三个细节:① 布尔量每组都要重新初始化(写在 while 里面);② s.size() 是 unsigned,和 8 比较没问题,但如果要和负数比就要小心;③ 输出用 printf("Y\n") 最省事。
📖 关键几行怎么看
代码作用为什么这样写
while (T--)循环 T 次每轮先判断 T 非零再自减,正好跑 T 轮
for (char c : s)逐字符遍历范围 for 更简洁,不用写下标
c >= 'A' && c <= 'Z'判断大写比 isupper() 更可控,不依赖 locale
s.size() >= 8判断长度长度不足时其它两项满足也没用
⚠️不要自作主张加条件:题目只要求"长度 + 大写 + 数字",不含小写字母、不含特殊字符、不能全是数字 —— 这些都不是题目要求,加了就会判错。
写完程序后,用这些数据自查一遍:
输入答案考察点
Pa2N长度不足 8
Pa12bsnaY恰好 8 位,三项齐全
abcdefghN无大写、无数字
ABCDEFGHN无数字
12345678N无大写
A1bcdefgY含 1 个大写 + 1 个数字就够了
✅自查清单:① 布尔量是否在每组开头重置?② 长度用的是 size() 吗?③ 有没有多加题目没要求的条件?
🚨 易错点清单
⚠️布尔量没重置:如果把 hasUpper 定义在循环外面,上一组的 true 会污染下一组,导致原本该输出 N 的变成 Y。
⚠️把判断条件写成"或":三项是"且"关系,写成一个不满足就判 N 即可,但容易不小心写成 ||。
⚠️用 cin >> s 读入含空格的密码:本题密码不含空格,所以 cin >> s 安全;如果题目允许空格就必须用 getline。
时间复杂度
O(T × L)
空间复杂度
O(L)
T 最大
100
L 最大
100
时间怎么算的?
外层 T 组
每组遍历长度 L 的字符串一次
合计 O(T × L),最坏 100 × 100 = 10⁴ 次
空间都用在哪?
只用一个字符串存当前密码(长度 ≤ 100)和两个布尔量,所以是 O(L)。
✅ 最多 1 万次操作,任何语言都是瞬间完成。
// 字符分类判断的标准写法(不依赖 locale)
bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
bool isLower(char c) { return c >= 'a' && c <= 'z'; }
bool isDigit(char c) { return c >= '0' && c <= '9'; }
bool isAlpha(char c) { return isUpper(c) || isLower(c); }
// 大小写转换(差 32)
char toLower(char c) { return isUpper(c) ? char(c + 32) : c; }
// C++ 也提供了库函数,但竞赛中更推荐自己写:
// isupper / islower / isdigit / isalpha / tolower / toupper
// 注意它们返回的是 int,且受 locale 影响
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
字符区间比较判断是否为大写、数字所有字符分类题
布尔标记法三个条件各用一位记录多条件判定、合规检查
多组输入模板while (T--)几乎所有"T 组数据"的题目
🌟思考题:如果题目再增加一条"密码中必须至少包含一个小写字母",代码要加什么?(提示:再加一个 hasLower 标记即可,结构完全不变。)
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
scanf("%d", &T);
while (T--) {
string s;
cin >> s;
bool hasUpper = false, hasDigit = false;
for (char c : s) {
if (c >= 'A' && c <= 'Z') hasUpper = true;
else if (c >= '0' && c <= '9') hasDigit = true;
}
bool ok = (s.size() >= 8) && hasUpper && hasDigit;
printf("%s\n", ok ? "Y" : "N");
}
return 0;
}// 字符分类判断的标准写法(不依赖 locale)
bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
bool isLower(char c) { return c >= 'a' && c <= 'z'; }
bool isDigit(char c) { return c >= '0' && c <= '9'; }
bool isAlpha(char c) { return isUpper(c) || isLower(c); }
// 大小写转换(差 32)
char toLower(char c) { return isUpper(c) ? char(c + 32) : c; }
// C++ 也提供了库函数,但竞赛中更推荐自己写:
// isupper / islower / isdigit / isalpha / tolower / toupper
// 注意它们返回的是 int,且受 locale 影响但是和所有的利用字母表进行替换的加密技术一样,凯撒密码非常容易被破解,而且在实际应用中也无法保证通信安全。
现在给你一个已破解的凯撒密码明文与密文,与一个有相同偏移量的未破解凯撒密码密文,请你帮忙破解它。
第一行包含一个字符串,表示已破解的凯撒密码明文;
第二行包含一个字符串,表示有相同偏移量的未破解凯撒密码密文;
第三行包含一个字符串,表示待破解的凯撒密码密文。
| # | 输入 | 输出 |
|---|---|---|
| 1 | ABCDEFGVWXYZ DEFGHIJYZABC WKHTXLFNEURZQIRAMXPSVRYHUWKHODCBGRJ | THEQUICKBROWNFOXJUMPSOVERTHELAZYDOG |
样例 1 中,通过已破解的密码得出偏移量为
'D' - 'A' = 3,因此,对未破解部分进行逆向偏移:密文中的 W 对应明文中的 T('W' - 3 = 'T'),密文中的 K 对应明文中的 H('K' - 3 = 'H'),以此类推。数据范围
保证密码长度均不超过 1000,所有字符串由大写字母组成。
· 逐字符遍历,注意大小写差 32、字符位移要回绕。
写完后可到洛谷
B4500 对照题解。- 大写字母,比如 A、B、C
- 小写字母,比如 a、b、c
- 数字,比如 0、1、2
现在小杨同学想把这串字符变一变,规则如下:
1. 如果是大写字母,就变成对应的小写字母;
2. 如果是小写字母,就变成对应的大写字母;
3. 如果是数字,就变成 * 。
请你按照这个规则,帮小杨把整串字符转换好。
第一行:一个整数,表示这串字符一共有多少个字符。
第二行:一串连续的字符,中间没有空格。
注意:输出时字符之间不要加空格。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 5 aBc98 | AbC** |
aBc98
从左到右一个一个看:
1. a 是小写字母,所以变成 A;
2. B 是大写字母,所以变成 b;
3. c 是小写字母,所以变成 C;
4. 9 是数字,所以变成 *;
5. 8 是数字,所以变成 *。
所以最后输出:
AbC**
数据范围
字符个数不会超过 1000 个。
每个字符只会是大写字母、小写字母或数字。
· 逐字符遍历,注意大小写差 32、字符位移要回绕。
写完后可到洛谷
B4556 对照题解。小洛现在有一个字符串 S,他想将这个字符串分为若干段,段长度分别为 1,2,3,…。具体而言,他会先将第一个字符拿出来作为字符串 S_1,再将第 2,3 个字符拿出来作为 S_2,再将第 4,5,6 个字符拿出来作为 S_3,以此类推……最后若还有多余的字符,则单独作为一段。
例如说,对于字符串 \tt aaababcaacd,会被分为如下的五个字符串:
- S_1=\tt a;
- S_2=\tt aa;
- S_3=\tt bab;
- S_4=\tt caac;
- S_5=\tt d;
字符串 \tt aaababcaacd 分割出的 5 个字符串都是回文的。
小洛想要知道,对于读入的字符串 S,这些被分割出来的字符串,有多少个是回文的呢?
| # | 输入 | 输出 |
|---|---|---|
| 1 | aaababcaacd | 5 |
| 2 | abacdcaaba | 2 |
- 对于第 1 组样例,已经在题面中进行表述;
- 对于第 2 组样例,S_1=\tt a,S_2=\tt ba,S_3=\tt cdc,S_4=\tt aaba,其中 S_1 与 S_3 为回文字符串。
【数据范围】
假定记号 |S| 表示字符串 S 的长度。
- 对于 10% 的数据,字符串至多包含一种字母;
- 对于 30% 的数据,字符串至多包含两种字母;
- 对于 70% 的数据,|S|≤q 1000;
- 对于所有数据,1 ≤q |S| ≤q 10^6,字符串仅包含英语小写字母。
· 逐字符遍历,注意大小写差 32、字符位移要回绕。
写完后可到洛谷
B3997 对照题解。Apple、apple、APPLE、aPPle 等均视为同一个单词)。请你编写一个程序,输入 n 个单词,输出其中出现次数最多的单词。
接下来 n 行,每行包含一个单词,单词由大小写英文字母组成。
输入保证,出现次数最多的单词只会有一个。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 6 Apple banana apple Orange banana apple | apple |
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定 n 个单词,找出其中出现次数最多的单词。忽略字母大小写(Apple、apple、APPLE、aPPle 视为同一个单词),输出该单词的小写形式。输入保证出现次数最多的单词只会有一个。
💡人话翻译:先把所有单词统一转成小写,然后统计每个单词出现几次,最后挑出次数最多的那个输出。关键是"先归一化,再统计",顺序不能反。
🔍 关键词提取
大小写归一化计数映射找最大值map 或排序
已知条件
项目说明
输入第一行 n;随后 n 行每行一个单词
输出出现次数最多的单词(小写)
数据范围1 ≤ n ≤ 100
单词长度不超过 30,仅含大小写字母
重要保证出现次数最多的单词唯一(不会并列)
需要解决的问题
怎么忽略大小写?统一转成小写(或统一转大写),再比较
怎么统计次数?用 map<string, int> 或先排序后连续计数
怎么找最多的?遍历 map,记录出现次数最大的那个键
📥 读入
读 n
逐个读入单词
每个都转小写
保持原序无所谓
🔤 归一化
大写字母 +32 变小写
或用 tolower()
统一后再统计
输出自然就是小写
📊 计数
map<string,int> 累加
或排序后数连续段
两者都 O(n log n) 以内
n 只有 100
🏆 找冠军
遍历所有键
记录最大次数
题目保证不并列
输出对应的键
先全部转成小写,再逐个计数。
1
统一转小写
Apple → apple
banana → banana
apple → apple
Orange → orange
banana → banana
apple → apple
得到 apple、banana、apple、orange、banana、apple
2
逐个计数
apple:第 1、3、6 个 → 3 次
banana:第 2、5 个 → 2 次
orange:第 4 个 → 1 次
apple 出现 3 次,是最多的
3
输出
答案是 apple(已经是小写形式)
✅ 输出 apple
📊 词频表
单词出现次数是否最多
apple3✅ 是
banana2否
orange1否
🔑如果先统计再转小写会怎样?那样 Apple、apple、APPLE 会被当成 3 个不同的单词,每个都只出现 1 次,答案就错了。归一化必须在统计之前。
🟢 map 计数(推荐) 推荐
用 map<string,int> 边读边累加,最后遍历找最大
时间 O(n × L × log n)
不需要保存全部单词
代码短、逻辑直白
还能顺便输出"出现次数"
💡为什么推荐:读入的同时就完成计数,最后只需一趟遍历判断最大值,是词频统计的标准解法。
🟠 排序后数连续段
把单词数组排序,相同单词会相邻,数最长连续段
时间 O(n log n × L)
需要 O(n) 空间存所有单词
要额外处理"当前段长度"
代码更长
⚠️注意:排序法必须先把所有单词都转成小写再排序,否则 Apple 和 apple 不会相邻,连续段就数错了。
📈 性能对比
方案空间代码量
map 计数O(不同单词数)约 15 行
排序计数O(n)约 25 行
每行输入一个单词(可多行),程序会忽略大小写统计词频并找出最多的那个。
输入单词(每行一个)Apple
banana
apple
Orange
banana
apple
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
map<string, int> cnt;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (char &c : s) c = tolower(c); // 归一化:统一小写
cnt[s]++;
}
string best;
int bestCnt = -1;
for (auto &p : cnt) { // p.first 是单词,p.second 是次数
if (p.second > bestCnt) {
bestCnt = p.second;
best = p.first;
}
}
printf("%s\n", best.c_str());
return 0;
}
🔑为什么用 map 而不是 unordered_map?两者都能用,本题 n ≤ 100 完全没差别。map 的键有序,输出更稳定;unordered_map 平均更快但键无序。
📖 关键几行怎么看
代码作用为什么这样写
for (char &c : s) c = tolower(c);逐个字符转小写用引用才能改到原字符串,否则只是改副本
cnt[s]++计数map 的 [] 会在键不存在时自动插入 0
p.second > bestCnt找最大值严格大于即可,题目保证不并列
best = p.first记录答案存的是已经归一化过的小写单词
⚠️三个坑:① 忘了归一化,导致同一个词被拆成多个;② 用 tolower 时没加 &,改了副本无效;③ 初始 bestCnt 设为 0,在次数可能为 0 的场景下会出错(本题每个词至少出现 1 次,设 -1 最稳)。
写完程序后,用这些数据自查一遍:
输入答案考察点
1
Hellohello只有一个词,注意输出小写
3
a
a
ba最基础计数
4
Apple
apple
APPLE
bananaapple大小写混合必须视为同一个词
6
Apple
banana
apple
Orange
banana
appleapple题面样例
5
Zz
zZ
ZZ
zz
aazz4 种写法都归一化为 zz
✅自查清单:① 归一化在统计之前吗?② 用了引用改字符吗?③ 输出的确实是次数最多的那个词?
🚨 易错点清单
⚠️先统计后归一化:顺序反了,Apple 和 apple 会被算成两个词。
⚠️tolower 没加引用:for (char c : s) 改的是副本,必须写 for (char &c : s)。
⚠️输出时又转了一次小写:其实统计时已经全部是小写了,直接输出即可,再转一次也没错但多余。
时间复杂度
O(n × L × log n)
空间复杂度
O(n × L)
n 最大
100
单词长度
≤ 30
时间怎么算的?
读入 n 个单词,每个做 L 次转小写:O(n × L)
map 插入查找每次 O(log n × L)(字符串比较)
最后遍历 map 找最大:O(n)
总体远小于 100 × 30 × 7 次操作
空间都用在哪?
最坏情况下 n 个单词互不相同,map 里存 n 个键值对,空间 O(n × L)。
✅ n 只有 100,任何合理写法都是瞬间完成;这题考的是归一化意识,不是效率。
// 字符大小写转换
char toLower(char c) { return (c >= 'A' && c <= 'Z') ? char(c + 32) : c; }
char toUpper(char c) { return (c >= 'a' && c <= 'z') ? char(c - 32) : c; }
// 字符串整体转小写(注意引用)
for (char &c : s) c = toLower(c);
// 计数三兄弟
map<string, int> cnt; // 有序,便于稳定输出
unordered_map<string, int> h; // 更快,但键无序
int bucket[300]; // 若键恰好是小整数,可以直接开数组
// 遍历 map 找最大值
string best; int bc = -1;
for (auto &p : cnt) if (p.second > bc) { bc = p.second; best = p.first; }
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
大小写归一化统一转小写后再统计字符串比较、去重、字典序处理
map 计数用键值对记录出现次数词频统计、去重、判断是否出现过
遍历找极值一趟扫描记录最大值的键求众数、最值、Top-1 问题
🌟思考题:如果题目改成"输出出现次数最多的前 3 个单词,按次数从多到少、次数相同按字典序",该怎么改?(提示:把 map 里的键值对倒进 vector,写个自定义比较函数再排序。)
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
map<string, int> cnt;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (char &c : s) c = tolower(c); // 归一化:统一小写
cnt[s]++;
}
string best;
int bestCnt = -1;
for (auto &p : cnt) { // p.first 是单词,p.second 是次数
if (p.second > bestCnt) {
bestCnt = p.second;
best = p.first;
}
}
printf("%s\n", best.c_str());
return 0;
}// 字符大小写转换
char toLower(char c) { return (c >= 'A' && c <= 'Z') ? char(c + 32) : c; }
char toUpper(char c) { return (c >= 'a' && c <= 'z') ? char(c - 32) : c; }
// 字符串整体转小写(注意引用)
for (char &c : s) c = toLower(c);
// 计数三兄弟
map<string, int> cnt; // 有序,便于稳定输出
unordered_map<string, int> h; // 更快,但键无序
int bucket[300]; // 若键恰好是小整数,可以直接开数组
// 遍历 map 找最大值
string best; int bc = -1;
for (auto &p : cnt) if (p.second > bc) { bc = p.second; best = p.first; }你的任务是:给定一个正整数 n,计算在 1 到 n 的范围内二进制回文数的数量。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 15 | 6 |
样例 1 中,1 到 15 范围内 1、3、5、7、9、15 是二进制回文数。
数据范围
1 ≤q n ≤q 10^5。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
对于一个正整数 n,将其转换为不含前导零的二进制表示。如果这个二进制序列从左向右读与从右向左读完全相同,则称该数为二进制回文数。例如 9 的二进制是 (1001)₂,是二进制回文数;12 的二进制是 (1100)₂,不是。
你的任务是:给定正整数 n,计算 1 到 n 范围内二进制回文数的数量。
💡人话翻译:把 1 到 n 每个数都写成二进制,看看哪些数的二进制串正读反读一样,数一数有几个。注意叶子级的细节:二进制首位必定是 1,不存在前导零。
🔍 关键词提取
进制转换回文判断枚举计数去前导零
已知条件
项目说明
输入一行一个正整数 n
输出1 到 n 中二进制回文数的个数
数据范围1 ≤ n ≤ 10⁵
二进制长度最多 17 位(2¹⁶ = 65536,2¹⁷ = 131072)
需要解决的问题
怎么把十进制转成二进制?除 2 取余法,反复取 n % 2 再 n /= 2
怎么判回文?把二进制串反转后与原串比较(回文反转后不变)
怎么数个数?1 到 n 逐个判断累加,没有更省的办法也不需要
📥 输入与循环
读入 n
i 从 1 枚举到 n
计数器 ans 置 0
每个数独立判断
🔄 进制转换
除 2 取余法
余数拼成 0/1 串
循环条件 x > 0
得到的串恰好低位在前
🔍 回文判定
反转字符串比较
或双指针从两端夹
也可直接用数字反转
回文反转后不变
⚠️ 边界细节
1 是回文(一位数)
循环从 i = 1 开始
不含前导零
int 足够,不会溢出
题目给的样例答案 6,我们亲手把它算出来,确认理解没跑偏。
1
1 → 1
只有一位,正读反读都是 1
✅ 是回文(计数 1)
2
2 → 10,3 → 11
2 的二进制 10,反转成 01,与原串不同
3 的二进制 11,反转还是 11
❌ 2 不算,✅ 3 算(计数 2)
3
4 → 100,5 → 101,6 → 110
100 反转 001 ≠ 100
101 反转 101 = 101
110 反转 011 ≠ 110
只有 5 算(计数 3)
4
7 → 111
三位全是 1,反转不变
✅ 算(计数 4)
5
8 → 1000,9 → 1001,10 ~ 14
8 = 1000 ❌;9 = 1001 ✅
10 = 1010 ❌,11 = 1011 ❌,12 = 1100 ❌
13 = 1101 ❌,14 = 1110 ❌
这一段只有 9 算(计数 5)
6
15 → 1111
四位全是 1
✅ 算(计数 6)
📊 汇总
数字二进制是否回文
11✅ 是
210❌ 否
311✅ 是
4100❌ 否
5101✅ 是
6110❌ 否
7111✅ 是
81000❌ 否
91001✅ 是
10 ~ 14—❌ 都不是
151111✅ 是
🔍 观察到的规律
位数是 1 的全是回文:1 ~ 1(1 个)
位数是 2、3、4 的:11、101、111、1001、1111 —— 中间位可以任意,两端必须相同
每跨越一个 2 的幂,候选数就换一批,所以数量增长很慢(n = 10⁵ 时也才几十个)
🟢 枚举 + 除 2 取余 推荐
对 1 到 n 每个数求二进制串,反转后比较
时间复杂度 O(n log n)
每个数二进制最多 17 位
n = 10⁵ 时运算量约 170 万次
代码十几行,不容易写错
💡为什么够用:C++ 每秒能跑约 10⁸ 次操作,170 万次不到 1 毫秒。
🔵 按位数构造回文数
枚举二进制长度 k,前半段自由取,后半段镜像过来,判断是否 ≤ n
时间复杂度 O(√n)
不需要逐个数字转换
代码约 40 行,边界多
n 达到 10¹⁸ 时才有必要
⚠️风险提示:要处理长度奇偶、前导位必须是 1、末尾数是否超过 n 等细节,三级考试写它性价比极低。
📈 性能对比
n 的规模枚举法运算量构造法运算量
1,000约 1 万次约 60 次
10,000约 14 万次约 200 次
100,000(本题上限)约 170 万次约 500 次
输入一串数字(空格或逗号分隔),逐个转成二进制并判断是否回文,最后统计回文个数。
输入
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
// 判断整数 x 的二进制表示是否为回文
bool isBinPalindrome(int x) {
string b = "";
while (x > 0) { // 除 2 取余,得到 0/1 位
b += char('0' + x % 2);
x /= 2;
}
string r = b;
reverse(r.begin(), r.end()); // 反转后比较
return b == r;
}
int main() {
int n;
scanf("%d", &n);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (isBinPalindrome(i)) ans++;
}
printf("%d\n", ans);
return 0;
}
🤔为什么"低位在前"也不影响?除 2 取余得到的是低位在前的串,但回文串本身反转后不变,所以正序存还是逆序存,比较的结果一样。
📖 关键几行怎么看
代码作用为什么这样写
while (x > 0)不断取下一位x 变成 0 说明所有位都取完了
char('0' + x % 2)把 0/1 变成字符字符 0 的 ASCII 码加上余数就是 "0" 或 "1"
reverse(r.begin(), r.end())反转字符串需要 <algorithm>(bits/stdc++.h 已包含)
return b == r;判断相等string 支持直接 == 比较
⚡省空间写法:不用字符串,边取余边构造反转后的数字,最后比 orig == rev 即可,连 string 都省了。
写完程序后,用这些数据自查一遍:
输入答案考察点
11最小规模,1 位必是回文
212 = 10 不是回文
321 和 3
741、3、5、7 —— 注意不是 5 个
95第一个四位回文数 1001 出现
156题面给出的样例
100000运行验证最大规模,考察是否超时
✅自查清单:① 循环区间是不是 1 ~ n?② 二进制串有没有前导零?③ 比较的是"反转后是否相等"而不是"是否全为 1"?
🚨 易错点清单
⚠️循环从 0 开始:题目要求统计 1 到 n,写成 i = 0 会把 0 也算进去(0 的二进制是 "0",也"回文")。
⚠️把"二进制长度"当成固定位数:题目明确说不含前导零,不能把 25(11001)补成 00011001 再判回文。
⚠️用了 int 却想要更大的 n:本题 n ≤ 10⁵,int 足够;但如果数据放大到 10⁹,单个数的二进制就有 30 位,仍不溢出,只是枚举法会超时。
时间复杂度
O(n log n)
空间复杂度
O(log n)
n 最大
10⁵
运算次数
约 170 万
时间怎么算的?
外层循环 n 次
每次转二进制:位数约 log₂n,最多 17 次操作
反转 + 比较:同样 O(log n)
合计 n × O(log n) = O(n log n)
空间都用在哪?
只需要一个字符串保存当前数字的二进制(最长 17 个字符),所以是 O(log n),与 n 无关。
✅ n = 10⁵ 时总操作约 170 万次,C++ 一瞬间跑完,稳妥通过。
// 十进制转二进制(正序)
string toBinary(int x) {
string s = "";
while (x > 0) { s = char('0' + x % 2) + s; x /= 2; }
return s.empty() ? "0" : s;
}
// 通用回文判断(双指针)
bool isPal(const string &s) {
for (int i = 0, j = (int)s.size() - 1; i < j; i++, j--)
if (s[i] != s[j]) return false;
return true;
}
// 数 1 的个数(本题不直接用,但很常用)
int cnt1(int x) { int c = 0; while (x) { c += x & 1; x >>= 1; } return c; }
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
除 k 取余法把 i 转成二进制串任意进制转换、进制判断
回文判定反转后比较或双指针字符串回文、数字回文、回文子串
枚举 + 计数1 ~ n 逐个数,满足就累加统计类题目、筛法类题目
🌟思考题:如果 n 放大到 10⁹,枚举法就太慢了。能不能换个角度——直接构造二进制回文数?提示:先定长度 k,前 ⌈k/2⌉ 位自由取(首位必须是 1),后一半镜像过去,再看这个数是否 ≤ n。
#include <bits/stdc++.h>
using namespace std;
// 判断整数 x 的二进制表示是否为回文
bool isBinPalindrome(int x) {
string b = "";
while (x > 0) { // 除 2 取余,得到 0/1 位
b += char('0' + x % 2);
x /= 2;
}
string r = b;
reverse(r.begin(), r.end()); // 反转后比较
return b == r;
}
int main() {
int n;
scanf("%d", &n);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (isBinPalindrome(i)) ans++;
}
printf("%d\n", ans);
return 0;
}// 十进制转二进制(正序)
string toBinary(int x) {
string s = "";
while (x > 0) { s = char('0' + x % 2) + s; x /= 2; }
return s.empty() ? "0" : s;
}
// 通用回文判断(双指针)
bool isPal(const string &s) {
for (int i = 0, j = (int)s.size() - 1; i < j; i++, j--)
if (s[i] != s[j]) return false;
return true;
}
// 数 1 的个数(本题不直接用,但很常用)
int cnt1(int x) { int c = 0; while (x) { c += x & 1; x >>= 1; } return c; }1. 小明从左到右扫描字符串,遇到第一个空格后停止,并将字符串分割为左右两个部分(舍弃用于分割的这个空格);
2. 对于上次分割后右侧的字符串,小明继续扫描,第一次遇到连续两个空格后停止,并将字符串分割为左右两个部分(舍弃用于分割的这两个空格);
3. 对于上次分割后右侧的字符串,小明继续扫描,第一次遇到连续三个空格后停止,并将字符串分割为左右两个部分(舍弃用于分割的这三个空格);
4. 以此类推,小明每分割一次,下一次分割就需要更长的连续空格;直到字符串无法再次分割。
最后输出每次分割的左侧的字符串,以及最后一次分割的右侧字符串。
如果字符串完全无法进行任何一次分割,直接输出其本身。
第一次分割左侧的字符串,第二次分割左侧的字符串,……,最后一次分割左侧的字符串,最后一次分割右侧的字符串。
| # | 输入 | 输出 |
|---|---|---|
| 1 | sdfd 55 55 99312 | sdfd 55 55 99312 |
| 2 | AbCd 999 | AbCd 999 |
1. 第一次分割将字符串分割为
sdfd 和 55 55 99312;2. 第二次分割将字符串分割为
55 55 和 99312。对于第二次分割,注意 55 和 55 之间虽然有空格,但是第二次分割需要连续两个空格才行;
另外,55 55 和 99312 之间有三个空格,第二次分割只需要两个,所以会分割为 55 55 和 99312,也就是右侧会留下一个空格;因为只留下了一个空格,所以不再满足第三次分割要求。
样例解释 2
1. 第一次分割将字符串分割为 AbCd 和 999;
2. 第二次分割将字符串分割为 空字符串 和 999。
由于 AbCd 和 999 之间有三个空格,第一次分割消耗掉一个,因此还能进行第二次分割,这个时候会分割出空字符串,因此输出中会输出一个空行(不能省略)。
数据范围
字符串长度不超过 1000,字符串中只包含大写字母、小写字母,数字,或空格,且输入字符串不会以空格结尾。
特别强调:输入仅一行,但可能包含若干空格
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
按如下规则分割字符串:
从左到右扫描,遇到第一个空格就切成左右两段(舍弃这个空格)
对右段继续,遇到连续两个空格再切(舍弃这两个空格)
再对右段继续,需要连续三个空格;依此类推
直到无法再分割为止
依次输出:每次分割左侧的字符串,以及最后一次分割右侧的字符串。如果完全无法分割,直接输出原串。
💡人话翻译:第 k 刀需要"连续 k 个空格"作为刀口。每次只消耗恰好 k 个空格,多出来的空格会留在右侧串里——这是本题最容易算错的地方。
🔍 关键词提取
字符串切分连续空格计数贪心匹配边界处理
已知条件
项目说明
输入一行字符串(可能含空格,不以空格开头)
输出若干行:每次分割的左侧串 + 最后剩余的右侧串
数据范围长度不超过 1000
字符集大小写字母、数字、空格
第 k 刀需要恰好连续 k 个空格作为分隔
需要解决的问题
怎么找刀口?从左扫描,找第一段"连续空格数 ≥ k"的地方
消耗几个空格?只消耗 k 个,剩余的空格归右侧
什么时候停?找不到"连续 ≥ k 个空格"时停止,此时剩下的整段作为最后一个输出
📥 读入
整行字符串(可含空格)
不含前导空格
长度 ≤ 1000
用 getline 读
🔍 找刀口
第 k 次需要连续 k 个空格
从左往右找第一处
找到的位置即分割点
消耗恰好 k 个空格
📤 输出
每次输出左侧串
最后输出剩余的右串
可能是空串(要输出空行)
无法分割则输出原串
⚠️ 易错点
多消耗了空格
用"至少 k 个"当"恰好 k 个"
空串要输出空行
忘记最后一段
共 3 个非空段,中间的空格数分别是 1 个和 3 个。
1
第 1 刀:需要 1 个空格
从左找第一处连续 ≥ 1 个空格:在 "sdfd" 后面
这段空格长度是 1,恰好等于 1
切出左侧 "sdfd",消耗掉这 1 个空格
右侧剩余 "55 55 99312"
输出第 1 段:sdfd
2
第 2 刀:需要 2 个空格
在 "55 55 99312" 里找连续 ≥ 2 个空格
"55" 和 "55" 之间只有 1 个空格 → 不够
继续往后,"55" 和 "99312" 之间有 3 个空格 → 够了
切出左侧 "55 55",消耗 恰好 2 个空格
右侧剩余 " 99312"(还剩 1 个空格)
输出第 2 段:55 55
3
第 3 刀:需要 3 个空格
在 " 99312" 里找连续 ≥ 3 个空格
整段只有 1 个空格 → 找不到
✅ 无法继续,输出剩余的 " 99312"
📊 输出结果
sdfd
55 55
99312
🔑注意第 2 刀的两个细节:① 它跳过了 "55" 和 "55" 之间的 1 个空格(因为不够 2 个);② 它从 3 个空格里只吃掉 2 个,所以右侧串开头留下了一个空格:" 99312"。"恰好消耗 k 个"是本题的核心。
🧮 样例 2:AbCd 999(含空串输出)
这组数据会切出一个空串,输出时必须保留那一行空行。
1
第 1 刀:需要 1 个空格
"AbCd" 和 "999" 之间有 3 个空格
找到第一处连续 ≥ 1 个空格,在 "AbCd" 后
消耗 1 个空格,左侧 = "AbCd"
右侧剩余 " 999"(还剩 2 个空格)
输出:AbCd
2
第 2 刀:需要 2 个空格
在 " 999" 里找连续 ≥ 2 个空格
开头正好是 2 个空格 → 够了
消耗这 2 个空格,左侧 = 空字符串
右侧剩余 "999"
⚠️ 输出一个空行!
3
第 3 刀:需要 3 个空格
在 "999" 里没有空格 → 无法分割
✅ 输出剩余的 "999"
📊 输出结果(中间那行是空行)
AbCd
999
⚠️空行不能省:第 2 刀切出的左侧是空字符串,必须原样输出一行空行。很多同学会误以为"空串不用输出",直接判错。这是本题最常见的失分点。
🟢 逐段扫描(推荐) 推荐
维护当前右段起点,第 k 刀找"连续 ≥ k 个空格"的第一处并消耗 k 个
长度 ≤ 1000,O(L²) 完全够
逻辑与题面一一对应
空串自然处理
代码 25 行
💡关键实现:用下标 pos 表示当前右段起点,第 k 刀在 [pos, L) 内找第一个"连续空格数 ≥ k"的位置 i,输出 s.substr(pos, i - pos),然后 pos = i + k。
🟠 用 stringstream 按空格切分
直接按空格拆成单词数组
会把连续空格"压扁"
丢失空格个数信息
无法满足题意
不适用
⚠️为什么不行:本题的核心就是"空格个数",而 stringstream 会把任意多个连续空格当成一个分隔符,信息全丢了。
📈 性能对比
方案是否可行原因
逐段扫描✅ 可行保留空格个数信息
stringstream❌ 不可行连续空格被压扁
输入一行字符串(可含空格),程序会按规则逐刀切分并展示每刀的位置与结果。
输入字符串
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
string s;
getline(cin, s); // 注意:必须用 getline,因为串里有空格
int pos = 0; // 当前右段的起点
int k = 1; // 第 k 刀
while (true) {
// 在 s[pos..] 中找第一处"连续空格数 >= k"的起始位置 i
int i = -1;
for (int j = pos; j < (int)s.size(); ) {
if (s[j] == ' ') {
int run = 0;
while (j + run < (int)s.size() && s[j + run] == ' ') run++;
if (run >= k) { i = j; break; } // 找到了
j += run; // 跳过这一段空格继续找
} else {
j++;
}
}
if (i == -1) { // 找不到刀口,输出剩余全部
printf("%s\n", s.substr(pos).c_str());
break;
}
printf("%s\n", s.substr(pos, i - pos).c_str()); // 输出左侧
pos = i + k; // 只消耗 k 个空格
k++;
}
return 0;
}
🔑两个关键点:① 用 getline(cin, s) 读入整行——如果用 cin >> s 会在第一个空格处断掉;② pos = i + k 只跳过 k 个空格,而不是跳过整段空格——这就是"右侧留下多余空格"的原因。
📖 关键几行怎么看
代码作用为什么这样写
getline(cin, s)读整行字符串含空格,不能用 >>
run >= k判断这段空格够不够够 k 个就能当刀口
j += run跳过整段空格避免在一个空格段里反复判断
pos = i + k只消耗 k 个本题核心,多余的留给右侧
printf("%s\n", ...)输出一段空串时输出空行,符合题意
⚠️三个坑:① 用 cin >> s 读入,遇到第一个空格就断了;② pos = i + run(消耗整段空格),会导致样例 1 右侧少一个空格;③ 切出空串时"跳过不输出",导致样例 2 少一行空行。
写完程序后,用这些数据自查一遍:
输入答案考察点
sdfd 55 55 99312sdfd / 55 55 / ␣99312题面样例 1,注意右侧留下了 1 个空格
AbCd 999AbCd / (空行)/ 999题面样例 2,中间输出空行
abcabc没有空格,直接输出原串
a ba / b只有 1 个空格,切一刀后结束
a ba / ␣b2 个空格:第 1 刀吃掉 1 个,剩 1 个不够第 2 刀 → 输出 "a" 和 " b"
x y zx / y z第 1 刀切出 x;第 2 刀需要 2 个连续空格,但两处都只有 1 个 → 输出 "x" 和 "y z"
✅自查清单:① 用 getline 读入了吗?② 只消耗恰好 k 个空格吗?③ 空串也输出空行了吗?④ 最后剩余的右段输出了吗?
🚨 易错点清单
⚠️用 cin >> 读入:字符串含空格,必须用 getline。
⚠️消耗了整段空格:必须是 pos = i + k,只吃 k 个,多余的留给右侧。
⚠️空串不输出:切出空串时必须输出一个空行,否则输出行数不对。
时间复杂度
O(L²)
空间复杂度
O(L)
L 最大
1000
最坏运算
约 10⁶
时间怎么算的?
每一刀都要在剩余串里扫描一遍找刀口,单刀 O(L)
最多切 L 刀(每刀至少消耗 1 个字符)
合计 O(L²)
L = 1000 时约 10⁶ 次字符比较,完全够快
空间都用在哪?
只需要原字符串和几个下标变量,substr 会产生临时串但总长度不超过 O(L²) 的输出量。
✅ L ≤ 1000,O(L²) 约 10⁶ 次操作,轻松通过。
// 读入含空格的整行(字符串题必备)
string s;
getline(cin, s);
// 如果前面用过 cin >> n,要先吃掉那个换行:
// cin.ignore();
// 找"连续 run 个空格"的起始位置
int findSpaceRun(const string &s, int from, int need) {
for (int j = from; j < (int)s.size(); ) {
if (s[j] == ' ') {
int run = 0;
while (j + run < (int)s.size() && s[j + run] == ' ') run++;
if (run >= need) return j;
j += run;
} else j++;
}
return -1; // 没找到
}
// 子串截取
string left = s.substr(pos, len); // 从 pos 起 len 个字符
string right = s.substr(pos); // 从 pos 到末尾
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
getline 读整行保留空格信息所有含空格的字符串输入
连续空格计数扫描时统计空格段长度文本处理、格式解析题
只消耗需要的部分pos = i + k按分隔符切分但保留多余分隔符
🌟思考题:如果规则改成"每次需要恰好 k 个空格(不多不少)",那么样例 2 的第一刀还成立吗?(提示:AbCd 和 999 之间有 3 个空格,第 1 刀要求"恰好 1 个",而该处是 3 个,不满足"恰好",所以第一刀就找不到位置,整串直接原样输出——这就是"恰好"和"至少"的关键区别。)
sdfd 55 55 99312
AbCd 999
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
getline(cin, s); // 注意:必须用 getline,因为串里有空格
int pos = 0; // 当前右段的起点
int k = 1; // 第 k 刀
while (true) {
// 在 s[pos..] 中找第一处"连续空格数 >= k"的起始位置 i
int i = -1;
for (int j = pos; j < (int)s.size(); ) {
if (s[j] == ' ') {
int run = 0;
while (j + run < (int)s.size() && s[j + run] == ' ') run++;
if (run >= k) { i = j; break; } // 找到了
j += run; // 跳过这一段空格继续找
} else {
j++;
}
}
if (i == -1) { // 找不到刀口,输出剩余全部
printf("%s\n", s.substr(pos).c_str());
break;
}
printf("%s\n", s.substr(pos, i - pos).c_str()); // 输出左侧
pos = i + k; // 只消耗 k 个空格
k++;
}
return 0;
}// 读入含空格的整行(字符串题必备)
string s;
getline(cin, s);
// 如果前面用过 cin >> n,要先吃掉那个换行:
// cin.ignore();
// 找"连续 run 个空格"的起始位置
int findSpaceRun(const string &s, int from, int need) {
for (int j = from; j < (int)s.size(); ) {
if (s[j] == ' ') {
int run = 0;
while (j + run < (int)s.size() && s[j + run] == ' ') run++;
if (run >= need) return j;
j += run;
} else j++;
}
return -1; // 没找到
}
// 子串截取
string left = s.substr(pos, len); // 从 pos 起 len 个字符
string right = s.substr(pos); // 从 pos 到末尾②编程打卡 · 点一下就能勾选
- 完成 B4449《密码强度》,跑通全部样例
- 完成 B4500《凯撒密码》,跑通全部样例
- 完成 B4556《字符转换》,跑通全部样例
- 完成 B3997《小洛的字符串分割》,跑通全部样例
- 完成 B4262《词频统计》,跑通全部样例
- 完成 B4499《二进制回文串》,跑通全部样例
- 完成 B4578《分割字符串》,跑通全部样例
- 对比题解里的参考代码,找出自己写法的差异
排序与比较
①本日知识点 · 排序与比较
cmp 返回 true 表示「a 排前面」;多关键字先判不等再比次。
本组 1 道题全部来自 GESP 真题,按「排序与比较」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。
老师想知道至少需要准备多少颗糖果才能让所有小朋友都开心。你能帮帮老师吗?
第二行,n 个正整数 a_1, a_2, …, a_n,依次表示每位小朋友至少需要的糖果数量。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 4 1 4 3 3 | 16 |
| 2 | 15 314 15926 53589793 238462643 383279502 8 8 4 1 9 7 1 6 9 3 | 4508143253 |
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
有 n 位小朋友排成一队。第 i 位小朋友想要至少 aᵢ 颗糖果,并且分给他的糖果数量必须严格多于前一位小朋友(否则他会不开心)。
老师想知道至少需要准备多少颗糖果才能让所有小朋友都开心。
💡人话翻译:给每位小朋友实际发的糖数记作 bᵢ,需要满足两个条件:① bᵢ ≥ aᵢ;② bᵢ > bᵢ₋₁(第一位没有前一位限制)。要使总和最小,每位都应"刚好卡着下限发"。
🔍 关键词提取
贪心严格递增递推long long
已知条件
项目说明
输入第一行 n;第二行 n 个正整数 aᵢ
输出最少需要的糖果总数
数据范围1 ≤ n ≤ 1000
数值范围1 ≤ aᵢ ≤ 10⁹
严格性bᵢ 必须严格大于 bᵢ₋₁,不能相等
需要解决的问题
每个人发多少?b₁ = a₁;之后 bᵢ = max(aᵢ, bᵢ₋₁ + 1)
为什么这样最省?前面发得越少,后面被"抬高"的压力越小,所以每一步都取满足条件的最小值
会不会溢出?单个 aᵢ 可达 10⁹,而 bᵢ 还可能被抬到 10⁹ + n,总和可达 10¹² —— 必须用 long long
📥 读入
n 和数组 a
实际发糖数记作 b
总和用 long long
b 由前一项递推
🧠 递推规则
b₁ = a₁(第一位无约束)
bᵢ ≥ aᵢ(满足自己的要求)
bᵢ > bᵢ₋₁(严格递增)
bᵢ = max(aᵢ, bᵢ₋₁ + 1)
➕ 累加
每算出一个 bᵢ 就加到总和
边算边加,不用存数组
最后输出总和
注意 long long
⚠️ 易错点
写成 bᵢ = max(aᵢ, bᵢ₋₁) 漏了 +1
用 int 导致溢出
总和用 int 累加
把"严格"当成"不小于"
我们一个个来,每次都取"刚好满足条件的最小值"。
1
第 1 位小朋友(a₁ = 1)
没有"比前一位多"的限制
所以直接发 a₁
b₁ = 1,累计 1
2
第 2 位小朋友(a₂ = 4)
下限是 4,同时要比 b₁ = 1 大(即至少 2)
max(4, 1 + 1) = max(4, 2) = 4
b₂ = 4,累计 5
3
第 3 位小朋友(a₃ = 3)
下限是 3,但要比 b₂ = 4 大(即至少 5)
max(3, 4 + 1) = max(3, 5) = 5
注意这里自己的下限 3 没起作用,是被前一位抬上去的
b₃ = 5,累计 10
4
第 4 位小朋友(a₄ = 3)
max(3, 5 + 1) = max(3, 6) = 6
b₄ = 6,累计 16
📊 逐人结果
小朋友自己的下限 aᵢ前一位发的 bᵢ₋₁实际发 bᵢ说明
11—1直接取 a₁
24144 > 1 + 1?不,4 ≥ 2,取下限 4
3345被前一位抬高到 5(下限 3 没起作用)
4356被前一位抬高到 6
总和 = 1 + 4 + 5 + 6 = 16 ✓
🧮 样例 2:为什么必须用 long long
样例 2 的输入里有 383279502 这样的大数字,n 又有 15 位。我们看看实际发糖数会涨到多少。
小朋友aᵢ实际发 bᵢ
1314314
21592615926
35358979353589793
4238462643238462643
5383279502383279502
68383279503 ← 被前一位抬高!
78383279504
……后面每位都比前一位多 1
🔑关键观察:第 6 位小朋友只要 8 颗,但前一位发到了 3.8 亿,他必须拿到 3.8 亿 + 1 颗!这种"小数字被大数字抬高"正是本题的核心考点。最终答案 4508143253 已经超过 int 上限(约 21 亿),所以必须用 long long。
🟢 贪心递推(推荐) 推荐
bᵢ = max(aᵢ, bᵢ₋₁ + 1),边算边累加
时间复杂度 O(n)
空间 O(1)(不用存数组)
每一步都取最小可行值
代码 6 行核心逻辑
💡贪心为什么正确:把某一位的糖发多了,后面每一位的"下限门槛"都会跟着抬高,总和只会变大。所以每位都发"刚好够"时总和最小。
🟠 先求最终最大值再倒推
先确定最后一位实际拿多少,再往前推
需要先正着推一遍才知道终值
等于要遍历两次
本质还是同一个递推
没有简化问题
⚠️结论:这题没有比 O(n) 更快的做法,因为每个 aᵢ 都必须看一遍。贪心一次遍历就是最优解。
📈 性能对比
方案遍历次数核心代码
贪心递推1 次约 6 行
两次遍历2 次约 12 行
输入每位小朋友的下限 aᵢ(空格分隔),程序会算出实际发糖数并给出总数。
输入
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
long long sum = 0; // 总和可能到 10^12,必须 long long
long long prev = 0; // 前一位实际拿到的糖果数
for (int i = 0; i < n; i++) {
long long a;
scanf("%lld", &a);
long long cur = max(a, prev + 1); // 取"下限"和"比前一位多 1"的较大者
sum += cur;
prev = cur;
}
printf("%lld\n", sum);
return 0;
}
🔑为什么不需要存整个数组?计算 bᵢ 时只用到 bᵢ₋₁,所以用一个变量 prev 滚动更新即可,空间降到 O(1)。这是递推题的常用优化。
📖 关键几行怎么看
代码作用为什么这样写
long long sum累加总数样例 2 的答案 45 亿已超 int 上限
max(a, prev + 1)核心递推兼顾"自己的下限"和"必须比前一位多"
prev = cur更新前一位为下一位提供比较基准
scanf("%lld", &a)读入大整数aᵢ 可达 10⁹,要用 long long 读
⚠️三个经典错误:① 写成 max(a, prev) 漏掉 +1,违反"严格递增";② 用 int sum 累加,样例 2 直接溢出;③ 把 aᵢ 读成 int,虽然 10⁹ 没超 int,但和 long long 混算时容易出错。
写完程序后,用这些数据自查一遍:
输入答案考察点
1
55只有一位,直接发下限
2
1 131 + 2,第二位被抬到 2
3
1 1 161 + 2 + 3,递增抬升
3
1 2 36下限本身已递增,恰好满足
4
1 4 3 316题面样例 1
15
314 15926 … 34508143253题面样例 2,考察 long long
✅自查清单:① 递推式有没有 +1?② 总和是不是 long long?③ 第一位有没有特殊处理?(其实不用,b₀ = 0 时 max(a₁, 1) 因为 a₁ ≥ 1 恰好等于 a₁。)
🚨 易错点清单
⚠️漏掉 +1:题目要求"必须比前一位更多",所以递推式是 max(aᵢ, bᵢ₋₁ + 1),不是 max(aᵢ, bᵢ₋₁)。
⚠️用 int 存总和:样例 2 答案 45 亿已超 int 上限(2147483647),即使 aᵢ 本身没超 int,累加后也会溢出。
⚠️把 aᵢ 当成 int 读入后与 long long 运算:虽然本题 aᵢ ≤ 10⁹ 恰好能放进 int,但统一用 long long 更安全,也避免类型提升的坑。
时间复杂度
O(n)
空间复杂度
O(1)
n 最大
1000
总和上限
约 10¹²
时间怎么算的?
每位小朋友只处理一次
每次做一次 max 和两次加法
合计 O(n),n ≤ 1000 时只需 1000 次运算
空间都用在哪?
用 prev 滚动记录前一位的糖数,不需要保存整个数组,所以是 O(1)。
✅ n 只有 1000,时间上毫无压力;真正的考点是识别出需要用 long long。
// 递推类题目的通用模板
long long prev = 初始值;
long long ans = 0;
for (int i = 0; i < n; i++) {
long long cur = 根据 a[i] 和 prev 计算;
ans += cur;
prev = cur; // 滚动更新
}
// 常见递推式对照
// 严格递增:cur = max(a[i], prev + 1)
// 不严格递增(可相等):cur = max(a[i], prev)
// 严格递减:cur = max(a[i], prev - 1)(注意下界)
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
贪心取最小值每位发"刚好够"的糖最小代价分配、资源分配类题目
递推 + 滚动变量只用 prev 记住前一项所有只依赖前一项的递推题
long long 意识先估算结果量级再选类型所有涉及累加、连乘的题目
🌟思考题:如果把要求从"必须比前一位多"改成"必须比前一位少"(即严格递减),递推式会变成什么?有没有可能无解?(提示:当某位的下限 aᵢ 太大时,就凑不出递减序列了。)
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
long long sum = 0; // 总和可能到 10^12,必须 long long
long long prev = 0; // 前一位实际拿到的糖果数
for (int i = 0; i < n; i++) {
long long a;
scanf("%lld", &a);
long long cur = max(a, prev + 1); // 取"下限"和"比前一位多 1"的较大者
sum += cur;
prev = cur;
}
printf("%lld\n", sum);
return 0;
}// 递推类题目的通用模板
long long prev = 初始值;
long long ans = 0;
for (int i = 0; i < n; i++) {
long long cur = 根据 a[i] 和 prev 计算;
ans += cur;
prev = cur; // 滚动更新
}
// 常见递推式对照
// 严格递增:cur = max(a[i], prev + 1)
// 不严格递增(可相等):cur = max(a[i], prev)
// 严格递减:cur = max(a[i], prev - 1)(注意下界)②编程打卡 · 点一下就能勾选
- 完成 B4359《分糖果》,跑通全部样例
- 对比题解里的参考代码,找出自己写法的差异
三级模拟自测卷
- 1.B 8+0+2+1 = 11
- 2.A 16+8+1 = 25
- 3.A 2→0010,E→1110
- 4.A 再取反加一得 0000 0101 = 5,加负号
- 5.B 比原码多一个 -128
- 6.A 1100 & 1010 = 1000
- 7.C 1100 | 1010 = 1110
- 8.D 1100 ^ 1010 = 0110
- 9.C 左移 1 位 = 乘 2
- 10.B 末位为 1 即奇数
- 11.B strlen 不含结尾的 \0
- 12.C 下标从 0 开始,共 5 个
- 13.A 负数才需要转换
- 14.A -128~127 共 256 个
- 15.B 全 0 取反是全 1,即 -1
- 16.B && 是逻辑运算,& 是按位运算
- 17.B 最后一个下标是 9
- 18.B sizeof 算整个数组,strlen 只数字符
- 19.A 子序列才允许不连续
- 20.A 穷举