真実に直面する時が来ました。私たちは永遠にここにいるわけではありませんが、少なくとも人類が時間の終わりまで苦労しても生き残るプログラムを書くことができます。

あなたの仕事は、宇宙の終わりまでの残り時間よりも長い予想実行時間を持つプログラムを書くことです。

あなたはそれを仮定するかもしれません：

• 宇宙は10 ¹⁰⁰⁰年後にエントロピーで死ぬでしょう。
• お使いのコンピューター：
  • Unobtainiumで作られているため、宇宙よりも長持ちします。
  • 無限のメモリ/スタック/再帰の制限があります。
  • プロセッサの速度は制限されています。

プログラムが終了したことを示し（申し訳ありませんが、無限ループはありません）、その予想実行時間を計算する必要があります。

標準抜け穴が適用されます。

これはコードゴルフの課題であるため、基準を満たす最短のコードが優先されます。

編集：

残念ながら、Unobtainiumのあり得ないフィールドがコンピュータの内部クロックを妨害し、それを役に立たなくすることが判明しました（30分後）。したがって、時間ベースのプログラムはすぐに停止します。（とにかく、生きている遺産として待っているプログラムを残すのは誰ですか？）

コンピュータープロセッサはIntel i7-4578Uに似ているため、実行時間を測定する1つの方法は、入力が小さい類似のコンピューターでプログラムを実行し（希望）、実行時間を推定することです。

表彰台

#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      

_{* 8月31日の賛成票}

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ため、実際の制限は利用可能なメインメモリのみです。

死の時

インタプリタが2 ^x未満の非負のBig Integerを格納するためにxビットのメモリを必要とすると仮定すると、最大2 ^{8×4,179,623,936} = 2 ^{33,436,991,488}までカウントする必要があります。クロックサイクルごとに1つの増分とCore i7-3770（ターボ付き3.9 GHz）では、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;)はxヒットすると終了します9007199254740992。

forループの本体は、n番目のフィボナッチ数Fib(9007199254740992) - 1でFib(n)ある回実行されます。

テストから、私のコンピューターは1秒間に150,000回未満の反復を行うことがわかっています。実際には、スタックが非常に大きくなるため、実行速度が大幅に低下します。

したがって、プログラムの(Fib(9007199254740992) - 1) / 150000実行には少なくとも数秒かかります。Fib(9007199254740992)それはとても大きいので計算できませんでしたが、10 ¹⁰⁰⁰ * 150,000 よりもはるかに大きいことを知っています。

編集：コメントに記載されているように、Fib(9007199254740992)約4.4092 * 10 ^{1882393317509686}であり、実際に十分な大きさです。

Python（9）

9**9**1e9

これには10 ** 10000000ビット以上あるので、計算することで熱死をはるかに超えるはずです。

値が大きくても妥当な値を得るにはこれに時間がかかることを確認したので、インタープリターによって最適化されているだけではありません。

編集： @ user2357112のおかげで、括弧を削除して2つの文字をゴルフしました。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^111年に1回この関数の呼び出しを実行できるようです。つまり、数年の実行時間を見ています10^1189。

Marbelousボードの詳細説明

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

0016進数（つまり0）で表される言語リテラル（または大理石）です。この大理石はに落下し--、大理石を1つ減らします（00は回り込み、FFまたは10進数で255になります）。値がFFになった大理石は、上に落下し\\、右に1列、下に押し込まれます@0。これはポータルであり、大理石を他の@0デバイスにテレポートします。そこに、大理石/\が複製機であるデバイスに着地し、--その左側に大理石のコピーを1つ置きます（この大理石はポータル間をループし続け、すべてのループで減少します）=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に達するたびに別の同様のループ（コマンドライン入力によって供給）を1回実行するループがあります。この2番目のループがn回（最大256 ）プログラムは終了します。したがって、ループは最大65536回実行されます。宇宙を生き抜くには十分ではありません。

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

これは見慣れたものに見えるはずで、入力は1回減少し、この値はループしてコピーされます（大理石はループを実行するたびではなく、1回しか減少しません）。次に、0と等しいかどうかがチェックされ、ゼロでない場合はになりMBます。これはMarbelousの関数であり、すべてのファイルに複数のボードを含めることができ、各ボードは関数です。すべての関数には、グリッドの前にを付けて名前を付ける必要があります:[name]。ファイル内の最初の関数を除くすべての関数（標準名：MB）。したがって、このループはn - 1、nの値でメインボードを継続的に再度呼び出します。nは、関数のこのインスタンスが呼び出された値です。

なぜn*512ですか？

さて、最初のループは4ティック（および256回）で実行され、2番目のループはボードが終了する前に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文字

したがって、少なくとも1つの有限精度の算術ソリューションが必要です。したがって、

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

x = ones（1,999）; y = x; while any（y）、y = mod（y + x、primes（7910））; end

（6文字をノックオフしてくれた@DennisJaheruddinに感謝します）

完了するのに必要なサイクル数は、最初の999個の素数の積によって与えられます。これらの大部分は10をはるかに超えているため、収束を実現するのに必要な時間は、最小時間制限よりも数百または数千桁大きくなります。

Mathematica、25 19バイト

このソリューションは、時間関数が失格になる前に投稿されました。

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

TimeUsed[]セッションが開始してからの秒数を返します。Mathematicaは任意精度の型を使用します。1年に10 ⁷秒あるので、10 ¹⁰⁰⁰⁰秒待つだけで十分です。

より短く/シンプルな（/有効な）代替：

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

代わりに数えてみましょう。1秒でかなり多くの増分を行うことができるため、もう少しカウントする必要がありますが、上限は実際には文字を消費しません。

技術的には、両方のソリューションで、問題が最小プロセッサ速度を指定していないため、はるかに低い制限を使用できます。

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は、宇宙は量子ゆらぎやトンネリングによって生まれ変わると提案しています。それで、もし各宇宙がまったく同じなら、私のプログラムはいくつの宇宙を生き延びますか？

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

宇宙は常に1e10+1e1000何年も生き続け、その後10**10**56「再起動」するのに何年もかかると仮定すると、私のプログラムは1e9701宇宙を生き延びます。もちろん、これはunobtainiumがBig Bangを生き抜くことができると仮定しています。

Python 59（ほとんどの場合動作します）

抵抗できなかった

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

これは理論的には1ミリ秒未満で終了する可能性があることは事実ですが、平均実行時間は10^400、指定された宇宙の寿命をはるかに超えています。@ BetaDecay、@ undergroundmonorail、および@DaboRossに感謝します。

J-5文字、私は思う

以下のすべては、任意の精度の算術演算であることに注意してください。これは、数字9が常に少しx横にあるためです。

では7つの文字、我々が持っている!^:!!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であると言いますが、これはおそらく検査もクリアします。

5文字もありますが!!!9x、これは（（9！）！）！です。W | Aは10 ^ 10 ^ 10 ^ 6.2695、それはまだ十分に大きいはずだと言います...それは、宇宙のナノ秒数1.6097e1859933よりも明らかに大きい数字のような数字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の再帰呼び出しは1つだけであり、帰納法の仮定によって終了します。
• f（x、y-1）が終了すると、fの最も内側の呼び出しは正確にf（x、y-1）であり、帰納仮説に従って最も外側の呼び出しが終了するため、f（x、y）も終了します。

予想される実行時間は、A（9,9）/ 11837秒です。この数には、観測可能な宇宙のクォークの数よりも多くの桁があります。

Matlab（10 8文字）

1:9e1016

私見、大部分のエントリーは、大きくて複雑なものを計算することによって一生懸命に努力しています。このコードは、1からカウントアップする9x10 ¹⁰¹⁶ doubleの配列を初期化するだけで、7.2x10 ^ ¹⁰¹⁷バイトかかります。21 GB / sまたは6.63x10 ^ ¹⁷バイト/年の最大メモリ帯域幅を備えた最新のCPUでは、配列を初期化するのに少なくとも 1.09x10 ¹⁰⁰⁰年かかります。末尾のセミコロンで出力を抑制します。（;

古いソリューション

nan(3e508)

代わりに

inf(3e508)

このコードはNaN、サイズ3e508x 3e508 = 9e10168バイトのdoubleまたは7.2e1017bytes のs /無限大の正方行列を作成するだけです。

Perl、16文字

/$_^/for'.*'x1e9

これは、「。*」を10億回繰り返す文字列を作成し、それを正規表現一致の針と干し草の両方として使用します。これにより、正規表現エンジンは、20億文字の文字列のあらゆるパーティションを試行します。Wikipediaのこの式によると、このようなパーティションは約10 ³⁵²¹⁸個あります。

上記のソリューションの長さは16文字ですが、必要なメモリは約2Gbのみであるため、実際のコンピューターで実行できます。無限のメモリと有限のレジスタサイズ（おそらく意味をなさない）を想定する場合、ランタイムを劇的に増加させながら15文字に短縮できます。

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

（私はそれをテストしていませんが、少なくとも6GbのRAMを搭載した64ビットマシン上に構築された32ビットPerlで動作すると思います。）

ノート：

• x 文字列の繰り返し演算子です。
• これforは実際のループではありません。これは、1文字を保存するためにのみ使用されます（と比較$_=".*"x1e9;/$_^/）。
• ^正規表現の最後では、空の文字列のみが一致することが保証されます。正規表現の数量詞はデフォルトで貪欲であるため、これはエンジンが試行する最後のことです。
• 私のコンピューターの値（1..13）のベンチマークは、実行時間が実際にO（exp（n））であることを示唆しています。これは、ウィキペディアの式のO（exp（sqrt（n）））よりもさらに長いです。

J（12）

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

これがPythonでどうなるか（!動作すると仮定）：

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

編集：

まあ、プログラムは2 × 10^-1858926、必要な時間内に完了するために、1サイクルあたり最大で数秒かかります。ヒント：これは最初のサイクルでも機能しません。最後のサイクルでもかまいません;）。

また、このプログラムは、宇宙にエントロピーがあるよりも多くのメモリを必要とするかもしれません...

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

そのため、Xは1の2 ^ 128イベントが発生すると1つ上がり、発生しないとリセットされます。このイベントが2 ^ 64 + 1回連続して発生すると、コードは終了します。時間の計算を開始する方法がわかりませんが、それは巨大だと思います。

編集：私は数学を計算し、各ループでこれが起こる確率は約20000桁の2 ^ 128 ^（1 + 2 ^ 64）に1です。1000000ループ/秒（薄い空気の数から球場）と30000000 s / yrが1年あたり3 * 10 ^ 13サイクルであると仮定すると、残りの10 ^ 1000年は3 * 10 ^ 1013サイクルなので、これは約20倍続くでしょう宇宙に残された残りの時間。数学が直感を裏付けてくれてうれしいです。

C、30文字

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

2の補数の符号付きオーバーフローと32ビット整数を想定すると、これは約2 ^{2 32の}関数呼び出しで実行され、宇宙が終了するのに十分な時間になるはずです。

GolfScript、13文字

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

このプログラムは、0から10 ^{9 9 -1} = 10 ^387420488までカウントアップします。コンピューターが100 GHzで実行され、プログラムの各反復を1サイクルで実行できると楽観的に想定すると、プログラムは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になります。プログラムを終了するには不十分です。

したがって、サイクル数の点でより優れたハードウェアが使用可能になると、プログラムは終了します。これは、この実行中のユニバースでは事実上不可能です。次回は、品質が量よりも優先される場合です。それまで、このプログラムは原則として終了しますが、実際には終了しません。

〜ATH、56

で架空の言語〜ATH：

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

〜ATHは、処理に耐えられない言語です。その論理は、無限ループ、またはせいぜい効果的に破壊可能な構造のループのみで構成されています。

多くの〜ATHコーダーが行うことは、有限構造をインポートし、ループをその寿命にバインドすることです。たとえば、ここでのメインループは、Uというラベルの付いた宇宙の死で終了します。このように、無限に終わるのではなく、数十億年待つだけで済みます。

境界線の抜け穴違反をおaびします。あまりにも関連性が高すぎて見過ごせないと思いました。

実際に誰かがこれに面白がっていた場合、詳細：（1）、（2）、（3）、（4）

ルビー（34）

([0]*9).permutation.each{print}9 行で約2.47秒かかります！マシンで印刷し([0]*10).permutation.each{print}ますが、ラインは10で約24.7秒かかります！印刷するので、ここで外挿し、(24.7/10!)*470! seconds in years6.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)

これは、次のように記述できるアッカーマン関数を使用します

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)等しい2↑↑(65533)-3、あなたが知っている、非常に大きなです。

Befunge '93-40バイト

（20x2プログラム）

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

このプログラムは、遅延を与えるために乱数に依存しています。Befungeインタープリターは非常に遅いため、このプログラムは法案に適合するはずです。そうでない場合は、いつでも水平方向に拡張できます。このプログラムの予想実行時間をどのように計算するのか正確にはわかりませんが、それぞれのことを知っていますか？は、最初からやり直すか、水平位置を1ずつ変更する可能性が50/50あります。18個の？があります。Googleの計算機が「無限」だと言う（18 ^ 2）！の線に沿ったものでなければならないと思います

編集：フープ私は他のBefungeの答えに気づかなかった、これはここでの私の最初の投稿です。ごめんなさい。

APL、10

私はこれが有効な答えだとは思いません（非決定的であるため）が、とにかく......

{?⍨1e9}⍣≡1

このプログラムは、1e9数のランダムな順列を計算し（?⍨1e9）、2つの連続した出力が等しくなるまで繰り返します（⍣≡）

したがって、順列が計算されるたびに、1000000000に1があります！終了する可能性。そして1000000000！は少なくとも10 ^{10 8}です。

置換を計算するのにかかる時間は、1000000000の重さによって無関係になります！。しかし、いくつかのテストではこれが示されておりO(n)、外挿すると約30秒かかります。

ただし、私のインタープリターは、2 ³¹ -1 より大きいランダム関数への入力を拒否し（したがって1e9を使用しました）、1000000000個の順列を生成すると、ワークスペース全体のエラーが発生しました。ただし、概念的には、無限のメモリを持つ理想的なAPLインタープリターを使用して実行できます。

これにより、64ビットアーキテクチャを想定して、1e9の代わりに2 ⁶³ -1 を使用して、実行時間を少なくとも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)

最小限のメモリ（おそらく0.5メガバイト未満）で実行できますが、停止するには（おそらく）約10 8, ⁷⁵⁰年かかります。

9 ^{10 4 -1に}達するまで、リトルエンディアンのbase-9 BigIntegerを繰り返しインクリメントします。

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⁹⁹⁹がそれ自身で与えられ、OverflowErrorを生成しますが、これはこのUnobtaniumコンピューターでは起こりません。For-Loopは9E999を繰り返します！^（9E999 ^ 9E999）！9E999！+1が0から9E99 * ^ i！までのランダムな整数である場合にのみ、次の反復に進みます。すべて0であり、while-loopのすべての反復で（9E999 ^ s）に設定されます！。ええと、sの印刷にはmuuuuccchhhh時間がかかることを忘れていました
。誰かが実行時間の計算を手伝ってくれますか？

チューリングマシンがさらに悪い、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

オンラインでお試しください！

ウィキペディアのページから6状態の2シンボルBusy Beaverを実行する必要があります。

$7.412 \times 10^{36534}$