GESP四级幸运数：字符串处理大数题的经典套路

上周末帮一个准备 GESP 四级的学生过真题，正好刷到洛谷 B3850 这道“[GESP202306 四级] 幸运数”。题目名称很喜庆，但真正让我在意的是题目标签里的“字符串处理”和“大数”两个词。很多同学一看到“大数”就容易慌，觉得要用高精度、甚至要找数学规律，其实这道题的内核非常朴素：它考查的就是你有没有意识到“这个数根本没法用 int 存”，以及你拿到一个超大整数之后，能不能想到用字符串去读、去扫、去统计。

这篇文章我会从 GESP 四级的命题角度出发，把 B3850 的题意拆开，把核心思路讲透，再给出 C++ 和 Python 两套可以直接提交的参考代码，最后把我自己踩过的坑和调试技巧整理成清单。适合正在备考 GESP 四级、或者刚接触字符串处理大数这类题目的同学阅读；就算你只是想在洛谷随手刷点字符串题，这篇文章也能帮你把“大数题”的套路梳理清楚。

1. 题目到底在考什么：拆掉“大数”这层壳

1.1 幸运数的定义与题面还原

B3850 的题面核心是“幸运数”的判断。洛谷上这道题的表述，大意是：给出一个正整数，判断它是不是幸运数。所谓幸运数，指的是这个正整数的十进制表示中，数字 0 到 9 每一个出现的次数都是偶数。

举两个例子来对号入座。比如112233，里面数字 1 出现 2 次、2 出现 2 次、3 出现 2 次，没有任何一个数字出现奇数次，所以它是幸运数。再看112，数字 1 出现 2 次，但数字 2 只出现 1 次，出现了奇数次，所以不是幸运数。再比如889900，8 出现 2 次、9 出现 2 次、0 出现 2 次，也是幸运数。

这个定义之所以叫“幸运”，你可以理解成每个数字都要“成双成对”地出现。这个条件听起来很“玄学”，但它背后的算法考点非常明确：频次统计。你只需要把每一个十进制数字出现的次数数清楚，然后检查一遍是否有奇数出现即可。

如果洛谷页面上的数据范围或样例细节和我描述的略有出入，一律以题面为准，但核心思路不会变：只要数字大到位数很长，就绕不开字符串处理。这也是标题里“字符串处理大数”的真正含义。

1.2 为什么“大数”必须用字符串处理

这道题最坑人的地方不在算法，而在于怎么读入。题目里的正整数可能非常大，位数可能达到 (10^5)、甚至更长。C++ 里最常用的整数类型 long long，最大也只能表示到大约 (9.22 \times 10^{18})，也就是 19 位左右。一旦位数超过 19 位，任何常规整数类型都会直接溢出。

这里可以打一个生活化的比方：你想用一个小桶去装一游泳池的水，桶再结实也会被撑坏。long long 就像那个桶，而题目给的大数就是游泳池。你硬要用整数类型去读，读进来的结果早就不是原来的数了，后面所有判断都失去意义。

正确的姿势是把它当成字符串读进来。字符串本身没有数字长度限制，它只受内存限制，10 万位、100 万位的数字都能原样装下。读入之后，我们也不需要真的去“算”这个数字的数值，只需要逐位看它的字符是什么，然后数次数就行。

所以这道题表面叫“大数题”，实际就是“字符串题”。它考的不是高精度四则运算，而是你有没有形成“看到超长数字先想字符串”的条件反射。这个反射一旦建立，以后看到任何大数相关题目，你就知道第一步该做什么了。

1.3 考点映射：字符串、数组、奇偶判断

把题目进一步解剖，会发现它至少涉及四个基础知识点。

第一是字符串的读入与遍历。在 C++ 中可以用string直接接收输入，然后通过下标或者范围 for 循环逐字符处理。第二是字符到数字的转换。一个字符'3'不等于整数 3，需要用c - '0'转成对应数字，这个操作建立在对 ASCII 编码的理解上。第三是数组计数。开一个长度为 10 的整型数组，分别记录 0 到 9 的出现次数。第四是奇偶判断。最后检查每个计数cnt[i] % 2是否等于 1。

这些知识点恰好都是 GESP 四级大纲里的高频内容。四级考试一般不考复杂算法，更喜欢用一个简单问题去考察字符串、数组、循环、模拟这些基本功。B3850 就是一个典型的样例：包装了一层“大数”的外衣，内核却非常基础。所以说，备考四级不要只盯着难题，把字符串和数组的基础打牢，才是拿高分的关键。

2. GESP 四级难度复盘：这道“幸运数”处于什么位置

2.1 四级到底考什么

很多刚接触 GESP 的同学对等级划分没什么概念。简单来说，四级一般要求你熟练掌握顺序、分支、循环、数组、字符串、函数，以及基础的枚举模拟和简单排序。从这几年真题来看，四级编程题经常出现冒泡排序交换次数、字符串分类统计、简单模拟等题目。

我在整理真题的时候发现，四级特别喜欢把“一眼能看懂、但数据范围会卡人”的题放进来。比如有同学经常搜到的“GESP 四级 202605 冒泡排序交换次数”，也是这种类型。B3850 的幸运数和它异曲同工：逻辑不复杂，但你如果用错数据类型、用错读入方式，就必然出错。它考查的不是你会不会复杂的数论，而是你处理基础问题时细不细心、思考全不全面。

2.2 洛谷上的 GESP 真题题号有什么用

洛谷上有一批 GESP 的历年真题，题号大多以 B 开头。B 开头一般属于“普及/入门”题库，难度不会特别高。B3850 这个题号就对应着 GESP 2023 年 6 月四级的第一道编程题。

对于备考同学来说，在洛谷刷真题有一个额外好处：可以即时评测、看错误样例、参考他人题解。你不需要像线下考试那样等着老师改卷，本地写完直接提交就能知道对不对。我建议你把洛谷上能搜到的 GESP 真题按等级整理成一个列表，从低到高刷。四级题就找 GESP 四级相关的题号，比如 B3849、B3850、B3851 这一批 202306 的题目，它们风格接近，可以集中练习。

2.3 被“大数”两个字吓到，是这道题最大的坑

我在实际带学生的过程中发现，十个人里有六个人看到 B3850 的第一反应是“完蛋，要写高精度”。其实这就是被包装吓住了。高精度四则运算确实属于大数处理，但那是另一类题。B3850 压根不需要计算大数的加减乘除，它只需要你统计每个字符出现的次数。

换句话说，这道题的“大数”只是改变了读入方式，没有改变算法复杂度。你仍然只需要 O(n) 的时间遍历一遍字符串，O(1) 的额外空间存那 10 个计数器。所以读题的时候一定要先看清楚：题目到底要求我“算”什么，还是只要求我“统计”什么。如果是统计字符频次这种需求，字符串就是最自然的载体，完全不需要碰高精度。

这样的“难度幻觉”在竞赛里非常常见。出题人故意把数据范围写得很大，用来筛选那些看到大数就放弃思考的同学。你只要冷静下来分析数据范围和操作类型，就能很快剥掉这层壳。

3. 核心思路与完整代码实现

3.1 算法流程拆解

这道题的完整流程可以拆成四个阶段，写代码的时候也可以按照这个顺序一步一步来实现。

第一步，读入字符串。在 C++ 里直接cin >> s即可，因为题目输入里就是一个不含空格的数字字符串。如果你担心输入结尾有换行或者多余空格，cin默认会跳过空白符，所以直接读是安全的。

第二步，统计 0 到 9 出现的次数。开一个int cnt[10]，初始化为 0。然后遍历字符串的每一个字符，把字符转成数字，对应计数器加一。这一步是核心，它做的事就是“数数”。

第三步，判断是否所有计数都是偶数。循环遍历cnt[0]到cnt[9]，只要发现某个计数器对 2 取模等于 1，就说明这个数字出现了奇数次，整个数不是幸运数，直接输出No并结束程序。如果循环全部通过，就输出Yes。

第四步，复杂度分析。遍历一遍字符串是 O(n)，其中 n 是字符串长度。十个计数器的检查是常数 O(10)。所以总时间复杂度 O(n)、空间复杂度 O(1)。这个复杂度对于 10 万位甚至 100 万位的数字来说都绰绰有余。

3.2 C++ 参考代码

下面这段代码可以直接用于洛谷提交。我特意写得“朴实无华”，没有压缩行数，目的是让每个初学者都能一眼看懂。

#include <bits/stdc++.h> using namespace std; int main() { string s; cin >> s; int cnt[10] = {0}; for (char c : s) { int digit = c - '0'; cnt[digit]++; } for (int i = 0; i < 10; i++) { if (cnt[i] % 2 == 1) { cout << "No" << endl; return 0; } } cout << "Yes" << endl; return 0; }

解释几个关键点。int cnt[10] = {0};是数组初始化，确保每个计数器从 0 开始，这一步如果不做，程序会出现未定义行为。c - '0'利用了 ASCII 表中数字字符连续排列的特性，把字符'0'到'9'映射成整数 0 到 9。最后cnt[i] % 2 == 1表示出现了奇数次，一旦发现就直接return 0退出，避免无意义的后续判断。

如果你所在的环境不允许使用bits/stdc++.h，也可以换成<iostream>和<string>，效果完全一样。GESP 官方环境通常支持万能头，但平时练习时建议养成写标准头文件的习惯。

3.3 Python 版本：懂原理后可以更简洁

Python 处理大数天然有优势，因为 Python 的整数本身就可以很长。不过用字符串统计的思路依然是最直接的。这里给出一版 Python 参考代码：

s = input().strip() cnt = [0] * 10 for ch in s: cnt[ord(ch) - ord('0')] += 1 if all(c % 2 == 0 for c in cnt): print("Yes") else: print("No")

Python 版本的核心逻辑与 C++ 完全一致。ord(ch) - ord('0')与 C++ 里的c - '0'是同一个思路。all(c % 2 == 0 for c in cnt)一行完成了“全部偶数”的判断，可读性也很好。

因为 Python 的 int 可以自动支持大数，所以有人可能会想：直接int(s)转成整数再处理行不行？行是行，但完全没有必要。转成大整数只会增加运算开销，而且如果数字有 10 万位，转成整数再一位位取，远不如直接遍历字符串干净。记住：判断数字特征类问题优先考虑字符串遍历，而不是先转 int。

4. 从零开始踩坑记录：新手最容易翻车的四个细节

4.1 用 int 或 long long 读入，直接爆掉

这个坑排第一，因为它的“炸法”最隐蔽。假如你写long long n; cin >> n;，当输入是一个 100 位的数字时，流读入会失败或者溢出，程序可能输出错误结果。更可怕的是，某些编译器在溢出时不会报错，而是产生一个错误但“看起来正常”的值，让你根本不知道问题出在哪。

有个很实用的检查方法：刷题之前先看一眼数据范围。B3850 这种题既然标签写了“大数”，就要默认输入远超整数范围。只要养成“大数配字符串”的条件反射，这个坑就不会踩到。你甚至可以记一句口诀：见到超长数字，先想string，再想long long。

4.2 统计数组忘记初始化

C++ 里局部数组int cnt[10];如果不初始化，里面存的是“随机垃圾值”。我见过有同学开好数组直接进入统计循环，结果某个计数器初始值是 3，累加完变成 5，最后判断5 % 2 == 1导致误判。

解决方法有两个。第一种是显式初始化：int cnt[10] = {0};，把前 10 个元素全部清零。第二种是使用memset：memset(cnt, 0, sizeof(cnt));。两种都行，我更推荐第一种，因为它直观且不会写错参数。记住：凡是用于计数的数组，使用前必须从 0 开始，这是所有统计类题目的基本纪律。

4.3 字符转数字时写错 ASCII 偏移

很多新手知道要把字符转成数字，但容易写成c - 48。虽然因为字符'0'的 ASCII 码正好是 48，这样写也能运行，但它的可读性差，而且违背了“用标准库含义表达意图”的习惯。万一有人手抖写成c - 47，那数字就全部偏了一位。

更严谨的写法是c - '0'。这样不仅语义清楚，还能避免死记硬背 ASCII 码表。在 Python 中对应的写法是ord(ch) - ord('0')，同样是利用字符码连续排列的特性。把“字符转数字”这个基础动作用熟，后面做字符串题目会顺畅很多。

4.4 输出格式：大小写和换行都是扣分点

在线评测系统对输出非常严格。这道题要求输出Yes或No，注意首字母大写、其余小写。有的人写成YES、NO或者yes，哪怕逻辑全对，也会被判 Wrong Answer。

另外，洛谷通常接受有换行和无换行的答案，但保险起见，建议每组输出后面都带上换行。C++ 里用cout << "Yes" << endl;或者cout << "Yes\n";都可以。我习惯用\n，因为省去endl带来的刷新缓冲开销，在大量输出时性能更好。

5. 常见问题与排查技巧实录

5.1 常见问题速查表

我把做这道题时学生问得最多的问题整理成一个速查表，方便你对照排查。

这张表的核心思想，是出了问题先怀疑“输入输出层”，再排查“逻辑层”。因为 B3850 的逻辑本身很短，大部分错误都发生在读入方式或初始化这种不起眼的地方。

5.2 调试技巧：用文件重定向喂入大样例

当你想测试一个 100000 位的大数时，不可能手动往终端里敲。我常用的做法是先在项目文件里准备好测试数据，然后用文件重定向把输入喂给程序。在 main 函数开头加上这样两行：

freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);

加上这两行之后，程序就会从input.txt读入数据，并把输出写到output.txt。调试完记得注释掉，否则提交到洛谷会因为找不到文件而出错。如果你不想改代码，也可以在终端里用命令./main < input.txt，效果一样。

生成超大测试数据可以用 Python 一行搞定，比如：

print('1' * 100000)

这会给程序输入一个由 10 万个 1 组成的数字。根据规则，它显然不是幸运数，因为数字 1 出现了 10 万次，是偶数，所以输出应该是Yes。你可以用这种办法验证程序的性能，看它能不能在 1 秒内跑完。

5.3 边界测试样例设计

除了超长数字，还要测几个边界情况。

第一个是只有一位数字的情况，比如输入5。数字 5 出现 1 次，是奇数，所以答案是No。第二个是十六位左右但所有数字成双成对的情况，比如12345678901234567890，这里 0 到 9 各出现 2 次，答案是Yes，这段测试能验证统计是否正确。第三个是包含0且 0 出现偶数次的情况，比如1001，数字 1 出现 2 次、0 出现 2 次，答案是Yes。

排错时一个很好的策略是：先用你能手算的小样例确认逻辑，再用程序跑大数据样例验证性能。小样例帮你找语义错误，大样例帮你找性能问题，两者缺一不可。

5.4 洛谷提交时的操作细节

在洛谷提交这道题时，语言要选对。C++ 代码选C++17或C++14都可以，Python 代码选Python3。不要选错版本，否则可能出现语法不兼容的报错。

另外，这次提交不用写文件读写，也不需要加什么“防抄袭”的东西，代码越干净越好。不要在程序里输出任何和答案无关的提示文字，比如“请输入数字”之类的，在线评测系统只要看到额外的输出就会判错。如果你平时习惯在本地调试时打印一大堆中间变量，提交前一定要清理干净。

6. 题目之外的扩展：这类“字符串处理大数”还能怎么考

6.1 从统计频次到高精度运算

B3850 只用了“字符串存储大数”这一层，并没有真的对大数做计算。但同类型的大数题，下一步往往就是高精度加减乘除。

高精度加法的核心思想，是把两个数字字符串从低位到高位逐位相加，同时维护一个进位 carry。比如计算123456789 + 987654321，模仿小学列竖式的过程，逐位相加并进位。高精度乘法稍微复杂一点，需要双重循环模拟每一位相乘，再用数组累加结果，最后统一处理进位。

做好了 B3850，你对“字符串逐位处理”已经有了感觉，再学高精度会比较顺利。建议可以去洛谷找几道高精度模板题练手，比如经典的大整数加法、大整数乘法，很多都是 B 开头的送分题。

6.2 从判断一个数到统计 1 到 n 有多少个幸运数

如果题目换个问法：给定一个可能很大的 n，问从 1 到 n 中有多少个幸运数，那就不是单纯遍历能解决的了。因为 n 的位数可能高达 (10^5) 甚至 (10^6)，根本不可能从 1 数到 n。

这种题一般要上“数位 DP”。数位 DP 的核心思路是按位处理，利用记忆化搜索统计满足条件的数字个数，避免逐个枚举。状态里常需要记录已经选过的位数、当前是否顶到上界、以及当前各位数字出现次数的奇偶状态。因为“每个数字出现次数是否为偶数”可以用一个 10 位二进制状态表示，正好对应 GESP 七级、八级可能出现的进阶考点。

B3850 是数位 DP 的一个极简前奏。你现在把它做明白，未来看到“统计幸运数个数”这类题时，就不会对状态压缩和 DFS 感到陌生。

6.3 大数与字符串算法的交汇

再往远处看，字符串处理大数还会和各种字符串算法结合。比如你需要快速判断一个超长数字子串的某一段数字和是否为偶数，可能会用前缀和。如果你需要在大数字字符串中查找某个模式，可能用到 KMP 算法。如果你需要对若干个大数字字符串进行排序，可能需要写一个字符串比较函数，而不是整数比较。

这些知识点会随着等级提升逐渐出现。但无论题目怎么变，“用字符串承载大数”这个意识始终贯穿。拿到任何大数相关题目，先问自己三个问题：这个数我需要计算吗？计算复杂吗？能不能只靠遍历字符串就完成？把这三个问题想清楚，解题方向就不会跑偏。

我个人在实际操作中的体会是，这种“纸老虎”型题目最考验基本功。你在洛谷上刷题，不用总盯着难题怪题，像 B3850 这样简单的四级题，反而最有复盘价值。它提醒我，读题时不要被“大数”“高精度”这种词汇吓住，而是先弄清楚输入是什么类型、输出要什么结果、数据范围暗示了哪种做法。

最后再分享一个小技巧：把同一道题分别用 C++ 和 Python 写一遍。C++ 版本能帮你理解数据的底层存储和字符转换，Python 版本能帮你快速验证逻辑。两者对照着看，你对字符串处理的理解会比只刷单一语言深得多。做完 B3850，再顺手找几道洛谷上的高精度和字符串入门题练一遍，这个专题就算真正吃透了。