GX 2026 CSP-S迷惑行为大赏
hangxiaopa · · 生活·游记
GX 2026 CSP-S 迷惑行为大赏
注:本篇文章使用AI生成并由人类润色(确信),如果违规将删除文章。
数据来源:2026 年广西 CSP-S 选手代码备份,共 588 个选手文件夹、1882 份
.cpp、79219 行代码。这些代码加起来 101.76 MB——其中 100 MB 来自同一个人。本文只使用选手编号
GX-Sxxxxx,不出现真实姓名;所有代码均为原文照录,错别字、乱码、拼音一个不改。纯属娱乐,如被冒犯——恭喜你,你已经被收录进广西 OI 的赛博博物馆了。
〇、先看几组数字
| 项目 | 数量 |
|---|---|
| 提交文件夹 | 588 |
| 源代码文件 | 1882 份 / 79219 行 |
| 四题全交 / 交三题 / 交两题 / 交一题 / 一题没交 | 337 / 91 / 104 / 49 / 5 |
| 各题提交数 crystal : subway : migrate : hub | 578 : 496 : 449 : 350 |
| 0 字节源码 / 1 字节源码 | 9 / 25 |
保存官方样例答案(.ans) |
9 人,共 179 份(下发的完整样例是 22 份) |
| 把样例答案硬编码进代码 | 35 人 |
| 同一份代码交多个题 | 25 人 |
| 跨选手完全相同的代码 | 9 组 |
全篇没有带文件名的 freopen |
136 份 |
freopen 写的是别的题的文件名 |
42 份 |
freopen 文件名/模式写错(本题) |
23 份 |
编译产物(可执行文件 / .o) |
18 个 / 17 个 |
| 全部代码体积 | 101.76 MB(其中 100 MB 属于同一位选手) |
顺便说明一下:今年四题的英文名是 crystal(水晶)、hub(枢纽)、migrate(迁徙)、subway(地铁)。记住这四个单词——因为后面你会发现,选手们对它们的拼写有着无限的可能性。
一、文件格式篇:把"提交"当成"上传附件"
先看最朴素的一类迷惑行为:不交代码。
1. 一个换行符也是代码
GX-S00364 选手四道题全部提交,四个文件整齐划一,每个都是 1 字节——内容是一个换行符。
$ wc -c GX-S00364/*/*.cpp
1 crystal/crystal.cpp
1 hub/hub.cpp
1 migrate/migrate.cpp
1 subway/subway.cpp
一手交白卷,一手交四份白卷。这种"整齐"已经超越了摆烂,达到了行为艺术的完成度。
比 1 字节更极端的还有 9 份 0 字节源码。其中 GX-S00362 选手的 hub 和 migrate 都是 0 字节,而 GX-S00588 选手连 generator.cpp 都是 0 字节——对拍程序的后端都没写,只有造数据的前端。
2. 三行以内的"代码"
GX-S00517/hub/hub.cpp,全文如下,共 8 字节:
#FFFFFF
对,一个十六进制色值。它甚至不是能跑的东西,但它确实被存成了 hub.cpp。我们合理推测,这位选手在比赛最后十分钟想起了自己 CSS 没写。
GX-S00501/hub/hub.cpp 则只有 9 字节:
#include
——连头文件都没选,直接 include 了个寂寞。
GX-S00237/hub/hub.cpp(44 字节)更进一步:
#include<bits/stdc++.h>
using namespace std
没有分号,也没有 main。编译器看完了这段代码,沉默了。
3. 编辑器事故现场
在 588 个文件夹里,我们挖掘出了一整套"文件考古"标本:
GX-S00149/crystal/#crystal.cpp#:Emacs 的自动保存文件,701 字节,比它旁边那份 296 字节的正牌crystal.cpp还长、还完整;GX-S00588/crystal/.crystal.py.swp:Vim 的交换文件。更抽象的是,旁边还躺着一个generator.py,内容是造数据脚本:
n = 1600
m = random.randint(500, 1000)
print(n, m)
for i in range(n):
print(i + 1, end=" ")
考试文件夹里带着数据生成器、带着 vim 交换文件,像是一个小型开发环境被原封不动端上了交卷台。
GX-S00237/crystal/crystal.cpp.save-failed和crystal.cpp.temp:都是 828 字节,同名同大小。文件名直译过来就是——保存失败。连编辑器都在帮他提交失败。
4. 交成别的格式
GX-S00069 选手,四个文件,扩展名全是 .html,内容全是 C++。其中 1.html 是这样的:
#include<dits/stdc++.h>
using namestpase std;
long long n,i,a[10e7];
...
("crystal.in");
("crystal.out");
retern 0 在最后一行等着你。这大概是全场唯一一份"用浏览器打开就能看到自己错误"的提交。
GX-S00020 选手更绝:四道题的源码全都没有扩展名,直接存成了 crystal、hub、migrate、subway。其中 crystal 的内容是:
...
for(int i=1;i<=m;i++){
max()
}
max() 后面什么都没有——这道题在这位选手手里,就停在了这个"max()"。
GX-S00406 选手把目录也改了名:crystal1、hub1、migrate1、subway1,源码同样没有扩展名。其中 hub1/hub 只有 1 字节,而 crystal1/crystal 是:
#<iostream>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
for(int i;i<=n,i++){
}
cout<<'3';
}
#<iostream>、for(..., i++) 用逗号分隔、'3' 是字符而不是数字。五行代码,四个语法错误,一个编译器。
GX-S00045 选手的问题则小得多:他只是把扩展名写成了大写——
GX-S00045/crystal/crystal.CPP
以及,这份文件的内容被整段粘贴了两遍,第一遍的 for(i=1;i>=10) 还没写完,第二遍就接上来了:
#inlin <bits/stdc++.h>
uing namespm std;
int main(){
freopeh("crystal.in","r",stdi);
...
for(i=1;i>=10)#inlin <bits/stdc++.h>
inlin、uing、namespm、freopeh、stdi——五行里五个错,而且他还把这五个错复制了一遍。这份提交值得裱起来。
5. 二进制、目标文件与"半成品"
统计下来,588 个文件夹里躺着 18 个可执行文件和 17 个 .o 目标文件。
GX-S00057选手的 crystal、hub、subway 三题都是"可执行文件 +.o"二件套,只有 migrate 剩了一个孤零零的.o;GX-S00139和GX-S00554的提交里只有.o,没有对应的可执行文件——编译了,但没有链接;GX-S00194选手的crystal可执行文件本体也一起交上来了;GX-S00013选手四题里 crystal、migrate、subway 交的都是 ELF 可执行文件,只有 hub 留了一份 304 字节的源码;GX-S00126选手四道题各交了一份可执行文件,外加.o、源码和全套 22 份样例答案——一个文件夹塞下了一个小型机房的全部产物;GX-S00514选手留下了一个名叫migrete的可执行文件。目录叫 migrate,源码叫 migrate,只有编译出来的这个二进制悄悄拼错了一个字母。
文件夹里同时存在"源码、可执行文件、.o、样例答案"的情况并不少见,恍惚间你会以为自己在看某位选手的桌面。
6. 目录名:crystal 的一百种写法
crystal 这个词,在这份数据里有如下变体:
| 写法 | 出处 |
|---|---|
crtystal |
GX-S00158 的目录名 |
crytal |
GX-S00103 的文件名、GX-S00440 的 freopen、GX-S00385 的目录名 |
subwsy |
GX-S00014 的目录名、文件名、freopen 三连错 |
hud |
GX-S00103、GX-S00437 把 hub 写成了 hud |
migarte |
GX-S00256 的目录名 |
stubway |
GX-S00473 的目录名与文件名 |
hug.cpp |
GX-S00005 注释里的神来之笔 |
还有 GX-S00087 选手,整个提交文件夹套了一层同名目录:GX-S00087/GX-S00087/crystal/crystal.cpp。交卷之前,他大概是把压缩包解压到了压缩包里面。
GX-S00411 选手的 crystal 目录里有一个名叫 Cancel 的文件(100 字节),内容是一份完整的 a+b 程序:
#include<iostream>
using namespace std;
int main(){
int a,s;
cin>>a>>s;
cout<<a+s;
}
文件名 Cancel——这不是文件名,这是这位选手对这道题最后的表态。
7. 放错抽屉的代码
GX-S00025:hub目录里放的是crystal.cpp;GX-S00160:subway目录里放的是crystal.cpp;GX-S00441:hub和subway目录里都是crystal.cpp,而且是同一份写着n%2的代码:
cin>>n>>m;
if(n%2==1){
cout<<(n+1)/2;
}
GX-S00366:hub和migrate目录里都放着一份subway.cpp,打开一看是完整的最短路代码,freopen("subway.in")写得明明白白。
在 CSP 的文件夹结构里,这相当于把语文卷子塞进了数学答题卡。
二、freopen 篇:文件名是这座城市的咒语
CSP-S 是文件 IO,写错文件名等于零分。统计显示,有 136 份代码里连一行带文件名的 freopen 都没有,另有 42 份代码在 freopen 里写的是别人的题。
1. 模式参数:不是 "r" 就是别的什么
GX-S00002 选手,四道题,八次 freopen,模式参数全部写成 "in" 和 "out":
freopen("crystal.in","in",stdin);
freopen("crystal.out","out",stdout);
fopen 只认 "r"、"w"、"a","in" 会返回空指针。也就是说,这位选手的八个文件一次都没被打开过,程序从头到尾都在读空气。
GX-S00411 选手是另一种思路——把读写模式互换:
freopen("crystal.in","w",stdin);
freopen("crystal.out","r",stdout);
先把输入文件"写"开,再把输出文件"读"开。这一步做完,cin 和 cout 都失去了存在的意义。
GX-S00515 选手则把抽象推到了新的高度,四道题(除了 crystal)全部如此:
freopen("radam","w",stdin);
freopen("radam","r",stdout);
文件名 radam(大概是 random 打歪了),模式 "w" 开 stdin、"r" 开 stdout,同一个文件既读又写。两行代码,零个正确的参数。
GX-S00256 选手的 crystal.cpp 则连参数之间的逗号都省了:
freopen("crystal.in" "r" "stdin");
freopen("crtstal.out" "w" "stdout");
C++ 会把相邻的字符串字面量自动拼接,于是这行等价于 freopen("crystal.inrstdin")——传进去的只有一个参数,一个不存在的文件名。
GX-S00224 选手把标准流当成了文件名,四道题八行 freopen 全部写成 std.in / std.out:
freopen("hub.in","r",std.in);
freopen("hub.out","w",std.out);
GX-S00267 选手只错了一个字符:freopen("migrate,out","w",stdout)——点写成了逗号。GX-S00291 选手用的是 fstream,并且把文件名删到只剩后缀:
input.open(".in",ios_base::in);
output.open(".out",ios_base::out);
还有一批选手选择把输入文件当输出文件打开:
freopen("crystal.in","r",stdin);
freopen("crystal.in","w",stdout);
GX-S00236、GX-S00307、GX-S00148 都在各自四道题的代码里写了这两行。程序启动的第一件事,就是把自己的输入文件清成 0 字节。
2. 张冠李戴
这是最高发的一类。下面每一行都是真实存在的:
// GX-S00005/migrate:题是 migrate,文件是 hub
freopen("hub.in","r",stdin);
freopen("hub.out","w",stdout);
// GX-S00197/subway:题是 subway,文件是 migrate
freopen("migrate.in","r",stdin);
freopen("migrate.out","w",stdout);
// GX-S00049/hub:文件名前面的部分被吃掉了
freopen(".in","r",stdin);
freopen(".out","w",stdout);
// GX-S00416/hub:没有扩展名,还顺便把同一个文件读一遍写一遍
freopen("hub","r",stdin);
freopen("hub","w",stdout);
// GX-S00440/hub:点被吞了
freopen("hubin","r",stdin);
freopen("hubout","w",stdout);
// GX-S00256/migarte:三道题全部指向 crystal,而且 crystal 拼成了 crtstal
freopen("crystal.in","r",stdin);
freopen("crtstal.out","w",stdout);
GX-S00256 那份尤其值得一看:hub.cpp、migrate.cpp、subway.cpp 三个文件里躺着一模一样的两行 freopen,都指向 crystal.in 和 crtstal.out。三题联保,一个文件。
GX-S00111 选手更有想法:crystal 题里写 freopen("crystal3.in"),migrate 题里写 freopen("crystal4.in")。他大概以为文件名里带个 3 和 4 就能对上下发的测试点——可惜评测机不按这个逻辑来。
3. 连 freopen 都没写
136 份代码里连一行带文件名的 freopen 都没有。其中大部分是空壳,但也有完整实现了算法、只是从头到尾不知道要文件 IO 的:
GX-S00261 选手就是这样一个例子。他的 hub.cpp、migrate.cpp、subway.cpp 三份文件完全相同,内容是……crystal 的解法:
cin>>n>>m;
for(int i=1;i<=n;i++){
cin>>a[i];
}
sort(a+1,a+n+1);
sum=n/2;
没有 freopen,没有文件 IO,没有正确的题,但有排序。三题同悲。
三、样例答案篇:题面是最好的外挂
接下来是全场的核心节目。
组委会在题面里给了样例输入输出,本意是让你调试。但有 35 位选手选择把样例输出直接写进代码里。更精确地说:下发的样例答案,在这份数据里成了一份被反复默写的经文。
1. 12251:hub 第五个样例的诅咒
hub 这道题,hub5.ans 的内容只有一行:12251。
于是 12251 这个数字,在 25 份提交里反复出现,每一份都有不同的包装:
// GX-S00001:来一组输出一组
while(t--)cout<<12251<<endl;
// GX-S00006:不读了,直接给
cout<<12251;
// GX-S00175:这次它是个字符串
cout<<"12251";
// GX-S00084:还给个条件,显得很严谨
else if(x==0&&y==1)cout<<12251;
// GX-S00107
else cout<<12251;
// GX-S00344:c==0 说明这是样例,t==1 说明是第五个样例
if(c==0 && t==1)cout<<12251;
// GX-S00400:把输入特征写全了
if(t== 1&&n== 99999 && k==1000){cout<<12251;}
注意最后两份的写法:他们不是随便乱猜,而是先读过样例、再逆推出样例的输入特征。c==0 && t==1,编号 0 表示样例、t 是这个样例文件里的数据组数。这已经不是骗分了,这是逆向工程。
2. 259997:migrate 第四个样例的背诵课文
migrate 的第 4 个样例输出是 12 行:
0
0
259997
259995
86669
0
0
0
7
5
5
0
这份答案在 9 位选手的代码里被完整抄了下来,比如 GX-S00192:
else if (a == 0 && b == 12) fout << "0\n0\n259997\n259995\n86669\n0\n0\n0\n7\n5\n5\n0";
a 是 c(测试点编号)、b 是 t(数据组数),a==0 是样例,b==12 正好对上样例 4 的 12 个输出。GX-S00210 的写法同样简洁:
else if(t==12){cout<<0<<endl<<0<<endl<<259997<<endl<<259995<<endl<<86669<<endl<<0<<endl<<0<<endl<<0<<endl<<7<<endl<<5<<endl<<5<<endl<<0;}
而 GX-S00019 甚至把 migrate 的全部 6 个样例答案都默写进了 if-else,连输入特征一起,像背课文一样一句不落:
if(b==2&&c==4&&d==2)
{
cout<<1<<endl<<2;
}
else if(b==2&&c==5&&d==3)
...
else if(b==12&&c==260000&&d==1)
{
cout<<0<<endl<<0<<endl<<259997<<endl<<259995<<endl<<86669<<endl<<0<<endl<<0<<endl<<0<<endl<<7<<endl<<5<<endl<<5<<endl<<0;
}
如果你是从头读到这里的,你应该已经发现:这位选手把样例的输入特征也一起背下来了。b==12&&c==260000&&d==1,三个数全对得上。考场上,他用不到 1 KB 的代码,把一个题的部分分固定成了"只有样例能过"。
3. 当样例答案写不完:/n 与 2000 行打表
subway 的第 3 个样例有 200 行输出。这就产生了一个技术难题:200 个数怎么塞进代码里?
GX-S00262 选手的方案是——全部塞进去,用 '/n' 分隔:
cout << 341 << '/n' << 667 << '/n' << 1255 << '/n' << 775 << '/n' << ...
'/n' 是多字符字面量,不等于 '\n'。这 200 个数字确实被输出了,但它们会挤在同一行里,中间夹着一堆不可名状的字节。也就是说,这位选手既正确地背下了 200 个答案,又用 200 个错误的换行把它们全部毁掉了。
同样的 200 行答案还出现在 GX-S00398、GX-S00422、GX-S00447 等选手的程序里。而 GX-S00222 选手选择了最朴实的方式:把两千多行「数字 << '\n' <<」一行行敲进 subway.cpp,文件 30943 字节,是全场最大的"合法"提交之一。
4. 直接把样例答案写成一个函数
GX-S00164 选手的解法优雅到令人心碎——crystal 第二个样例答案是 4,于是他写:
#define AC return 0
inline void LI()
{
cout<<4;
}
int main()
{
...
int t=1;
while(t--)
LI();
AC;//rp+=INF
}
一个名叫 LI 的函数,唯一的作用是输出 4;AC 是一个宏,展开后是 return 0;AC 后面还跟着一句 //rp+=INF。全程序共 355 字节,实现了 100% 的样例通过率和 0% 的题解含量。
5. 100 MB 的 'p':一个人的行为艺术
GX-S00005/hub/hub.cpp 大小 100,001,146 字节,是整个数据集里最重的文件。
它的程序部分是这样的:
#include<bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
freopen("hub.in","r",stdin);
freopen("hub.out","w",stdout);
while(1)cout << 'p';
return 0;
}
while(1) cout << 'p';——无限输出字母 p。然后他在文件末尾开了一个注释,在里面写了:
0>=T1>100,T2==T3==T4==0
我一轮是运出来的,So QU GOD is came
I'm 在J组T4打了100万个p的[数据删除]
Now,I also wrote down 《忘情牛肉面》 & 100 million of p!!!
我可以装作无所谓地离开
到没有你的地方我再崩溃
...
接下来,是 99,997,513 个字母 p,一行一行,一直铺到第 2545 行,最后用一个 */ 收尾。
而在注释的中间,他还夹了一段"反向代码"——
#include<bits/sdtc++>
#include<bits\sdtc++.h>
#include<bit/sdtc++.h>
use namespaces sdt;
int mian(){
feropen("hug.cpp",'w',sdtin);
freeopen("hug.cpp",'r',sdtout);
int a,b;
cin << a << b;
cout >> a += b;
rteurn 0;
]
mian、feropen、sdtin、sdtout、cin <<、cout >>、rteurn、结尾一个 ]——这段代码把 C++ 的每一个关键字都故意写错了一遍。
同一位选手的 migrate.cpp 里,freopen 写的是 hub.in,程序依旧是 while(1)cout << 'p';,注释里则是一副用 11、[[]]、'兵' 拼出来的中国象棋棋盘:
11车 11马 11相 11士 11将 11士 11相 11马 11车
...
-----------------------------------------//(楚河汉界)
...
'车' '马' '相' '士' '帅''士' '相' '马' '车'
死者:
"快来看我的雷霆猪爆球塞T4吧",这是他在注释第一行留下的邀请函。我们看了,我们确实看了。
6. 3001 行 kskbl
如果说 100 MB 那位是规模冠军,GX-S00518 选手就是耐心冠军。他的 hub.cpp 有 3008 行、264182 字节,主体是 3001 行一模一样的代码:
cout<<'k'<<'s'<<'k'<<'b'<<'l'<<'z'<<'d'<<'j'<<'d'<<'w'<<'k'<<'z'<<'k'<<'b'<<'l'<<endl;
kskblzdjdwkzkbl,重复 3001 次。全文件只有 freopen("hub.out","w",stdout),连输入都不读。这份提交唯一的产出,是一个包含 3001 行乱码的 hub.out。
7. 骗分的自我修养
GX-S00272/hub/hub.cpp 是全数据集中最坦白的一份代码,因为它把动机直接写进了注释:
if(C==0) { //make table to pass all the example......
vector<int> ans;
if(T==2) {
ans = {1, 2};
} else if(T==3) {
ans = {1, 1, 2};
} else if(T==5&&A==602) {
ans = {17, 9, 6, 6, 9};
} else if(T==1&&A==99999) {
ans = {12251};
}
...
} else {
while(T--) cout<<1<<'\n';
}
"make table to pass all the example......"——打表以通过所有样例。而这位选手的 crystal.cpp 里还留着一句:
// why I WA on example4? I cant understand.
一边打表一边求解,一边求解一边 WA,最后把疑问留在注释里。这就是 2026 年的 OI。
GX-S00199/crystal/crystal.cpp 的思路更进一步——直接把样例输入当成字符串来比对:
int n;
cin >> n;
if (n == "5 5 1 2 4 8 9") {
cout << 3;
}
else if (n=="5 8 -3 -1 2 2 7") {
cout << 4;
}
else{
cout << 3845;
cout << 315275;
}
cin 读进一个 int,然后拿去和一个字符串字面量比较。这段代码连编译都过不了,但它完整表达了作者的骗分哲学:"只要样例看起来像这串字符串,那它就得输出 3。" 顺带一提,else 分支里两个数字之间没有换行——如果它能编译,输出会把它们粘成 3845315275。
GX-S00321/hub/hub.cpp 则尝试了一条更激进的路——直接读答案文件:
switch(c){
case 1:freopen("hub1.ans","r",stdin);
case 2:freopen("hub2.ans","r",stdin);
...
case 10:freopen("hub10.ans","r",stdin);
case 11:freopen("hub.ans","r",stdin);
...
}
freopen("hub.out","w",stdout);
for(int i=0;i<t;i++){
long long num;
cin >> num;
cout << num << endl;
}
按测试点编号把 stdin 接到 hub1.ans …… hub.ans,再把读到的东西原样输出——这是一段"把下发答案文件当输入抄"的代码。整段 switch 没有一个 break,case 一路穿透到 20。它唯一的问题是:评测时目录里根本没有这些 .ans 文件。
GX-S00120/hub/hub.cpp 连算术都写进了源码:
55115+71365=126480+34864=161344+36710=225054
if (n == 5 && m == 2) printf ("1\n");
if (n == 10 && m == 3) printf ("2\n");
...
if (n == 71365 && m == 2) printf ("288\n");
if (n == 34864 && m == 2) printf ("229\n");
if (n == 63170 && m == 2) printf ("388\n");
}_
return 0;
}
十五个 if 对应十五个样例答案,中间夹着一行用等号连起来的加法竖式,收尾是 }_。这份代码用行动解释了什么叫"我算给你看"。
GX-S00348/crystal/crystal.cpp 则把测试点数据抄进了注释,连同答案:
//I pass first,second and third test point,but crystal 4 is error,why?
//crystal 4.in(a piece of):500000 19768503
//61 64 18 17 -54 -41 47 83 24 89 -67 -6 -24 -69 26 -41 77 -44 5 21 54......
//that's so large...
//ans:315275
//this code make mistakes when it face a little big test point I don't know why
连 ans 都写好了。差一步,他就能把这道题的答案背进代码里。
四、语法与拼写篇:编译器看完想转行
1. 十行代码,五个错,冠军是它
GX-S00540/migrate/migrate.cpp,全文 11 行,168 字节:
#include <sits/stdc++.h>
using namspace std;
int main(){
//frpopen("migrte.in","r",stdin)
//frpopen("migrte.ans","w",stdout)
int a, b;
cin >> a >> b;
reunu 0;
}
sits/stdc++.h:不存在的头文件;namspace:少了个 e;frpopen:fopen 拼成了 frpopen,而且连注释里都拼错;migrte:migrate 拼成 migrte,而且注释里的freopen没有分号;reunu 0;:return拼成了reunu。
抄一份 freopen 模板能抄出五个错误,还把错误错误地注释掉了。这份代码一次都编译不过,但它完整地呈现了"一个选手从入门到放弃的全过程"。
2. 分号的艺术
GX-S00495/crystal/crystal.cpp 的开头:
freopen("crystal.in";"r";stdin);
freopen("crystal.out";"w";stdout);
freopen 的三个参数之间应该用逗号,他用了分号。编译器在第一个分号处就停下了。
同一个文件的循环更值得品味:
for(int i=1;i>=n;i++){
cin>>x;
x=a[i];
}
for(int j=0;j>=n;j++){//从小到大排序
if(a[j]>=a[j+1]){
a[j]=a[j+1];
a[j+1]=a[j];
i=1; i>=n; i++:条件永远不成立(除非 n≤1),循环体一次都不执行;x=a[i]:把输入读进x之后,又把a[i]的值赋给x——方向反了,输入丢了;a[j]=a[j+1]; a[j+1]=a[j];:这两句效果是把a[j+1]赋给两个位置,交换变成了复制;- 而那个
//从小到大排序的注释,是全场最自信的一行注释。
3. 五处拼写事故的合订本
GX-S00069 的 1.html(就是把代码存成网页的那位):
#include<dits/stdc++.h>
using namestpase std;
long long n,i,a[10e7];
...
("crystal.in");
("crystal.out");
...
retern 0;
dits、namestpase、a[10e7](用浮点数当数组大小)、("crystal.in");(把 freopen 整个丢了,只剩括号)、retern——一份代码集齐五种武器。
4. 其它精品
GX-S00536/hub/hub.cpp 直接输出还没声明的变量:
cout<<bu<<' '<<hui<<' '<<xie<<' '<<QAQ;
bu hui xie QAQ——"不会写 QAQ"。四个变量一个都没定义,编译不过,但意思传达到了。
GX-S00097/crystal/crystal.cpp 和 GX-S00185/crystal/crystal.cpp 的 for 循环条件写成了 i>=1 配上 i++,和上面那位 GX-S00495 组成了"反向循环三兄弟"。其中 GX-S00185 那句尤其工整:
double a[5000000];
...
for(int i=(l+r)/2-1;i>=1;i++){
数组开 500 万个 double 存整数,循环从中间往左走却用 i++,两个错误的组合方式都很有创意。
GX-S00521/subway/subway.cpp(56 字节)大概是"提交事故"的另一个极端——它只写完了全局变量:
#include <iostream>
using namespace std;
int c,n,m,d,q;
没有 main,没有 return,只有一个信念:总有一天我会把这道题写完。
顺带一提,全场只有 GX-S00262 一位选手用 '/n' 代替 '\n'——但他一个人写了 199 次。其余 1881 份代码的换行,都还算正常。
5. 又一批拼写事故
因为实在太多,只能列表展示:
-
GX-S00214/hub/hub.cpp:int main{——main后面的括号不见了,文件最后一行是}m m; -
GX-S00290/crystal/crystal.cpp:#include <bits\Stdc++.h>,反斜杠加大写 S,四道题整套复制; -
GX-S00234/crystal/crystl.cpp:#include<bst/stdc++.h>、fnoing("crystl.in","r",intin)、ronung 0;——整份代码像是键盘被往右推了一格; -
GX-S00314/migrate/migrate.cpp:#intclue<bits/stdc++.h> using namecpace std; int main(); //freopen("migrate.out",'w",stdin); int a=[9999],do[9999],temp[9999];#intclue、namecpace、main只声明不定义、数组用方括号赋值、把关键字do当数组名、freopen的引号一半单一半双。而同一位选手的crystal.cpp更绝,直接把题面的数据范围抄成了循环条件:for(int i=1,1<=i<=5*10^5,0<=m<=10^18,i++){ -
GX-S00344/subway/subway.cpp:#define ll = long long——因为整份代码再也没用过ll,这个宏居然从未被展开,代码顺利编译; -
GX-S00359/crystal/crystal.cpp:for(int i=1;i=m;i++),把比较写成了赋值,循环永不结束; -
GX-S00115/subway/subway.cpp:const int c,n,m,d,q;cin>>c>>n>>m>>d>>q;//m node n wide vector<vector<int>>(d)(m) a; ... for(int i=1;i<=k;k++){const变量直接cin、vector模板参数写成函数调用、循环变量用k++无限自增。三处编译错误之后,这份代码依然乐观地输出了32和17。
五、注释文学篇:考场上,人人都是作者
这是整份数据里最动人的部分。588 个文件夹里,藏着大量的诗、日记、遗书(AFO 声明)、表情包和脏话。
1. 日记体
GX-S00062 选手的四份代码里,注释全部带时间戳,像一份实时战报:
//中国计算机协会我爱您。您可否乐意给予我更多的得分呢?
...
贪心……贪心? -10/31 14:40
双指针? -10/31 15:20
对了,就是双指针!俺寻思俺可以拿下100pts。 -10/31 15:30
//这里存在着至少998244353个滚木。
...
连通块还没学。空悲切! -10/31 17:24
早知道我就吃午饭了! -10/31 17:29
最小的最大长得很像二分耶(思考ing)。 -10/31 17:35
...
//场上结算:100+50+8+0=158.
//中国计算机协会我爱您。您可否乐意给予我更多的得分呢?
...
头晕。感觉发烧了。 -10/31 16:53
洛谷用户DY0601,膜拜大佬%%% -10/31 16:58
预估分数8pts -10/31 17:19
线段树? -10/31 17:21
从 14:40 的"我觉得我能 100 分",到 16:53 的"头晕,感觉发烧了",再到 17:19 的"预估 8 分",最后是"场上结算:100+50+8+0=158"。
这几段注释如果被打印出来,可以当一篇非虚构文学发表。
2. 英文遗书
GX-S00009/hub/hub.cpp 的代码部分只有 freopen 和一个 return 0,剩下的全是注释:
/*
Forgive me if there are grammar errors.
...
This is the first time I write this kind of thing, and the last time -- I'm Senior Two this year.
I didn't get a good mark last year and was persuaded to go back for gaokao.
...
Maybe it's because I'm too lazy to do everything.
Or maybe my original purpose of learning C++ is to avoid being in classroom.
...
It's about to ending, in all meanings.
Good luck & Goodbye!
*/
这位选手把 hub 交成了一份 AFO 声明。二十多行英文,除了 It's about to ending 这个小瑕疵,比他的代码流畅得多。
3. 拼音体
GX-S00180/subway/subway.cpp 的结尾:
/*This is Pingyin
* zheshiwozuihouyicicanjiaCSPle(keneng,wode whk binbu good danwoyijiureaizheOI,...
* ...
* huoxvxiezhiyiqieyebuguoshiweileshangyici GX-CSP-S mihuoxingweidashang,yesuanyingzhenglewodeaimuxvrong
*/
翻译过来是:"这是我最后一次参加 CSP 了(可能),我的 whk 并不 good,但我依旧热爱着 OI……或许写这一切也不过是为了上一次 GX-CSP-S 迷惑行为大赏,也算应征了我的爱慕虚荣。"
——这位选手在考场上就把投稿理由写好了。 所以本篇文章决定把这句话放在这里,作为本节的句号。
GX-S00513/crystal/crystal.cpp 则是意识流:
//ziSHUIJIN?!
//huleyigecaixiang,shishi.
//shijiansihudale.
//nule,zenmeyunxing 240.597s.
//wochangchangzhuiyiguoqvshengmingshunjiandinggezainaohai...
以及一整行 939 个字符、没有标点、没有空格的拼音,最后收在:
//henhuang,sihuguobuqvdengchashulienagedian'a......................
//owocao,zuihoudeyige c youwenti!!!
//eixinghao.
"很慌,似乎过不去等差数列那个点啊……哦我操,最后一个 c 有问题!!!呃行吧。"
4. 中二体
GX-S00151/crystal/crystal.cpp:
///回家我要耍起!!!!!!!!!!!!!!!!!!!!!!!
...
真错就给了,但是这次能不能给我一个惊喜啊,如果考了s1我就退休111
同一位选手的 migrate 和 subway 开篇只有一句话:
///燃尽了啊
"燃尽了啊",四个字,抵得上一篇题解。
5. 硬核吐槽体
GX-S00072/subway/subway.cpp:
// 贪心 第i个站台的最优应是前一位加上这一位的最小数值,可是上一位最优的路线不一定与这
// 一位的最小值在同一条轨道上,需要把两条路线的差补上而且可能上一条最有的路线与目前最小
// 值位置连接不起来 (终于找到切换输入法了!!!)
//-----------------硬模屎山代码---------------
三行严肃的算法分析之后,括号里那句"(终于找到切换输入法了!!!)"是全场最有生活气息的一行代码。
GX-S00548/hub/hub.cpp 则是纯粹的怨念,循环 100001 次输出同一句话:
for(int i=0;i<=100000;i++){
cout<<"I hate this question too. QwQ\n";
}
同一份文件夹里的 subway.cpp 写的是 I hate this question. QwQ(没有 too)。hub 更恨一点。
GX-S00427/hub/hub.cpp 的整个程序逻辑就是:
cout<<"RP++,goodbye,OI.";
6. 把题面抄进代码里
GX-S00504/subway/subway.cpp 的程序之后,附了一份完整的题面:
/*
文件 subway.in 中读入数据。
输入的第一行包含五个非负整数 c, n, m, d, q,分别表示测试点编号、地铁线路数、
地铁站数、每个地铁站最多被几条线路经过,以及出行计划数。特别地,若 c = 0,则
该测试点为样例。
...
输入的第 r + n + 2 (1 ≤ r ≤ q) 行包含两个正整数 x r , y r ,分别表示第 r 个出行计
划的起点和终点所在的地铁站编号。
*/
注释抄得一字不差,连排版换行都保留了。可惜代码部分只有一句 cout << 1 << "\n";。
7. 宏定义体
GX-S00257:#define QAQ return 0,然后在文件结尾连续写了 32 个QAQ;——空代码也要有排面:QAQ; QAQ; QAQ; // 此处省略 29 行 QAQ;GX-S00164:#define AC return 0,AC;//rp+=INF;GX-S00382:#define qwq Ff472130,四个题都定义了这个宏,但只有 crystal 真的用了一次;GX-S00015:// #define LOCAL_TEST CSP2026_RP++——一个被注释掉的宏,宏体是合法的CSP2026_RP++表达式。
8. 四封短信
GX-S00306/subway/subway.cpp 在 return 0 后面留了一份英文墓志铭:
/*
*Maybe it's the worst fail in my whole life.Now I have abandoned it
*becouse of my low knowledge level.I have regreted a lot about it.
*I blieve that I will do it again if i have enough time.And I wish
*that's true.I love myself forever.
* sinCe
* 31 Oct. 2026
*/
拼错了三个词(becouse、regreted、blieve),把落款写成了 sinCe,但日期是准确的:2026 年 10 月 31 日,CSP-S 第二轮的日子。这是全场唯一一份自带墓志铭的代码。
GX-S00227/crystal/crystal.cpp 的短信只有一行,写在 freopen 之后:
freopen("crystal.in","r",stdin);
freopen("crystal.out","w",stdout);
// my s write wrong so my time -30min
"s 写错了,时间 -30min。" 这大概是全场最平静的一次崩溃。
GX-S00277/subway/subway.cpp 则给评测机递了一张请假条(全文 205 字节):
int main(){
freopen("subway.in","r",stdin);
freopen("subway.out","w",stdout);
cout<<"I don't have enough time to finish this work";
return 0;
}
freopen 一丝不苟,态度诚恳,就是没有算法。
还有一条更短的消息,写在两个不同题目的文件里。GX-S00343/crystal/crystal.cpp 是一份写完了的正解,末尾两行是:
// finished at 14:57
// To wyx: I love you
而 GX-S00343/hub/hub.cpp 的最后一行是:
// wyx,I love u
第一题写完了,后面三题没有了。短信写到这里,就变成了告别。
六、玄学与数字迷信篇
1. 时间是最好的随机种子
全场 12 份代码使用了 srand(来自 8 位选手),13 份代码调用了 rand()(来自 9 位选手),其中相当一部分是 srand(time(0))。还有 3 份代码使用了 clock(),不过都只是注释掉的计时器,属于"我不是玄学,我只是没删"。
2. 114514 家族
数字迷信是 OI 圈的基本盘。下面这些变量名/数组/常量都是真实存在:
int a[11451419]; // GX-S00083
long long g[1145][1145]; // GX-S00083,g[k][k+514]
const int maxn = 5*114514; // GX-S00529
int minn=11451419198102333ll; // GX-S00146
ll ans = 1145141919810114514; // GX-S00451
long long m,maxx=-114514,minn=1145141919810; // GX-S00367
int a[1145141], sum[1145141]; // GX-S00146
vector<int>awsl; // GX-S00146
GX-S00146 选手尤其有爱:用 awsl 当数组名,用 11451419198102333ll 当 INF,一个文件里三种梗。
3. 玄学输出
GX-S00279/migrate/migrate.cpp:
int id = rd(),T = rd();
if (id == 114514) cout << "yuanshen fenchang nb";
输入的第一个数是被当作"测试点编号"的。这位选手大概以为评测机会给一个 114514 号测试点,于是他提前打好了招呼:"原神分场 nb"。
GX-S00217/subway/subway.cpp 的做法更守规矩:把 subway 第三个样例的 200 个答案一行行写成 200 个 cout,其中恰好有一行是 cout<<666<<endl;——全场最吉利的一个答案。
GX-S00019 选手在"猜不中"时的处理方式,则是本章的 TOP1:
else
{
while(true)
{
cout<<"666you are laomushi wode yupan juran bushi nide ceshidian?!"<<endl;
}
}
翻译:"666 你是老木虱,我的预案居然不是你的测试点?!"。猜不中样例就死循环输出问题,这位选手把"骗分失败"表演成了一场对话。
他的 subway 版本更狠:
cout<<"wo bu gen ni men wan le"<<endl;
cout<<"666 hou mian de yang li shu chu tai duo le lan de chao le,zhe qun lao mu shi de gao zhe me duo yang li shu chu jiu shi wei le bu gei wo men xie zhe mo duo de if else";
"我不跟你们玩了。666 后面样例输出太多了懒得抄了,这群老木虱搞这么多样例输出就是为了不给我们写这么多 if else。"
这段话说出了 35 位硬编码选手的共同心声。
4. 自己钦定测试点编号
GX-S00117/migrate/migrate.cpp 读完输入后的第一件事,是把测试点编号改掉:
cin>>c>>t;
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
c=11;
测试点编号归你,跑哪一档归我。那排感叹号就是全部的底气。
5. 许愿与咒语
GX-S00259/subway/subway.cpp 在 Floyd 三重循环中间用拼音许愿:
for ( int l = 1; l <= n; l++) for ( int i = 1; i <= n; i++) for ( int j = 1; j <= n; j++){//fah
dis[i][j] = min( dis[i][j], dis[i][l] + dis[l][j] );
// zhe shi ge fu za du hen gao de san chong xun huan, fu za du shi O(n^3), xi wang bu yao TLE, wo zhen mei zhao le
}
"这是一个复杂度很高的三重循环,复杂度是 O(n³),希望不要 TLE,我真没招了。" 许愿是 OI 圈最古老、也最没有用的优化。
GX-S00242/subway/subway.cpp 的答案则是一句咒语:
cout<<"KSKBL ZDJD WKZKBL";
KSKBL 正好也是 GX-S00518 那 3001 行 cout<<'k'<<'s'<<'k'<<'b'<<'l' 的开头。两位选手在同一天、不同的考场,用同一串字母交了两份不会得分的答案。
七、逻辑与算法篇:正确性是最后一步
这一节收录那些"算法写了,但写的是别的算法"的选手。
1. 堆的用法:从堆顶取一个比预算还大的
GX-S00237/crystal/crystal.cpp 用优先队列做了一个贪心,核心循环是:
while(m){
int f=cha_min.top();
cha_min.pop();
if(f>=m){
m=m-f;
res++;
}
if(cha_min.empty()){
break;
}
}
条件 f>=m 的意思是"当前花销不小于剩余预算时才买"——正常人的写法应该是 f<=m。于是这个循环要么一个都取不到,要么把 m 减成负数。而这份代码的文件名是 crystal.cpp.save-failed,另一份同内容的 crystal.cpp.temp 也在旁边。整份提交连"保存成功"都没做到。
2. 无限调用一个文本文件
GX-S00251/hub/hub.cpp:
while(1){
system("gunmu.txt");system("gunmu.txt");system("gunmu.txt");system("gunmu.txt");system("gunmu.txt");system("gunmu.txt");
}
system() 用来执行程序,而 gunmu.txt 是一个文本文件。六个 system 排成一行塞进死循环,试图让操作系统反复执行一个 txt。这个程序在评测机上只有两种结局:TLE,或者被沙箱踢出去。
3. 变量名全错,但样例居然对上了
GX-S00222/migrate/migrate.cpp 读取输入的方式是:
int c, n, t;
cin >> c >> n >> t;
if(t == 4){cout << 1 << '\n' << 2;}
if(t == 5){cout << 0 << '\n' << 1;}
if(n == 17){cout << 8129 << '\n' << ...}
migrate 的输入是 c t 两个数,第一位是测试点编号,第二位是数据组数。这份代码读了三个数,把第三个变量命名为 t,然后拿它去和 4、5 比。按官方格式,第三个读到的数其实是第一组数据的 n——变量名和输入位置全错,但偏偏在样例上能对上。这是典型的“我看样例长得像这样,所以我这么写”。
4. 用循环次数当答案
GX-S00416/hub/hub.cpp:
if(n<5){
for(int i=0;i<=n;i++){
ans++;
}
for(int i=0;i<=k;i++){
f++;
}
}
cout<<ans<<endl<<f;
ans 和 f 分别是 n+1 和 k+1。没有图,没有树,没有 DFS,只有两个从 0 数到 n/k 的循环,然后把数出来的结果当答案交上去。这是全场最诚实的"计数"选手。
5. 递归建树,但结果被覆盖
GX-S00046/hub/hub.cpp 手写了一个树结构:
Tree* find_create(int i) {
if (i == id) return this;
Tree* result = nullptr;
for (Tree* t : child) {
result = t->find_create(i);
}
if (result == nullptr) {
result = new tree(i);
this->child.push_back(result);
}
return result;
}
循环里 result 被反复覆盖,最后一个孩子的返回值说了算——即使前面已经找到了。这段代码如果放进数据结构作业,助教会让你重写;放进 CSP 文件夹,它就是一件展品。而它的主函数最后输出的是:
cout << k - 1 << endl;
6. 按测试点编号特判,是门手艺
GX-S00062/hub/hub.cpp 拿到输入后先看 c:
c=read();t=read();
if(c==13||c==14){
while(t--){
n=read();k=read();
for(i128 i=1;i<n;i++){read();read();}
if(k>n-2){write(0);putchar('\n');continue;}
}
return 0;
}
c 是测试点编号,13、14 号点的性质是 k 大到答案必为 0,于是他直接跳过计算。这已经不是迷惑行为了,这是合法的、非常聪明的骗分——我们把它放在这里,是因为它和上一节那 35 位抄样例的选手一起,构成了这个赛场最真实的两端。
反例是 GX-S00417/hub/migrate.cpp:它在 i 循环里写了 a[i+2],
for (int j = i+1; j <= n; j++)
{
if (a[i+1] - a[i] < d && a[i+2] - a[i+1] < d && a[i+2] - a[i] < d && fff(i, j))
ans++;
}
当 i = n-1 时 a[n+1] 已经出了有效范围,而 fff 里又是一重 O(n) 的循环——外层 O(n²) 的枚举套着它,复杂度直接拉满到 O(n³)。
7. 同一段 if 写了两遍
GX-S00262/subway/subway.cpp 的第 10 行和第 21 行,是一模一样的两段:
if (c == 0 && n == 3 && m == 7 && d == 20 && q == 2)
{
cout << 35 << endl;
cout << 16 << endl;
return 0;
}
中间隔着一段同样巨大的样例答案字符串。第一段后面跟着 return 0,所以第二段永远走不到。这属于:写的时候怕漏,就复制一遍;复制完之后自己也忘了删。
8. 比较器写成小于等于
GX-S00004/crystal/crystal.cpp:
bool cmp(ll x,ll y)
{
return x<=y;
}
std::sort 的比较器要求严格弱序,而 x<=y 对相等元素返回 true。这不会让程序崩溃,只会让它的行为进入未定义状态。就为了排个序,他给评测机准备了一份 UB 大礼包。
9. 输出与内存双打
GX-S00313/hub/hub.cpp:
freopen("hub.in","r",stdin);
freopen("hub.out","w",stdout);
while(1){
cout<<"0"<<endl;
malloc(2048);
}
return 0;
每轮输出一个 0,再 malloc(2048) 一次,永不 free——输出和内存两条路一起打爆。同一选手的 subway.cpp 连 0 都懒得输出,只剩一个裸露的 while(1) malloc(2048);。这不是算法,这是对评测机的压力测试。
10. 把 m 当成操作次数
GX-S00325/crystal/crystal.cpp 把题面里的"预算 m"理解成了"要老老实实操作 m 次":
while(m>0)
{
m--;
sort(a+1,a+n+1);
a[1]++;
int e=a[1],r[20],d=1;
...
每轮 m--、sort 一遍整个数组、把最小值 +1。m 但凡上到 1e5,这个循环就要开始烧香;而它连数组都只开了 a[101]。
11. 向评测机预约一块地皮
今年出现了一批"数组开得比题还大"的选手:
long long n,m,a[10000000000005],cnt=0; // GX-S00114/migrate:80 TB
int w[1000005],k[506],a[100006][100006]; // GX-S00024/migrate:约 40 GB
const int N=2000010;
long long t,n,d,x[N],p[N][N],ans,c; // GX-S00205/migrate:约 32 TB
int c,n,m,d,q,wt[100000000005]; // GX-S00166/subway:400 GB
GX-S00114的a[10000000000005]是 10 万亿个long long,按 8 字节算是 80 TB;GX-S00205的p[2000010][2000010]是二维静态数组,约 32 TB,而且全篇一次都没用过;GX-S00024的a[100006][100006]是 100 亿个int,约 40 GB;GX-S00166的wt[100000000005]是 1000 亿个int,约 400 GB,顺带还把freopen的读写模式和流一起写反。
这些数组没有一个能通过编译或通过内存限制,但它们确实表达了同一种朴素的情感:"我不知道题目要什么,但我知道它一定很大。"
还有一份开得不算离谱的:GX-S00343/migrate/migrate.cpp 开了两个 5140 × 5140 的数组,
int cnt[5140][5140],dp[5140][5140]; // dp[i][j] : the shortest distance between i,j cnt[i][j] : the number of shortest panths
各约 105 MB,合计约 210 MB——不算离谱,刚好卡在"能过编译、能 MLE"之间。注释里把 paths 拼成了 panths,而每组数据前只 memset 了 dp,cnt 从头到尾没有清空过:第二组数据开始时,它装的是第一组留下的计数。同一位选手的 subway.cpp 则是另一种比例失调:w[514514] 给 m 留了 5e5 的余量,记录"哪条线路经过哪个站"的 mp/tim/sta 第二维却只有 20005。同一个文件里,站数被当成了两个不同的数量级。
12. 边权是终点编号
GX-S00343/hub/hub.cpp 的 SPFA 写得很规整,只有一行是错的:
for(int i=head[nw];i;i=e[i].nxt){
int u=e[i].to;
if(dist[u]>dist[nw]+e[i].to){
dist[u]=dist[nw]+e[i].to;
e[i].to 是这条边的终点编号,不是边权。于是"最短路"变成了"沿途点编号之和":走到 100 号点要花 100,走到 1 号点只要 1。这个 SPFA 跑得飞快,但它算的是一种谁也不认识的距离。
同一份代码里还有两件小事:bool mp[1145][1145] 只能装下 1144 个点,而 dfs 要对每个候选组合跑 n 次 SPFA;while(t--) 里只清了 arr、mp、vis,head、tot、e 一个都没清——第二组数据会接着第一组数据的图继续 add。
八、颁奖典礼
每年的大赏都要颁奖。以下奖项由笔者评选,评选标准是:离谱、真诚、且不可复现。
| 奖项 | 得主 | 理由 |
|---|---|---|
| 最佳文件格式奖 | GX-S00069 |
把代码存成 .html,用浏览器就能看错 |
| 最小文件奖 | GX-S00364 |
四题各交一个换行符,共 4 字节 |
| 最短源码奖 | GX-S00517 |
#FFFFFF,8 字节 |
| 最大文件奖 | GX-S00005 |
100,001,146 字节,99,997,513 个 p |
| 最具耐心奖 | GX-S00518 |
3001 行 cout<<'k'<<'s'<<'k'<<'b'<<'l' |
| 最佳默写奖 | GX-S00019 |
把 migrate 全部 6 组样例答案连输入特征一起背下来 |
| 最佳坦白奖 | GX-S00272 |
注释写明 make table to pass all the example...... |
| 最佳妄想奖 | GX-S00321 |
想用 freopen 把下发答案文件 hub.ans 当输入抄 |
| 最佳算术奖 | GX-S00120 |
源码里夹着 55115+71365=126480+... 的加法竖式 |
| 最佳拼写奖 | GX-S00540 |
10 行 5 个错:sits/namspace/frpopen/migrte/reunu |
| 最佳复制粘贴奖 | GX-S00045 |
五行代码五个错,然后整段复制了一遍 |
| 最佳文学奖 | GX-S00062 |
带时间戳的 14:40—17:35 比赛日记 |
| 最佳英文奖 | GX-S00009 |
21 行英文 AFO 长文,语法零错误 |
| 最佳墓志铭奖 | GX-S00306 |
拼错三个词的英文遗书,落款 31 Oct. 2026 |
| 最诚实奖 | GX-S00548 |
I hate this question too. QwQ ×100001 |
| 最佳请假条奖 | GX-S00277 |
I don't have enough time to finish this work |
| 最佳预言奖 | GX-S00180 |
在注释里写明"为了上一次 GX-CSP-S 迷惑行为大赏" |
| 最佳行为艺术奖 | GX-S00005 |
100 MB 的 p + 反向 C++ + 忘情牛肉面 + 象棋残局 |
| 最会藏文件奖 | GX-S00588 |
Vim 交换文件 .crystal.py.swp + 数据生成器 |
| 最勇奖 | GX-S00411 |
文件名 Cancel,freopen 读写对调 |
| 最整齐奖 | GX-S00364 |
四题各 1 字节,一行不差 |
九、写在最后
588 个文件夹,1882 份代码,79219 行。
把这些东西全部读完,你会发现一件有点奇怪的事:真正的迷惑行为其实很少,多的是一群人在极度紧张的两三个小时里,做出了各种各样的选择。
有人选择把样例抄下来,因为那是他唯一能确定的东西。
有人选择死循环输出骂人的话,因为那是他唯一能表达的东西。
有人选择写满 100 MB 的 p,因为那是他唯一能留下的东西。
有人选择在注释里写上"这是我的最后一次",然后交了一份只有 freopen 和 return 0 的代码。
我们每年都要做一次这样的大赏,用笑话的方式把这些时刻收集起来,其实是因为——明年就看不到同样的段子了,明年这些人里,总有人不在了。
所以,最后:
- 祝各位
rp++; #FFFFFF的同学,明年把颜色代码留在 CSS 里;- 100 MB 的同学,明年换个小的字母;
Cancel的同学,下次记得freopen是"r"不是"w";- 写英文遗书的同学,希望你已经考上想去的地方;
- 在注释里写日记的同学,那几段笔记,真的很好看;
- 写
To wyx的同学,希望你们还在一起。
GX 2026 CSP-S 迷惑行为大赏,完。
附:统计口径
- "提交"按选手文件夹下的题目目录统计:同一目录内可能有多个文件(源码、
.ans、.o、可执行文件),但只有.cpp计入源码数; - "四题全交"指四个题目目录里都至少有一份
.cpp; - "硬编码样例答案"指代码中出现了与下发样例输出完全相同的数值常量(如
12251、259997、315275等),并配合cout/printf输出,共人工核对 35 位选手; - "跨选手完全相同的代码"指文件级 MD5 相同(不排除公共模板);
- 所有引用的代码片段均来自原始文件,未做任何美化;为排版方便,部分长行做了换行或省略,用
...标出。