现在是时候面对现实了：我们不会永远在这里，但是至少我们可以编写一个程序，即使人类奋斗到最后，它也将比人类长寿。

您的任务是编写一个程序，该程序的预期运行时间大于到Universe结束之前的剩余时间。

您可以假设：

• 宇宙将在10 ¹⁰⁰⁰年后死于熵。
• 你的电脑：
  • 因为它是由Unobtainium制成的，所以它将比宇宙持久。
  • 具有无限的内存/堆栈/递归限制。
  • 它的处理器速度有限。

您必须证明程序已终止（对不起，没有无限循环）并计算其预期运行时间。

该标准的漏洞适用。

这是一场高尔夫挑战赛的代码，因此符合条件的最短代码将获胜。

编辑：

不幸的是，发现（30分钟后）Unobtainium的不可能范围字段干扰了计算机的内部时钟，使其无法使用。因此，基于时间的程序立即停止。（无论如何，谁会留下一个程序等待其生存的遗产？）。

该计算机处理器与Intel i7-4578U相似，因此一种测量运行时间的方法是在输入较小的类似计算机上运行程序（我希望如此）并推断其运行时间。

讲台

#CharsLanguageUpvotes        Author        
1    5      CJam              20       Dennis                  
2    5      J                      5         algorithmshark      
3    7      GolfScript       30       Peter Taylor          
4    9     Python             39       xnor                      
5    10   Matlab             5         SchighSchagh      

_{*于31/08投票}

CJam，5个字节

0{)}h

这个怎么运作

 0   " Push 0.                                 ";
 {   "                                         ";
   ) " Increment the Big Integer on the stack. ";
 }h  " Repeat if the value is non-zero.        ";

当堆不再存储Big Integer时，该程序将停止运行，这在现代台式机上不会很快发生。

我的计算机上的默认堆大小为4,179,623,936字节（Fedora上的Java 8）。可以使用-Xmx将该值增加到任意值，因此唯一的实际限制是可用的主存储器。

死亡时间

假设解释器需要x位内存来存储小于2 ^x的非负Big Integer ，我们必须计算最多2 ^{8×4,179,623,936} = 2 ^{33,436,991,488}。在每个时钟周期增加一个增量并使用我的Core i7-3770（3.9 GHz，带Turbo）时，这将花费2 ^{33,436,991,488} ÷3,400,000,000> 10 ^{10,065,537,393}秒，这是10 10, ^065,537,385年。

JavaScript，39

(function f(x){for(;x!=++x;)f(x+1)})(0)

说明

由于JavaScript不能精确地表示大整数，因此for(;x!=++x;)一旦xhits ，循环就会终止9007199254740992。

for循环的主体将执行Fib(9007199254740992) - 1次数，其中Fib(n)第n个斐波那契数。

通过测试，我知道我的计算机每秒执行不到150,000次迭代。实际上，由于堆栈会变得非常大，因此运行速度会慢得多。

因此，该程序将至少需要(Fib(9007199254740992) - 1) / 150000几秒钟才能运行。我无法计算，Fib(9007199254740992)因为它太大了，但是我知道它比10 ¹⁰⁰⁰ * 150,000 大得多。

编辑：如评论中所述，Fib(9007199254740992)大约是4.4092 * 10 ^{1882393317509686}，的确足够大。

巨蟒（9）

9**9**1e9

它具有超过10 ** 10000000位，因此计算它应该使我们远远超过热死。

我检查出，获取更大但仍然合理的值会花费越来越多的时间，因此，解释器不仅对其进行了优化。

编辑：感谢@ user2357112，通过删除括号来打高尔夫球两个字符。Python将连续指数视为动力塔的TIL。

GolfScript（12 7个字符）

9,{\?}*

这将计算并打印8 ^ 7 ^ 6 ^ 5 ^ 4 ^ 3 ^ 2〜= 10 ^ 10 ^ 10 ^ 10 ^ 183230。要在10 ^ 1000年〜= 10 ^ 1007.5秒的时间内打印（不必担心计算），它需要每秒打印约10 ^（10 ^ 10 ^ 10 ^ 183230-10 ^ 3）个数字。

Marbelous 68 66字节

}0
--@2
@2/\=0MB
}0@1\/
&0/\>0!!
--
@1
00@0
--/\=0
\\@0&0

Marbelous是一种8位语言，其值仅在类似Rube Goldberg的计算机中用大理石表示，因此这并不是一件容易的事。此方法大致等效于以下伪代码：

function recursiveFunction(int i)
{
    for(int j = i*512; j > 0; j--)
    {
        recursiveFunction(i - 1);
    }
}

由于最大值为256（在Marbleous程序中用0表示，在不同的地方以不同的方式表示），因此recursiveFunction（1）的总和256!*512^256等于，大约10^1200足以使宇宙寿命更长。

Marbelous没有非常快的解释器，似乎它可以10^11每年运行一次此函数，这意味着我们正在寻找运行10^1189年限。

Marbelous板的进一步说明

00@0
--/\=0
\\@0&0

00是语言文字（或大理石），以十六进制（所以0）表示。此大理石落在上--，会将任何大理石减1（00环绕并变成FF或十进制255）。现在具有FF值的Marble落在大理石上\\，将其向右推一列，移至较低的@0。这是一个门户网站，将大理石传送到其他@0设备。在那里，大理石降落在/\设备上，该设备是一个复制器，它将大理石的一个副本放在--其左侧（该大理石将在各门户之间不断循环并在每个环上递减），在=0其右侧放置一个副本。=0将大理石与零值进行比较，如果相等，则使大理石落入低谷，否则将其推向右侧。如果大理石的值为0，则它​​将降落在&0同步器上，稍后我将进一步解释。

总而言之，这只是从循环中的0值大理石开始，然后递减直到它再次达到0，然后将这0值大理石放在同步器中并保持循环。

}0@1
&0/\>0!!
--
@1

}0是输入设备，最初在调用程序时将第n（基数0）命令行输入放置在每个}n设备中。因此，如果您使用命令行输入2调用此程序，则02值的大理石将替换它}0。然后，此大理石掉入&0设备中，另一个同步器，&n同步器将大理石保持住，直到所有其他对应&n的也都归档为止。然后，大理石像以前解释的循环一样递减，传送和复制。然后检查右副本的不等式>0是否为零（）（如果不为0，则不合格）。如果为0，则将其向右推并落在上!!，从而终止电路板。

好的，到目前为止，我们有一个循环，它从255连续倒数到0，并让另一个类似的循环（由命令行输入提供）在每次达到0时运行一次。当第二个循环运行了n次（最大为256）时）程序终止。因此，该循环最多可运行65536次。不足以使宇宙寿命更长。

}0
--@2
@2/\=0MB

这应该看起来很熟悉，输入递减一次，然后该值循环并被复制（请注意，大理石只递减一次，而不是每次循环都递减）。然后，检查是否等于0，如果不等于0，则等于MB。这是Marbelous中的一个函数，每个文件可以包含多个板，每个板都是一个函数，每个函数必须在网格之前加上来命名:[name]。文件中的第一个功能（标准名称为MB）以外的所有功能。因此，此循环使用值n - 1n 连续调用主板，其中n是调用此teh函数实例的值。

那为什么n*512呢？

好吧，第一个循环运行4个滴答声（和256次），第二个循环运行n次，直到板终止。这意味着该板运行约一n*4*256滴答声。最后一个循环（执行递归函数调用）更紧凑，运行2个滴答，这意味着它设法调用函数n*4*256/2 = n*512时间。

您没有提及的符号是什么？

\/ 是一个垃圾桶，可从板上移除大理石，这可确保分散的大理石不会干扰正在循环的其他大理石，并防止程序终止。

奖金

由于从大理石板底部掉落的大理石会输出到STDOUT，因此该程序在运行时会打印大量ASCII字符。

Perl，66 58个字符

sub A{($m,$n)=@_;$m?A($m-1,$n?A($m,$n-1):1):$n+1;}A(9,9);

以上是Ackermann-Péter函数的实现。我不知道A（9,9）有多大，但我可以肯定它需要很长时间才能评估。

MATLAB，58 52个字符

我们至少需要一个有限精度的算术解，因此：

y=ones(1,999);while y*y',y=mod(y+1,primes(7910));end

x = ones（1,999）; y = x;而any（y），y = mod（y + x，primes（7910））;结束

（感谢@DennisJaheruddin淘汰了6个字符）

完成所需的循环数由前999个素数的乘积给出。由于其中绝大多数都超过10，因此实现收敛所需的时间将比最小时间限制大数百或数千个数量级。

Mathematica，25个 19字节

此解决方案是在取消时间功能资格之前发布的。

While[TimeUsed[]<10^10^5]

TimeUsed[]返回自会话开始以来的秒数，并且Mathematica使用任意精度类型。一年大约有10 ⁷秒，因此等待10 ¹⁰⁰⁰⁰秒就足够了。

更短/更简单（/有效）的替代方案：

For[i=0,++i<9^9^9,]

让我们算一下吧。我们将需要进一步计数，因为我们可以在一秒钟内进行很多增量，但是上限实际上并不会花费字符。

从技术上讲，在两种解决方案中，我都可以使用更低的限制，因为该问题并未指定最低处理器速度。

Python 3-49

这做些有用的事情：使用Gregory-Leibniz无限级数计算Pi达到前所未有的精度。

以防万一您想知道，该程序会循环10**10**10**2.004302604952323时间。

sum([4/(i*2+1)*-1**i for i in range(1e99**1e99)])

任意精度：78

from decimal import*
sum([Decimal(4/(i*2+1)*-1**i)for i in range(1e99**1e99)])

图片来源

终极呼吸

由于进行了大量的计算，因此1e99**1e99迭代需要不到1e99**1e99几年的时间。现在，(1e99**1e99)-1e1000几乎没有任何区别。这意味着该程序的运行时间将远远超过我们宇宙灭亡的时间。

重生

现在，科学家们提出，在中10**10**56 years，宇宙将因量子涨落或隧穿而重生。因此，如果每个Universe完全相同，我的程序将经历多少个Universe？

(1e99**1e99)/(1e10+1e1000+10**10**56)=1e9701

假设宇宙将始终存在数1e10+1e1000年，然后需要数10**10**56年才能“重启”，那么我的程序将通过1e9701宇宙存在。当然，这是假设unobtainium可以通过大爆炸。

Python 59（大多数时候都可以工作）

我无法抗拒

from random import*
while sum(random()for i in range(99)):0

虽然理论上可以在毫秒内终止，但平均运行时间远远超过10^400了宇宙指定的寿命。感谢@ BetaDecay，@ undergroundmonorail和@DaboRoss将它记下来大约17个字符。

J-5个字符，我认为

请注意，以下所有内容都是任意精度的算术运算，因为数字9总是x旁边有一点。

在七个字符中，我们有!^:!!9x，有点像跑步

n = 9!
for i in range(n!):
    n = n!

在任意精度的算术中。这绝对超出了限制，因为Synthetica这样说，因此我们有一个上限。

在6个字符，我们也可以写^/i.9x，它计算的每一个中间结果0 ^ 1 ^ 2 ^ 3 ^ 4 ^ 5 ^ 6 ^ 7 ^ 8。Wolfram | Alpha说2^3^4^5^6^7^8大约是10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 6.65185，这也可能清除检查。

我们还有五个 char !!!9x，它们只是（（9！）！）!。W | A表示10 ^ 10 ^ 10 ^ 6.2695，它应该仍然足够大...就像1.6097e1859933-ish的数字，绝对大于3.154e1016宇宙中纳秒的数量，但我要承认我不知道该怎么想这些东西的真实运行时。

但是，仅打印一项所需要的时间应比宇宙所需的时间长得多，因此应该没问题。

C，63 56个字符

f(x,y){return x?f(x-1,y?f(x,y-1):1):y+1;}main(){f(9,9);}

这是基于一个叫威廉的家伙的想法。我唯一的贡献就是将代码压缩为简短（且不可读）的代码。

归纳证明它终止。

• 如果x为0，则立即终止。
• 如果它以x-1和任何y终止，它也以x终止，那么它本身可以通过归纳表示。

通过归纳证明归纳步骤：

• 如果y为0，则只有一个x-1递归调用，该调用以归纳假设终止。
• 如果f（x，y-1）终止，则f（x，y）也终止，因为f的最内层调用恰好是f（x，y-1），而最外层调用根据归纳假设终止。

预期的运行时间为A（9,9）/ 11837秒。这个数字比可观察的宇宙中的夸克数多。

Matlab（10 8个字符）

1:9e1016

恕我直言，大多数条目都在通过计算大型，复杂的事物来进行过度努力。此代码将简单地初始化一个从1开始计数的9x10 ¹⁰¹⁶ double s 数组，该数组需要7.2x10 ^ ¹⁰¹⁷字节。在最大内存带宽为21 GB / s或6.63x10 ^ ¹⁷字节/年的现代CPU上，至少需要花费1.09x10 ¹⁰⁰⁰年才能初始化数组，更不用说尝试打印了，因为我没有打扰用结尾的分号禁止输出。（;

旧的解决方案

nan(3e508)

或者

inf(3e508)

此代码将简单地创建NaN大小为3e508x 3e508 = 9e10168字节双精度或7.2e1017字节的s /无穷大的方阵。

Perl，16个字符

/$_^/for'.*'x1e9

这将生成一个字符串，该字符串重复“。*”十亿次，然后将其用作正则表达式匹配中的指针和干草堆。反过来，这导致正则表达式引擎尝试对长度为20亿个字符的字符串进行每个可能的分区。根据Wikipedia的公式，大约有10 ³⁵²¹⁸这样的分区。

上面的解决方案长16个字符，但是只需要大约2Gb的内存，这意味着它可以在真实的计算机上运行。如果我们假设无限的内存和有限的寄存器大小（这可能没有意义），可以将其缩短为15个字符，同时大大增加运行时间：

/$_^/for'.*'x~0

（我尚未对其进行测试，但我认为它可以与在至少具有6Gb RAM的64位计算机上构建的32位Perl一起使用。）

笔记：

• x 是字符串重复运算符。
• 这for不是一个实际的循环；它仅用于保存一个字符（与相比$_=".*"x1e9;/$_^/）。
• ^正则表达式中的final 确保只有空字符串可以匹配；由于regex量词默认情况下是贪婪的，因此这是引擎要尝试的最后一件事。
• 我计算机上的基准值（1..13）表明运行时间实际上是O（exp（n）），甚至比Wikipedia公式中的O（exp（sqrt（n）））还多。

J（12）

(!^:(!!9))9x

这归结为Python（假设!可行）：

a = 9 
for i in range((9!)!):
    a = a!

编辑：

好的，该程序2 × 10^-1858926每个周期最多可能需要几秒钟才能在所需时间内完成。提示：这甚至在第一个周期都行不通，没关系在最后一个周期;）。

另外：此程序可能需要比宇宙中存在熵更多的内存...

C＃217

我不是高尔夫球手，但是我无法抗拒阿克曼的功能。我也不太了解如何计算运行时间，但是它肯定会暂停，并且运行时间肯定会比此版本更长。

class P{
static void Main(){for(int i=0;i<100;i++){for(int j=0;j<100;j++){Console.WriteLine(ack(i,j));}}}
static int ack(int m,int n){if (m==0) return n+1;if (n ==0) return ack(m-1,1);return ack(m-1,ack(m,n-1));}
}

第一次尝试打码高尔夫，但现在开始了。

VBA- 57 45

x=0
do
if rnd()*rnd()<>0 then x=0
x=x+1
while 1=1

因此，如果发生1 in 2 ^ 128事件，X将上升1，如果未发生，则X将复位。当此事件连续发生2 ^ 64 + 1次时，代码结束。我不知道如何开始计算时间，但我猜想它是巨大的。

编辑：我计算出了数学，每个循环中发生这种情况的概率为1 in 2 ^ 128 ^（1 + 2 ^ 64），大约2万个数字长。假设1000000个循环/秒（凭空产生的棒球场）和30000000 s / yr，即每年3 * 10 ^ 13个周期，剩下的10 ^ 1000年是3 * 10 ^ 1013个周期，那么这大概会持续20倍宇宙剩余的时间。我很高兴我的数学支持了我的直觉。

C，30个字符

main(i){++i&&main(i)+main(i);}

假设二进制补码带符号的溢出和32位int，这将运行大约2 ^{2 32个}函数调用，这对于Universe来说应该有足够的时间结束。

GolfScript，13个字符

0{).`,9.?<}do

该程序仅从0到10 ^{9 9 -1} = 10 ^{387420488计数}。乐观地假设计算机以100 GHz运行并且可以在单个周期内执行程序的每个迭代，则该程序将运行10 ^{9 9 -12}秒，或大约3×10 ^{9 9 -20} = 3×10 ^387420469年份。

测试程序，就可以更换9用2，这将使其停止在10 ^{2 2 -1} = 10 ³ = 1000（使用3而不是2将使其停止在10 ^{3 3 -1} = 10 ²⁶，这，即使采用上述乐观假设，它也不会持续至少几百万年。）

自动热键37

loop {
if (x+=1)>10^100000000
break
}

哈斯克尔（23）

main=interact$take$2^30

从读取1073741824个字符后，该程序终止stdin。如果运行时没有将任何数据传送到stdin，则必须在键盘上键入此数量的字符。假设您的键盘有105个按键，每个按键的额定机械周期为100k，并且已编程为生成非死键击，自动重复功能已关闭，并且您的键盘插座允许100个连接周期，那么每台计算机的最大击键次数为1050000000，即不足以终止程序。

因此，只有在周期数方面有更好的硬件可用时，程序才会终止，这在此运行的Universe中实际上是永远不会发生的。也许下次，质量比数量优先。在此之前，该程序原则上终止，但实际上并未终止。

〜ATH，56岁

用虚构的语言〜ATH：

import universe U;
~ATH(U) {
} EXECUTE(NULL);
THIS.DIE()

〜ATH是一种无法使用的语言。它的逻辑只由无限循环或充其量是有效的无穷循环构成。

许多〜ATH编码人员所做的是导入有限构造并将循环绑定到其寿命。例如，这里的主循环将在标记为U的宇宙死亡时终止。这样一来，您只需等待数十亿年才能结束，而不是永远结束。

对于违反漏洞的行为，我深表歉意。我认为这太重要了以至于无法通过。

如果真的有人对此感到逗乐，那么更多细节：（1），（2），（3），（4）

红宝石（34）

这条线([0]*9).permutation.each{print}大约需要2.47秒，持续9秒钟！在我的机器上打印，而生产线([0]*10).permutation.each{print}大约需要24.7秒，耗时10秒！打印，所以我想我可以在这里推断并计算出(24.7/10!)*470! seconds in years它是6.87 * 10 ^ 1040，这应该是运行时间：

([0]*470).permutation.each{print}

JavaScript 68 62个字符

(function a(m,n){return m==0?n+1:a(m-1,n==0?1:a(m,n-1))})(5,1)

这使用了Ackermann函数，可以写成

function ackermann(a, b) {
  if (a == 0) return b + 1;
  if (b == 0) return ackermann(a-1, 1);
  else return ackermann(a-1, ackermann(a, b-1));
}

它的运行时间以指数方式增加，因此计算时间很长。即使这里不是英语，您也可以大致了解其返回值。根据表ackermann(5,1)equals 2↑↑(65533)-3，这是非常大的。

Befunge '93-40字节

（20x2程式）

v<<<<<<<<<<<<<<<<<<<
>??????????????????@

该程序依靠随机数来增加延迟。由于Befunge的口译员非常慢，因此该程序应符合要求。如果没有，我们总是可以水平扩展它。我不确定如何计算该程序的预期运行时间，但是我知道每个程序都可以吗？重新开始或将其水平位置改变1的机会为50/50。有18个。我认为应该是类似（18 ^ 2）！的东西，Google计算器说的是“ Infinity”

编辑：哎呀，我没有注意到另一个Befunge答案，这是我在这里的第一篇文章。抱歉。

APL，10

我认为这不是一个有效的答案（因为它不是确定性的），但是无论如何……

{?⍨1e9}⍣≡1

该程序计算1e9数字（?⍨1e9）的随机排列，并重复进行直到两个连续的输出相等（⍣≡）

因此，每次计算置换时，它在1000000000中就有1！终止的机会。还有十亿！至少为10 ^{10 8}。

计算排列所花费的时间与1000000000的庞大程度无关！但是一些测试表明这是正确的，O(n)并且推断给出了大约30秒。

但是，我的解释器拒绝接受大于2 ³¹ -1 的随机函数的输入（因此我使用了1e9），并且生成1000000000个数字的排列会给工作区带来完全错误。但是，从概念上讲，它可以使用具有无限内存的理想APL解释器来完成。

假设使用64位体系结构，这使我们有可能使用2 ⁶³ -1代替1e9，以将运行时间提高到至少10 ^{10 20}。

但是，等等，理想的解释器中的体系结构是否相关？地狱没有，所以实际上没有运行时间的上限！

R，45个字节

(f=function(x)if(x)f(x-1)+f(x-1)else 0)(9999)

这是一个旧线程，但我看不到R的答案，我们不能那样做！

对我来说，当x为20时，运行时间约为1秒，这意味着2 ^ 9979秒的运行时间。

如果将零替换为1，则输出将为2 ^ x，但按原样，无论x是多少，输出均为零（避免出现溢出问题）。

Javascript，120个字节

a=[0];while(a.length<1e4)(function(){var b=0;while(b<a.length){a[b]=(a[b]+1)%9;if(a[b])return;b++}a.push(1)})();alert(a)

可以用最少的内存（可能不到半兆字节）完成操作，但是（大约）需要10 ⁷⁵⁰年才能停止。

反复增加一个以小尾数为底的9 BigInteger，直到达到9 ^{10 4 -1}为止。

Python 3，191字节

from random import*
r=randint
f=lambda n:2if n<2else f(n-1)
x=9E999
s=x**x
for i in range(f(x)**f(s)):
 while exec(("r(0,f(x**i))+"*int(f(x)))+"r(0,f(x**i))")!=0:
  s=f(x**s)
  print(s)

首先，f是一个递归阶乘函数，并且非常慢。然后，它自身会被弹起9 * 10 which，这会产生OverflowError，但这在此Unobtanium计算机上不会发生。前循环迭代9E999！^（9E999 ^ 9E999）！次，并且如果9E999！+1介于0到9E99 * ^ i！之间的随机整数，则仅进行下一次迭代。全部为0，并且在while循环的每次迭代中将s设置为（9E999 ^ s）!. 呃，我忘记了s的打印需要花费很多时间……
我知道这不是最短的解决方案，但我认为它确实有效。有人可以帮我计算运行时间吗？

图灵机但更糟，167字节

0 0 1 1 2 0 0
1 0 1 0 4 0 0
0 1 1 1 2 0 0
1 1 1 1 5 0 0
0 2 1 0 3 0 0
1 2 0 1 1 0 0
0 3 1 1 4 0 0
1 3 0 0 2 0 0
0 4 1 0 0 0 0
1 4 0 1 3 0 0
0 5 1 0 6 0 1
1 5 1 1 2 0 0

在线尝试！

应该从Wikipedia页面运行6状态2符号繁忙Beaver 。

$7.412 \times 10^{36534}$