专栏文章

如何科学膜拜

22021CHD
休闲·娱乐参与者 2已保存评论 1

文章操作

快速查看文章及其快照的属性，并进行相关操作。

当前评论
0 条
当前快照
1 份
快照标识符
@min0jjyv
此快照首次捕获于
2025/12/01 18:35
3 个月前
此快照最后确认于
2025/12/01 18:35
3 个月前
查看原文
观前提示：本文纯属娱乐，可能有部分不严谨之处，请勿深究，亦请勿将本文作为学习资料。
首先，由于 wtc 非常强，所以这里我们膜拜 wtc。
那怎么膜拜呢？
%%%wtc 显然是不够的，我们需要用一个程序来膜拜 wtc。
CPP
#include<cstdio>
int main()
{
	printf("%%%wtc");
}
诶怎么编译器弹警告了？原来 % 是 printf 转换说明符的前导字符，为了使一个 % 表示一个 % 而不是两个 % 表示一个 %，我们改用 cout 输出：
CPP
#include<iostream>
using namespace std;
int main()
{
	cout<<"%%%wtc"<<endl;
}
膜拜次数：00。
诶，为什么是 00？既然我们都是 OIer，应该都能接受 00 标号。这里根据传统，我们对每行 %%%wtc 采用 00 标号，也就是说，我们输出的最后一行是第 00 行。
所以我们的“膜拜次数”实际上指的是最后一次膜拜的行号。
显然膜拜一次难以表示我们的热情，所以我们可以膜拜很多次：
CPP
#include<iostream>
using namespace std;
int main()
{
	cout<<"%%%wtc"<<endl;
	cout<<"%%%wtc"<<endl;
	cout<<"%%%wtc"<<endl;
	cout<<"%%%wtc"<<endl;
	cout<<"%%%wtc"<<endl;
}
膜拜次数：44。
显然这样我们膜拜的次数还是太少了，于是我们可以用一个循环进行膜拜：
CPP
#include<iostream>
using namespace std;
int main()
{
	for(int i=1;i<=100000;i++)
	cout<<"%%%wtc"<<endl;
}
膜拜次数：9999999999。
既然都膜拜这么多次了，那干脆直接无限膜拜不就好了吗？
说干就干：
CPP
#include<iostream>
using namespace std;
int main()
{
	while(1)
	cout<<"%%%wtc"<<endl;
}
膜拜次数：∞\infty？
这里的膜拜次数写 ∞\infty 显然太低级了。作为经历过「最长待机」的人，显然可以把膜拜次数写成 ω\omega。
膜拜次数：ω\omega？
这样看起来虽然高级多了，但是好像不太符合 ω\omega 的定义？（毕竟此时，“最后一行”都不存在）
让我们更改一下我们的代码：
CPP
#include<iostream>
using namespace std;
int main()
{
	while(1)
	cout<<"%%%wtc"<<endl;//对应有限序数 0,1,2,3,4,...
	cout<<"%%%wtc"<<endl;//对应序数 omega：大于所有有限序数的最小序数
}
膜拜次数：ω\omega。
这下对劲多了。
显然还能有更多的膜拜！
CPP
#include<iostream>
using namespace std;
int main()
{
	while(1)
	cout<<"%%%wtc"<<endl;
	for(int i=1;i<=100000;i++)
	cout<<"%%%wtc"<<endl;
}
膜拜次数：ω+99999\omega+99999。
太少了，来个 ω+ω\omega+\omega 如何？
CPP
#include<iostream>
using namespace std;
int main()
{
	while(1)
	cout<<"%%%wtc"<<endl;
	while(1)
	cout<<"%%%wtc"<<endl;
	cout<<"%%%wtc"<<endl;
}
膜拜次数：ω×2\omega\times2。
这里的乘法就是正常的乘法。
显然还能有更多的膜拜！
CPP
#include<iostream>
using namespace std;
int main()
{
	for(int i=1;i<=100000;i++)
	while(1)
	cout<<"%%%wtc"<<endl;
	cout<<"%%%wtc"<<endl;
}
膜拜次数：ω×100000\omega\times100000。
显然还能有更多的膜拜！
CPP
#include<iostream>
using namespace std;
int main()
{
	while(1)
	while(1)
	cout<<"%%%wtc"<<endl;
	cout<<"%%%wtc"<<endl;
}
膜拜次数：ω2\omega^2。
这里的乘方就是正常的乘方。
显然还能有更多的膜拜！
CPP
#include<iostream>
using namespace std;
int main()
{
	while(1)
	while(1)
	while(1)
	while(1)
	while(1)
	while(1)
	while(1)
	while(1)
	while(1)
	while(1)
	cout<<"%%%wtc"<<endl;
	cout<<"%%%wtc"<<endl;
}
膜拜次数：ω10\omega^{10}。
考虑到大量 while(1) 会使得代码不美观，我们换一种方式表示 ω\omega 高次幂的膜拜：
CPP
#include<iostream>
using namespace std;
void mo_bai(int x)
{
	if(x==0)
	cout<<"%%%wtc"<<endl;
	else
	while(1)
	mo_bai(x-1);
}
int main()
{
	mo_bai(100000);
	cout<<"%%%wtc"<<endl;
}
膜拜次数：ω100000\omega^{100000}。
但是好像卡住了？
如何才能制造出比 ω\omega 的有限次方更多的膜拜呢？
可以想到一件事情：我们只需要输出一个无限膜拜序列，第一项是 ω\omega，第二项是 ω2\omega^2，第三项是 ω3\omega^3，以此类推，不就可以了吗？
说干就干！
但是你会悲伤地发现 C++ 的整型都是有上限的……
如果我们套用上面的做法，我们就需要手写一份无上限的高精度整型，太麻烦了，考虑更简单的做法。
通过若干人类智慧，我们可以得到以下代码：
CPP
#include<iostream>
#include<functional>
using namespace std;
int main()
{
	function<void()> las=[]()->void{cout<<"%%%wtc"<<endl;};
	while(1)
	{
		auto s=[las]()->void{while(1)las();};
		las=s;
		las();//第 x 次执行 while 循环的时候会 las() 就对应 omega^x 次膜拜
	}
	//while 循环执行过程中 x 会大于任何有限数，所以我们认为 omega 的指数是 omega
	cout<<"%%%wtc"<<endl;
}
膜拜次数：ωω\omega^{\omega}。
至此，我们已经超越了「最长待机」中可能涉及的所有序数。
但是，显然这个还可以继续升级！
CPP
#include<iostream>
#include<functional>
using namespace std;
int main()
{
	function<void()> las=[]()->void{cout<<"%%%wtc"<<endl;};
	while(1)
	{
		auto s=[las]()->void{while(1)las();};
		las=s;
		las();
	}
	while(1)
	{
		auto s=[las]()->void{while(1)las();};
		las=s;
		las();
	}
	cout<<"%%%wtc"<<endl;
}
膜拜次数：ωω×2\omega^{\omega\times2}。
进一步优化：
CPP
#include<iostream>
#include<functional>
using namespace std;
int main()
{
	function<void()> las=[]()->void{cout<<"%%%wtc"<<endl;};
	for(int i=1;i<=100000;i++)
	while(1)
	{
		auto s=[las]()->void{while(1)las();};
		las=s;
		las();
	}
	cout<<"%%%wtc"<<endl;
}
膜拜次数：ωω×100000\omega^{\omega\times100000}。
叠叠幂塔是好事，所以开始叠幂塔：
CPP
#include<iostream>
#include<functional>
using namespace std;
int main()
{
	function<void()> las=[]()->void{cout<<"%%%wtc"<<endl;};
	while(1)
	while(1)
	while(1)
	while(1)
	while(1)
	while(1)
	while(1)
	while(1)
	while(1)
	while(1)
	{
		auto s=[las]()->void{while(1)las();};
		las=s;
		las();
	}
	cout<<"%%%wtc"<<endl;
}
膜拜次数：ωω10\omega^{\omega^{10}}。
注意，正常情况下（就是指没有括号的情况下），幂塔是从上往下计算的。
同样可以将 while 循环改用递归：
CPP
#include<iostream>
#include<functional>
using namespace std;
void mo_bai(int n,function<void()> &las)
{
	if(n==1)
	while(1)
	{
		auto s=[las]()->void{while(1)las();};
		las=s;
		las();
	}
	else
	while(1)
	mo_bai(n-1,las);
}
int main()
{
	function<void()> las=[]()->void{cout<<"%%%wtc"<<endl;};
	mo_bai(100000,las);
	cout<<"%%%wtc"<<endl;
}
膜拜次数：ωω100000\omega^{\omega^{100000}}。
怎么样才能使答案来到 ωωω\omega^{\omega^{\omega}} 呢？
考虑一些人类智慧：我们可以复用我们已经得出的做法。
于是我们就可以得到这份抽象代码：
CPP
#include<iostream>
#include<functional>
using namespace std;
int main()
{
	function<void()> inner_las=[]()->void{cout<<"%%%wtc"<<endl;};
	function<void()> las=[&inner_las]()->void{while(1){auto s=[inner_las]()->void{while(1)inner_las();};inner_las=s;inner_las();}/*这个 while 执行了几次膜拜次数就是 omega 的几次幂*/};
	while(1)
	{
		auto s=[las]()->void{while(1)las();};
		las=s;
		las();
	}
	//通过已有的构造使上面那个 while 的执行次数达到 omega^omega
	cout<<"%%%wtc"<<endl;//最终的膜拜次数来到了 omega^omega^omega
}
膜拜次数：ωωω\omega^{\omega^{\omega}}。
未完待续……

评论

共 1 条评论，欢迎与作者交流。

正在加载评论...