あなたの目標は、数字を印刷するプログラムを書くことです。数値が大きいほど、より多くのポイントを獲得できます。しかし、注意してください！スコアリング機能では、コードの長さが制限されており、かなりの重みがあります。印刷された数値は、ソリューションに使用したバイト数のキューブで除算されます。

したがって、印刷10000000したコードが100バイト長であるとします。最終スコアはになります10000000 / 100^3 = 10。

この挑戦を少し難しくするために、従うべき他のルールがあります。

• コードで数字を使用することはできません（0123456789）。
• あなたはできるなど/物理/数学を使用します。定数、しかし、彼らはしている場合にのみ、10未満（あなたが使用することができます例えばパイ〜= 3.14が、あなたが使用することはできませんアボガドロ定数 = 6e23）
• 再帰は許可されますが、生成された数は有限である必要があります（そのため、無限は解として受け入れられません。プログラムは、時間とメモリの制限なしで正しく終了し、要求された出力を生成する必要があります）;
• 操作*（乗算）、/（除算）、^（電力）、またはそれらを示す他の方法を使用すること2 div 2はできません（たとえば、許可されていません）。
• プログラムは、必要に応じて複数の数値を出力できます。最高のものだけが得点にカウントされます。
• ただし、文字列を連結することはできます。つまり、隣接する数字のシーケンスはすべて単一の数字と見なされます。
• コードはそのまま実行されます。これは、エンドユーザーがコードの行を編集することも、数字やその他のものを入力することもできないことを意味します。
• 最大コード長は100バイトです。

リーダーボード

1. スティーブンH.、Pyth ≈Fの _{φ（1,0,0）+7}（256 ²⁶）/ 1000000 ^[1]
2. 単に美しいアート、ルビー ≈F _{φ 121（ω）}（126） ^[1]
3. ピーター・テイラー、GolfScript ≈F _{ε 0 +ω+ 1}（17）/ 1000 ^[1]
4. RES、GolfScript ≈F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（126））））））））） ^[1]
5. 単に美しいアート、ルビー ≈F _{ω ^ω2 +1}（1983）
6. eaglgenes101、ジュリア ≈Fの _ω3（127）
7. col6y、Python 3、 ≈（127→126→...→2→1）/ 99 ^{3 [1] [3]}
8. Toeofdoom、ハスケル、 ≈ ₂₀（1）/ 99 ^{3 [1]}
9. Fraxtil、dc、 ≈15↑¹⁶⁶⁶⁶⁶⁵15/100 ^{3 [3]}
10. マゼンタ、パイソン、 ≈ACK（126126）/ 100 ³ ↑≈10 ¹²⁴ 129
11. ケンドールフレイ、ECMAスクリプト6、 ≈10 ^{3↑ 4 3} /100 ^{3 [1]}
12. ILMARI Karonen、GolfScript、 ≈10↑ ³ 10 ³⁷⁷ /18 ^{3 [1]}
13. BlackCap、Haskell、 ≈10↑↑65503/100 ³
14. 再帰、パイソン、 ≈2↑↑95分の11 ³ ≈10↑↑8.63297 ^[1]〜[3]
15. NM、ハスケル、 ≈2↑↑100分の7 ³ ≈10↑↑4.63297 ^[1]
16. デビッド・ヨー、C、 ≈10 ^{10 、4×10 22} /83 ³ ≈10↑↑4.11821 ^[2]
17. プリモ、Perlの、 ≈10^{（12750684161！）5×2 27} /100 ³ ≈10↑↑4.11369
18. アート、C、 ≈10 ^{10 2×10 6} /98 ³ ≈10↑↑3.80587
19. ロバートSørlie、x86の、 ≈10 ^{2 2 19 +32} / 100 ³ ≈10↑↑3.71585
20. トビア、APL、 ≈10 ^{10 353} /100 ³ ≈10↑↑3.40616
21. ダレン石、C、 ≈10 ^{10 97.61735} / 98 ³ ≈10↑↑3.29875
22. ecksemmess、C、 ≈10 ^{2 320} /100 ³ ≈10↑↑3.29749
23. アダムスパイツ、vb.net、 ≈10 ^{5000×（2 64）4} /100 ³ ≈10↑↑3.28039
24. ジョシュアは、bash、 ≈10 ^{10 15} /86 ³ ≈10↑↑3.07282

_脚注

1. ^{宇宙のすべての電子がキュービットであり、そのすべての重ね合わせが情報を格納するために有益に使用できる場合（これは、実際に格納されているものを知る必要がない限り、理論的には可能です）、このプログラムは必要以上のメモリを必要とします存在する可能性があり、したがって実行することはできません-現在、または将来の任意の考えられる時点で。著者が≈3↑↑3.28より大きい値を一度に印刷することを意図した場合、この条件が適用されます。}
2. ^{このプログラムは現在存在するよりも多くのメモリを必要としますが、理論的には少ない数のキュービットに格納できないほど多くないため、このプログラムを実行できるコンピューターがいつか存在する可能性があります。}
3. ^{現在利用可能なすべてのインタープリターはランタイムエラーを発行します。そうでない場合、プログラムは作成者の意図したとおりに実行できません。}
4. ^{このプログラムを実行すると、システムに修復不可能な損傷が発生します。}

@primoの編集：スコアボードの一部を更新しました。比較しやすい表記法を使用し、小数部を使用して次の高次への対数距離を示します。例10↑↑2.5 = 10のために^{10 √10}。また、ユーザーの分析に誤りがあると思われる場合は、いくつかのスコアを変更しました。これらのいずれかについては気軽に異議を申し立ててください。

この表記の説明：

の場合0 ≤ b < 1、その後。a↑↑b = ab

の場合b ≥ 1、その後。a↑↑b = aa↑↑(b-1)

の場合b < 0、その後。a↑↑b = loga(a↑↑(b+1))

GolfScript; _{fε_0+ω+ 1}（17）/ 1000 以上のスコア

この質問にワームの寿命の回答を使用するというresの提案に続いて、ハワードのソリューションの派生を大幅に改善する2つのプログラムを紹介します。

関数名を法とする共通のプレフィックスを共有します：

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g

計算g(g(1)) = g(5)場合g(x) = worm_lifetime(x, [x])、Fとほぼ成長_{ε 0}（ノートをRES「関数で急成長している階層に大別グッドスタイン関数と同じ速度を成長」）。

分析がやや簡単（！）

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{.{.{.{.{.{.{.{.{.{g}*}*}*}*}*}*}*}*}*}*

.{foo}*にマップxしfoo^x xます。

,:z){[]+z\{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{g}*

したがって、与えるg^(g(5)) ( g(5) ); さらに8レベルの反復は、矢印チェーンに似ています。単純な用語で表現する場合：if h_0 = gとh_{i+1} (x) = h_i^x (x)thenを計算しh_10 (g(5))ます。

この2番目のプログラムのスコアはほぼ間違いなく優れていると思います。今回gは、機能に割り当てられたラベルは改行（sic）です。

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:
~
{.['.{
}*'n/]*zip n*~}:^~^^^^^^^^^^^^^^^^

今回^は、別の関数としてより有効に活用します。

.['.{
}*'n/]*zip n*~

かかるxスタック上に、そして葉x含む文字列が続くxのコピー.{が続くg続くxのコピーを}*。次に、文字列を評価します。予備のキャラクターを焼き付けるのに適した場所があったので、最初にj_0 = g; 場合はj_{i+1} (x) = j_i^x (x)、その後の最初の評価^を計算j_{g(5)} (g(5))（私はかなり確信している、すでに前のプログラムを打ちます）。その後、^さらに16回実行します。のでk_0 = g(5)、k_{i+1} = j_{k_i} (k_i)それから計算しk_17ます。k_i>> _{fε_0+ω+ 1}（i）を推定してくれたresに感謝します。

Windows 2000-Windows 8（3907172 /23³= 321）

注：これを実行しないでください！

以下をバッチファイルに保存し、管理者として実行します。

CD|Format D:/FS:FAT/V/Q

4TBドライブで実行すると、最初に印刷された数字が太字で出力されます。

ドライブDに新しいディスクを挿入し
、準備ができたらEnterキーを押します...ファイルシステムの種類はNTFSです。
新しいファイルシステムはFATです。
QuickFormatting 3907172M
ボリュームはFAT16 / 12には大きすぎます。

GolfScript、スコア：方法が多すぎる

わかりました、GolfScriptのいくつかの文字でいくつの数字を印刷できますか？

次のコードから始めましょう（ありがとう、Ben！）126。

'~'(

次に、それを126回繰り返して、約1.26126×10 ^377に等しい数を与えます。

'~'(.`*

（これは乗算ではなく文字列の繰り返しであるため、ルールの下では問題ありません。）

それでは、その 378桁の数字を10 ³⁷⁷回少し繰り返してみましょう。

'~'(.`*.~*

それは約10で数を計算しようとするので、あなたが実際に、このプログラムの仕上がりを見ることは決してないだろう³⁸⁰ ≈2 ¹¹⁴⁰桁。これまでに構築されたコンピューターは、これほど大きな数を格納することも、既知の物理学を使用してそのようなコンピューターを構築することもできませんでした。観察可能な宇宙の中の原子の数は約10と推定されている⁸⁰ので、私たちは何とか使用できる場合でも、宇宙のすべての問題を、この膨大な数を格納するために、我々はまだ何とか詰め込む必要があるだろう、約10 ³⁸⁰ /10 ⁸⁰ = 各アトムに 10 ³⁰⁰桁！

しかし、このような計算を実行できる神の独自のGolfScriptインタープリターがあり、まだ満足していないと仮定しましょう。OK、もう一度やりましょう！

'~'(.`*.~*.~*

このプログラムの出力は、完了できた場合、約10 ^{10 383}桁になるため、約10 ^{10 10 383になり}ます。

ちょっと待って！そのプログラムは一種の反復的なものになっています...なぜループに変えてみませんか？

'~'(.`*.{.~*}*

ここでは、ループ本体は、約10実行します³⁷⁷私たちに約10からなる理論的な出力を与える、回を^{10⋰ 10 377}のタワー桁ほど、反復力 10のは約10である³⁷⁷ステップの長を。（実際には、繰り返される数も毎回長くなるという事実を無視しているため、これはかなり過小評価されていますが、比較的言えばそれは小さな問題です。）

しかし、まだ完了していません。別のループを追加しましょう！

'~'(.`*.{.{.~*}*}*

そのような数値の近似値を適切に書き留めるには、難解な数学表記が必要です。たとえば、クヌースの上向き矢印表記では、上記のプログラムによって（理論的に）出力される数値は約10↑ ³ 10 ³⁷⁷であり、数学が正しかったと仮定して、10のべき乗（または10 ³⁷⁷）を与えたり受けたりします。

このような数字は、「信じられないほど巨大」なものを超えて、「想像もできない」領域に到達します。同様に、そのような数までカウントアップしたり、書き留めたりすることが不可能であるだけでなく（上記の3番目の例で既にそのポイントを超えた）、抽象数学以外では文字通り考えられる使用や存在はありません。私たちは、から、証明することができます数学の公理、我々は上記のプログラムは、GolfScript仕様から証明できると同じように、そのような数が存在すること、でしょう）現実と利用可能なストレージ容量の限界が介入しなかった場合は、それらを計算しますが、文字通りありません何もでは、あらゆる意味でそれらを使用して数えたり測定したりできる物理的な宇宙。

それでも、数学者は時々さらに大きな数を利用します。（理論的に）大きな数値を計算するには、少し多くの作業が必要です。ループを1つずつネストするだけでなく、再帰を使用してネストされたループの深さを伸縮する必要があります。それでも、原則として、短いGolfScriptプログラム（100バイトをはるかに下回ると思います）を記述して、（理論的には）Conwayチェーン矢印表記で表現可能な任意の数を計算することが可能です。詳細は演習として残します。;-)

JavaScript 44文字

これは少しずるいように見えるかもしれません：

alert((Math.PI+''+Math.E).replace(/\./g,""))

スコア= 31415926535897932718281828459045/44 ^ 3≈3.688007904758867e + 26≈10↑↑2.1536134004

C、スコア= 10 ^{10 97.61735} / 98 ³ ≈10↑↑2.29874984

unsigned long a,b,c,d,e;main(){while(++a)while(++b)while(++c)while(++d)while(++e)printf("%lu",a);}

得点の助けに感謝します。洞察や修正を歓迎します。私の方法は次のとおりです。

n = 1から2 ⁶⁴ -1 までのすべての数値の連結（2 ⁶⁴ -1）を⁴回繰り返します。最初に、1〜2 ⁶⁴ -1（「サブシーケンス」）の累積桁数を（低）推定する方法を次に示します。サブシーケンスシーケンスの最終数は2 ⁶⁴ -1 = 1844674407370955161520桁です。したがって、サブシーケンスの数字の90％以上（1..で始まるもの9）は19桁です。残りの10％が平均10桁であると仮定しましょう。それはそれよりもはるかに多くなりますが、これは簡単な数学と不正行為のための低い推定値です。そのサブシーケンスは⁴回（2 ⁶⁴ -1）繰り返されるため、長さはNあろう少なくとも（0.9×（2 ⁶⁴ -1）19 + 0.1×（2× ⁶⁴ ×（2 -1）×10）⁶⁴ -1）⁴ = 3.86613×10 ⁹⁷桁。以下のコメントでは、@ primoはnの長さが4.1433x10 ⁹⁷であることを確認しています。したがって、n自体は10の¹⁰乗、つまり10 ^{10 97.61735になり}ます。

l = 98文字のコード

スコア = n / l ³ = 10 ^{10 97.61735} / 98 ³

要件：64ビットコンピューターで実行する必要がありsizeof(long) == 8ます。MacとLinuxがそれを行います。

Python 3-99文字-（ほとんどの場合）Grahamの数よりも大幅に大きい

アッカーマン関数の拡張に基づいて、より急速に増加する関数を考え出しました。

A=lambda a,b,*c:A(~-a,A(a,~-b,*c)if b else a,*c)if a else(A(b,*c)if c else-~b);A(*range(ord('~')))

http://fora.xkcd.com/viewtopic.php?f=17&t=31598に触発されましたが、私の番号を理解するためにそこを見る必要はありません。

これが、分析で使用するackermann関数の修正バージョンです。

A(b)=b+1
A(0,b,...)=A(b,...)
A(a,0,...)=A(a-1,1,...)
A(a,b,...)=A(a-1,A(a,b-1,...),...)

A上記のコードの私の機能は技術的には同じではありませんが、実際にはより強力であり、上記の定義の3行目を置き換える次のステートメントがあります。

A(a,0,...)=A(a-1,a,...)

（aは少なくとも1でなければならないため、より強くなければなりません）

しかし、私の目的のために、アッカーマン関数の解析はすでに部分的に行われているため、2つの引数がある場合、この関数の解析は単純なものと同じであると想定します。

私の関数は、引数の削除、最初の引数のデクリメント、または同じ最初の引数の保持と2番目の引数のデクリメントのいずれかであるため、最終的に再帰を停止することが保証されています。

サイズの分析

グラハムの数であるAFAIKは、次のものG(64)を使用して表すことができます。

G(n) = g^n(4)
g(n) = 3 ↑^(n) 3

ここで、↑^(n)a bはクヌースの上矢印表記です。

同じように：

A(a,b) = 2 ↑^(a-2) (b+3) - 3
A(a,0) ≈ 2 ↑^(a-2) 3
g(n) ≈ A(n+2,0) // although it will be somewhat smaller due to using 2 instead of 3. Using a number larger than 0 should resolve this.
g(n) ≈ A(n+2,100) // this should be good enough for my purposes.

g(g(n)) ≈ A(A(n+2,100),100)

A(1,a+1,100) ≈ A(0,A(1,a,100),100) = A(A(1,a,100),100)

g^k(n) ≈ A(A(A(A(...(A(n+2,100)+2)...,100)+2,100)+2,100)+2,100) // where there are k instances of A(_,100)
A(1,a,100) ≈ A(A(A(A(...(A(100+2),100)...,100),100),100),100)

g^k(100) ≈ A(1,k,100)
g^k(4) < A(1,k,100) // in general
g^64(4) < A(1,64,100)

上記のプログラムで表現されている数はA(0,1,2,3,4,...,123,124,125)です。

以来はg^64(4)グラハムの数であり、私の数学と仮定すると、それはより少ない正しいですA(1,64,100)私の電話番号があり、大幅にグラハムの数よりも多いです。

私の数学の間違いを指摘してください-ない場合、これはこの質問に答えるためにこれまでに計算された最大数でなければなりません。

Perl-スコア≈10↑↑4.1

$_=$^Fx($]<<-$]),/(?<R>(((((((((((((((((((.(?&R))*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

再びperlの正規表現エンジンを悪用して、想像を絶する量の組み合わせをグラインドします。今回は再帰降下を使用します。

式の内側のほとんどには、.無限再帰を防ぐためのベアがあり、したがって、再帰のレベルを文字列の長さに制限しています。

最終的には次のようになります。

/((((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*/
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                    .                                      \
                       .
                       .

... 671088640回繰り返され、合計で12750684161のネスティングが行われました。これは、23回のネスティングの私の以前の試みを恥ずべきことです。驚くべきことに、perlはこれを抑制しさえしません（再び、メモリ使用量は約1.3GBで安定しています）が、最初のprintステートメントが発行されるまでにかなり時間がかかります。

以下の私の以前の分析から、数字出力の数の順になることを結論付けることができる（！12750684161）^671088640、kは！ある左階乗のK（参照A003422を）。これを（k-1）として近似できます！、これは厳密に小さくなりますが、大きさは同じです。

そして、wolframalphaに尋ねると：

...私のスコアはほとんど変わりません。少なくとも10↑↑5になると確信していました。10↑↑4と10↑↑4.1の違いは、あなたが思っているよりもはるかに大きいと思います。

Perl-スコア≈10↑↑4

$_=$^Fx($]<<-$]),/((((((((((((((((((((((.*.*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Perlの正規表現エンジンを乱用して、いくつかの組み合わせを行います。埋め込みコードブロック
(??{print})は、その結果を正規表現に直接挿入します。以来$_完全に構成されており2、S（との結果がprint常にある1）、これは一致していない、とかなりの数がありますそれらのすべての可能な組み合わせを介して、紡績Perlを送信しないことができます。

使用される定数

• $^F-最大システムファイルハンドル、通常は2。
• $]-perlのバージョン番号5.016002。

$_この場合、671088640回2繰り返される数字を含む文字列です。メモリ使用量は約1.3GBで一定で、出力はすぐに開始されます。

分析

P _k（n）をprintステートメントの実行回数として定義してみましょう。ここで、kはネストの数、nは文字列の長さに1を加えたものです（n + 1を書く気がしないからです）どこにでも）。

(.*.*)*
P ₂（n） = [ 2、8、28、96、328、1120、3824、13056、... ]

((.*.*)*)*
P ₃（n） = [ 3、18、123、900、6693、49926、372615、2781192、... ]

(((.*.*)*)*)*
P ₄（n） = [ 4、56、1044、20272、394940、7696008、149970676、2922453344、... ]

((((.*.*)*)*)*)*
P ₅（n） = [ 5、250、16695、1126580、76039585、5132387790、346417023515、23381856413800、... ]

(((((.*.*)*)*)*)*)*
P ₆（n） = [ 6、1452、445698、137050584、42142941390、12958920156996、... ]

((((((.*.*)*)*)*)*)*)*
P ₇（n） = [ 7、10094、17634981、30817120348、53852913389555、... ]

一般に、式は次のように一般化できます。

どこ

つまり、左階乗のk個未満のすべての階乗の合計すなわち、K（参照A003422を）。

閉じたフォームを判別できませんでした D _kとE _kのが、それを観察すれば、それほど重要ではありません。

そして

23のネスティングにより、次のようなおおよそのスコアが得られます。

これは実際にはほぼ正確なはずです。

ただし、これを視覚化が少し簡単な表記法にするには、内部指数の基数を概算できます。

そして、指数自体：

そして、wolframalphaに尋ねます：

10↑↑4を呼び出して終了することもできます。

Javascript、10↑↑↑↑210

100文字：

z=~~Math.E+'';o={get f(){for(i=z;i--;)z+=i}};o.f;for(i=z;i--;)for(j=z;j--;)for(k=z;k--;)o.f;alert(z)

最大限に反復することfが最適な方法であるという観察に基づいて、13 回のf呼び出しをf、を呼び出すzたびに（f増加を続けながらz）呼び出す3レベルのネストされたループに置き換えました。

私は一枚の紙で分析的にスコアを推定しました。誰かがそれを見たいと思ったら入力します。

改善されたスコア：10↑↑13

再び100文字のJavascript

z=~~Math.E+'';__defineGetter__('f',function(){for(i=z;i--;)z+=i});f;f;f;f;f;f;f;f;f;f;f;f;f;alert(z)

これにより、元の回答が3つの方法で改善されます。

1. zグローバルスコープで定義することで、o.z毎回入力する必要がなくなります。

2. グローバルスコープ（ウィンドウ）でゲッターを定義し、のf代わりに入力することができo.fます。

3. より多くの反復を行うことfは、より大きな数で開始するよりも価値があります。したがって、(Math.E+'').replace('.','')（= 2718281828459045、27文字）の代わりに（= 2、11 ~~Math.E+''文字）を使用し、回収された文字を使用してfより多くの呼び出しを行います。

以下でさらに分析されるように、各反復は、大きさMのオーダーの数から、大きさ10 ^Mのオーダーのより大きな数を生成するため、このコードは各反復後に生成します

1. 210〜O（10 ²）
2. O（10 ^{10 2}）〜O（10↑↑2）
3. O（10 ^10↑↑2）= O（10↑↑3）
4. O（10 ^10↑↑3）= O（10↑↑4）
5. O（10 ^10↑↑4）= O（10↑↑5）
6. O（10 ^10↑↑5）= O（10↑↑6）
7. O（10 ^10↑↑6）= O（10↑↑7）
8. O（10 ^10↑↑7）= O（10↑↑8）
9. O（10 ^10↑↑8）= O（10↑↑9）
10. O（10 ^10↑↑9）= O（10↑↑10）
11. O（10 ^10↑↑10）= O（10↑↑11）
12. O（10 ^10↑↑11）= O（10↑↑12）
13. O（10 ^10↑↑12）= O（10↑↑13）

スコア：~10 ^{10 10 10 10 16} ≈10↑↑6.080669764

正確に100文字のJavascript：

o={'z':(Math.E+'').replace('.',''),get f(){i=o.z;while(i--){o.z+=i}}};o.f;o.f;o.f;o.f;o.f;alert(o.z)

それぞれo.fがwhileループを起動し、合計5ループになります。最初の反復のみの後、スコアはすでに10 ^{42381398144233621を超えてい}ます。2回目の反復までに、Mathematicaは結果の桁数さえ計算できませんでした。

コードのウォークスルーは次のとおりです。

初期化

から小数点を削除して、2718281828459045から始めMath.Eます。

反復1

数字の減少シーケンスを連結し、

• 2718281828459045
• 2718281828459044
• 2718281828459043
• ...
• 3
• 2
• 1
• 0

新しい（巨大な）番号を作成するには、

• 271828182845904527182818284590442718281828459043 ... 9876543210。

この数字には何桁ありますか？まあ、それはの連結です

• 1718281828459046 16桁の数字
• 900000000000000 15桁の数字
• 90000000000000 14桁の数字、
• 9000000000000 13桁の数字
• ...
• 900 3桁の数字
• 90 2桁の数字
• 10桁の1桁の数字

Mathematicaでは、

In[1]:= 1718281828459046*16+Sum[9*10^i*(i+1),{i,-1,14}]+1
Out[1]= 42381398144233626

つまり、2.72⋅1042381398144233625 ^です。

唯一の最初の反復の後、私のスコアを作る2.72⋅10 ^{42381398144233619}。

反復2

しかし、それはほんの始まりに過ぎません。今、巨大な数字から始めて、手順を繰り返します！つまり、数字の減少するシーケンスを連結し、

• 271828182845904527182818284590442718281828459043 ... 9876543210
• 271828182845904527182818284590442718281828459043 ... 9876543209
• 271828182845904527182818284590442718281828459043 ... 9876543208
• ...
• 3
• 2
• 1
• 0

だから、私の新しいスコア、Mathematicaは何ですか？

In[2]:= 1.718281828459046*10^42381398144233624*42381398144233625 + Sum[9*10^i*(i + 1), {i, -1, 42381398144233623}] + 1

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

Out[2]= Overflow[]

反復3

繰り返す。

反復4

繰り返す。

反復5

繰り返す。

分析スコア

最初の反復では、2718281828459045から始まる減少シーケンスの連結の桁数を計算しました。

• 1718281828459046 16桁の数字
• 900000000000000 15桁の数字
• 90000000000000 14桁の数字、
• 9000000000000 13桁の数字
• ...
• 900 3桁の数字
• 90 2桁の数字
• 10桁の1桁の数字

この合計は、式で表すことができます。

ここで、Zは、開始番号を示す（例えば、 2718281828459045）とO _Zは、大きさの順序を表す（例えば 15、以降Zは〜10 ¹⁵）。有限和の等価性を使用すると、上記は明示的に次のように表現できます。

9≈10を取ると、さらに減少します

そして、最後に、用語を展開し、大きさの順序を減らして順序付けすると、

私たちは、結果の大きさの順にだけ興味があるので、今、、の代用させZを「の大きさの順に番号をO _Z、」すなわち 10 ^{O _Z} -

最後に、2番目と3番目の用語はキャンセルされ、最後の2つの用語は削除できます（サイズは簡単です）。

そこから最初の用語が勝ちます。

再表示、fの大きさの順に番号をとりMとの大きさの順に約番号を生成するM（10 ^M）。

最初の反復は、手で簡単に確認できます。2718281828459045は15桁のf数値です。したがって、15（10 ¹⁵）〜10 ¹⁶の桁の数値を生成する必要があります。実際、生産数は、以前から、2.72⋅10 ^{42381398144233625} -つまりは、10ある^{42381398144233625}〜10 ^{10 16}。

MがM（10 ^M）の重要な要素ではないことに注意して、各反復の結果の大きさの順序は、単純な四分割のパターンに従います。

1. 10 ¹⁶
2. 10 ^{10 16}
3. 10 ^{10 10 16}
4. 10 ^{10 10 10 16}
5. 10 ^{10 10 10 10 16}

LaTeXソース

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\sum_{k=0}^{\mathcal{O}_Z-1}{(9\cdot10^k(k+1))}+1

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\frac{10-\mathcal{O}_Z10^{\mathcal{O}_Z}+(\mathcal{O}_Z-1)10^{\mathcal{O}_Z+1}}{9}+10^{\mathcal{O}_Z}

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+1

Z\mathcal{O}_Z+Z-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}+10^{\mathcal{O}_Z}-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}

APL、10↑↑3.4

ここに私の修正された試みがあります：

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

完了までに非常に長い時間がかかりますが、現在のハードウェアで実行される100文字/バイト*プログラム（無視できる量のメモリと通常の32ビットint変数を使用）。

実際にAPLインタープリターで実行すると、数字の印刷が開始されます。完了できる場合、10×123456789 ⁴⁴桁の数字が印刷されます。

したがって、スコアは10である^{10×123456789 44} /100 ³ ≈10 ^{10 353} ≈10↑↑3.406161

説明

• ⎕D に事前定義された定数文字列です '0123456789'
• n←⍎⎕Dnをその文字列で表される数値に定義します：123456789（<2 ^31であり、したがってループ制御変数として使用できます）
• {⍞←⎕D} 改行なしで、10桁を標準出力に出力します
• {⍞←⎕D}⍣nn回実行します（⍣「パワーオペレータ」です。*、/、^でもありません。数学演算ではないため、一種のループです）
• {⍞←n}⍣n⍣n前の操作をn回繰り返すので、10桁の数字をn ²回印刷します
• {⍞←n}⍣n⍣n⍣nそれを行いますnは³回
• ⍣nそこに44 を収めることができたので、文字列のn ⁴⁴倍を印刷します'0123456789'。

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*：APLは、上位128のバイト値にAPLシンボルをマッピングし、独自の（レガシー）シングルバイト文字セットに書き込むことができます。したがって、スコアリングの目的のために、ASCII文字とAPLシンボルのみを使用する N文字のプログラムは、Nバイト長と見なすことができます。}

Haskell、スコア：（2 ^{2 2 65536} -3）/ 1000000≈2↑↑7≈10↑↑4.6329710779

o=round$sin pi
i=succ o
q=i+i+i+i
m!n|m==o=n+i
 |n==o=(m-i)!i
 |True=(m-i)!(m!(n-i))
main=print$q!q

このプログラムは、100バイトの純粋なHaskellコードです。4番目のアッカーマン数を出力し、最終的にはプロセスで宇宙のすべての利用可能なエネルギー、物質、時間を消費します（したがって、ソフト制限の5秒をわずかに超えます）。

Python、2↑↑11/830584≈10↑↑8.632971（クヌース上矢印表記）

print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))

おそらく、これを正常に実行するのに十分なメモリを備えたコンピューターはありませんが、それは実際にはプログラムのせいではありません。最小システム要件が満たされていれば、機能します。

はい、これはブール値のビットシフトを行っています。 このコンテキストでTrue強制さ1れます。Pythonには任意の長さの整数があります。

GolfScript 3.673e + 374

'~'(.`*

*は、乗算ではなく、文字列の繰り返しを示すため、許可されていると思います。

説明：'~'(スタックに126（ASCII値 "〜"）を残します。次に、数値をコピーして文字列に変換し、文字列を126回繰り返します。これにより、126126126126...どちらが約になり1.26 e+377ます。解決策は7文字なので、で割って7^3およそのスコアを求めます3.673e+374

Ruby、確率的に無限、54文字

x='a'.ord
x+=x while x.times.map(&:rand).uniq[x/x]
p x

xは97に初期化されます。次に、次の手順を繰り返します。0〜1のx個の乱数を生成します。それらがすべて同じ場合、xを終了して出力します。それ以外の場合は、xを2回繰り返します。Rubyの乱数の精度は17桁であるため、任意のステップで終了する確率は（10e17）^ xの1です。したがって、nステップ内で終了する確率は、x = 1〜nの（1 / 10e17）^（2 ^ n）の合計であり、1 / 10e34に収束します。これは、どんなに大きな数字であっても、このプログラムがより小さな数字を出力することは圧倒的に少ないことを意味します。

今、もちろん、哲学的な問題は、任意のnに対してステップnで終了する可能性が10 ^ 34分の1未満のプログラムは、終了すると言うことができるかどうかです。無限の時間と電力だけでなく、プログラムに、終了の確率が減少する速度を超える速度で増加する速度で実行する能力が与えられていると仮定すると、実際には、任意に1に近い時間tで終了する。

GolfScript、≈F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（126）））））））））

これは、@ Howardによる別の回答から恥知らずに改作され、@ Peter Taylorによる提案が組み込まれています。

[[[[[[[[[,:o;'~'(]{o:?~%{(.{[(]{:^o='oo',$o+o=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:f~]f]f]f]f]f]f]f]f

GolfScriptについての私の理解は限られていますが*、^上記のand 演算子はOPで禁止されている算術演算子ではないと考えています。

（@Howardが彼自身のバージョンを提出したい場合、私は喜んでこれを削除します。

このプログラムは、fは約だ数を計算_{ε 0}（fは _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（126）））））） ））） -のFの9倍反復_{ε 0} - Fの_{ε 0は}関数である急成長階層グッドスタイン関数とでほぼ同じ速度を成長させます。（_{fε 0}フリードマンのn（k）の機能とk倍コンウェイのの成長率は矢もfは非反復1つだけと比較して、事実上重要ではないチェーンほど早く伸びる_{ε 0}。）

dc、100文字

[lnA A-=ilbA A-=jlaSalbB A--SbLndB A--SnSnlhxlhx]sh[LaLnLb1+sbq]si[LbLnLasbq]sjFsaFsbFFFFFFsnlhxclbp

十分な時間とメモリがあれば、これは15↑¹⁶⁶⁶⁶⁶⁵15前後の数値を計算します。私はもともとハイパーオペレーション機能を実装していましたが、このチャレンジに必要なキャラクターが多すぎたためn = 2, b = 0、n >= 3, b = 0条件を削除し、条件をに変えn = 1, b = 0ましたn >= 1, b = 0。

ここで使用される算術演算子は、加算と減算のみです。

編集：コメントで約束されているように、ここにこのコードの機能の内訳があります：

[            # start "hyperoperation" macro
lnA A-=i     # if n == 0 call macro i
lbA A-=j     # if b == 0 call macro j
laSa         # push a onto a's stack
lbB A--Sb    # push b-1 onto b's stack
LndB A--SnSn # replace the top value on n with n-1, then push n onto n's stack
lhxlhx       # call macro h twice
]sh          # store this macro in h

[            # start "increment" macro (called when n=0, the operation beneath addition)
LaLnLb       # pop a, b, and n
F+sb         # replace the top value on b with b+15
q            # return
]si          # store this macro in i

[            # start "base case" macro (called when n>0 and b=0)
LbLnLa       # pop b, n, and a
sb           # replace the top value on b with a
q            # return
]sj          # store this macro in j

Fsa          # store F (15) in a
Fsb          # store F (15) in b
FFFFFFsn     # store FFFFFF "base 10" (150000+15000+1500+150+15=1666665) in n
lhx          # load and call macro h
lbp          # load and print b

前述のように、これは、乗算およびそれ以上の基本ケースが加算の基本ケースで置き換えられるという点で、ハイパーオペレーション機能とは異なります。このコードはa*0 = a^0 = a↑0 = a↑↑0 ... = a数学的に正しいa*0 = 0およびの代わりに動作しますa^0 = a↑0 = a↑↑0 ... = 1。結果として、本来あるべき値よりも少し高い値を計算しますが、大きな数字を目指しているので大したことではありません。:)

編集：のインクリメントを実行するマクロで、偶然に数字がコードに滑り込んだことに気付きましたn=0。これを 'F'（15）に置き換えることで削除しました。これは、各増分操作を15でスケーリングする副作用があります。これが最終結果にどの程度影響するかはわかりませんが、おそらくもっと大きくなっています。

実行時の制限はもうありませんか？OK

プログラムは最新のコンピューターで実行できる必要がありますか？

64ビットを使用する両方のソリューションlongはコンパイルするため、64ビット整数になります。

C：10 ^{（2 64 -1）2 64}より大きい、それ自体は10 ^{10 355393490465494856447≈10} ↑↑4.11820744より大きい

long z;void f(long n){long i=z;while(--i){if(n)f(n+~z);printf("%lu",~z);}}main(){f(~z);}

88文字。

これらの数式を簡単にするために、を使用しますt = 2^64-1 = 18446744073709551615。

mainはf、のパラメータで呼び出しますt。これはt、値を出力するたびに時間をループし、のパラメータでt呼び出しfますt-1。

印刷された合計桁数：20 * t。

これらの各呼び出しfは、のパラメーターでt-1を繰り返しt、値を出力tし、のパラメーターでfを呼び出しますt-2。

印刷された総桁数： 20 * (t + t*t)

3ビット整数に相当するものを使用してこのプログラムを試しました（i = 8メインコールを設定しましたf(7)）。printステートメントに6725600回ヒットしました。それでうまくいく7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7ので、これが完全なプログラムの最終カウントだと思います。

印刷された総桁数： 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

（2 ⁶⁴ -1）^{2 64の}計算方法がわかりません。その合計は（2 ⁶⁴）^{2 64}より小さく、この計算を行うには2の累乗が必要です。したがって、（2 ⁶⁴）^{2 64 -1を}計算します。実際の結果よりも小さいですが、2の累乗なので、他の結果と比較するために10の累乗に変換できます。

誰かがその合計を実行する方法、または（2 ⁶⁴ -1）^{2 64}を10 ⁿに変換する方法を知っていますか？

20 * 2 ^ 64 ^（2 ^ 64-1）
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^（64 * 18446744073709551615）
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
その指数を10の対数底2で除算して、指数の底を10のべき乗に切り替えます。
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

しかし、覚えておいてください、それは印刷された桁数です。整数の値は10の累乗なので、10 ^ 10 ^ 355393490465494856447

このプログラムのスタック深度は2 ^ 64です。これは、ループカウンターを保存するための2 ^ 72バイトのメモリです。これは40億テラバイトのループカウンターです。2 ^ 64レベルの再帰でスタックに追加される他のことは言うまでもありません。

編集：誤字のペアを修正し、log2（10）により正確な値を使用しました。

編集2：ちょっと待って、printfが外にあるループがあります。それを修正しましょう。初期化を追加しましたi。

編集3：やめて、前の編集で数学を台無しにしました。一定。

これは最新のコンピューターで実行されますが、すぐには終了しません。

C：10 ^ 10 ^ 136≈10↑↑3.329100567

#define w(q) while(++q)
long a,b,c,d,e,f,g,x;main(){w(a)w(b)w(c)w(d)w(e)w(f)w(g)printf("%lu",~x);}

98文字。

これは、反復ごとに1回、ビット単位のゼロの逆数、2 ^ 64-1を出力します。2 ^ 64-1は20桁の数字です。

桁数= 20 * (2^64-1)^7 = 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187500

プログラムの長さを100文字に丸め、スコア=印刷数/ 1,000,000

スコア= 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187494

R- 49 41文字のコード、4.03624169270483442 * 10 ^ 5928≈10↑↑2.576681348

set.seed(T)
cat(abs(.Random.seed),sep="")

[ここだけを再現して開始]を出力します：

403624169270483442010614603558397222347416148937479386587122217348........

ECMAScript 6-10 ^ 3↑↑↑↑3/884736

（3↑↑↑↑3はG（1）で、G（64）はグラハムの数です）

u=-~[v=+[]+[]]+[];v+=e=v+v+v;D=x=>x.substr(u);K=(n,b)=>b[u]?n?K(D(n),K(n,D(b))):b+b+b:e;u+K(v,e)

出力：10 ^ 3↑↑↑↑3

ヒント：

Gは、G（64）がグラハムの数である関数です。入力は整数です。出力は0で記述された単項文字列です。簡潔にするために削除されました。

KKnuthの上矢印関数a↑ ⁿ b（aは暗黙的に3）。入力はn（単項文字列）およびb（単項文字列）です。出力は単項文字列です。

u 「1」です。

v 「0000」、またはG（0）

e 「000」です。

C

（ダレン・ストーンに謝罪）

long n,o,p,q,r;main(){while(--n){while(--o){while(--p){while(--q){while(--r){putchar('z'-'A');}}}}}}

n = 2 ^ 64桁の数字（9 ...）

l = 100文字のコード

スコア≈1e + 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936570570≈10↑↑3.2974890744

[スコア= n ^ 5 / l ^ 3 =（10 ^（2 ^ 320）-1）/（100 ^ 3）=（10 ^ 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576-1）/（10 ^ 6）]

私はこの答えに対して容赦なくむち打たれるに値するが、抵抗することはできなかったことに注意してください。明らかな理由から、私と同じようにstackexchangeで行動することはお勧めしません。:-P

編集：次のようなものに行く誘惑に抵抗することはさらに難しいだろう

long n;main(){putchar('z'-'A');putchar('e');putchar('+');while(--n){putchar('z'-'A');}

...しかし、意図されているが不特定のルールは、数字を構成する数字の全体を印刷する必要があるということだと思います。

新ルビー：スコア〜F _{ω ^ω2 +1}（126 ² 2 ¹²⁶）

ここで、f _α（n）が急成長階層です。

n=?~.ord;H=->a{b,*c=a;eval"b ?H[b==$.?c:[b==~$.?n:b-(b<=>$.)]*n+c]:p(n+=n);"*n};eval"H[~n];".*n*n<<n

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

これら*nは単なる文字列と配列の乗算であるため、問題ありません。

未ゴルフコード：

n = 126
H =-> a {
    b, *c = a
    n.times{
        case b
        when nil
            puts(n += n)
        when 0
            H[c]
        when -1
            H[[n]*n+c]
        else
            H[[b.-b<=>0]*n+c]
        end
    }
}
(n*n<<n).times{H[~n]}

ここでb.-b<=>0は整数を返し1に近い0よりはb。

説明：

nのすべての呼び出しの開始時に印刷しHます。

H[[]]doubles n（ntimes）、つまりn = n<<n。

H[[0,a,b,c,...,z]]呼び出しH[[a,b,c,...,z]]（n回）。

H[[k+1,a,b,c,...,z]]呼び出しH[[k]*n+[a,b,c,...,z]]（n回）、ここで[k]*n = [k,k,...,k]。

H[[-1,a,b,c,...,z]]呼び出しH[[n]*n+[a,b,c,...,z]]（n回）。

H[[-(k+1),a,b,c,...,z]]呼び出しH[[-k]*n+[a,b,c,...,z]]（n回）。

H[k] = H[[k]]。

私のプログラムはを初期化してn = 126から、H[-n-1]126 ² 2 ¹²⁶回呼び出します。

例：

H[[0]]H[[]]適用するn = n<<n（n回）を呼び出します。

H[[0,0]]H[[0]]（n回）を呼び出します。

H[[1]]H[[0]*n]（n回）を呼び出します。

H[[-1]]H[[n]*n]（n回）を呼び出します。

H[[-1,-1]]H[[n]*n+[-1]]（n回）を呼び出します。

H[[-3]]H[[-2]*n]（n回）を呼び出します。

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

他のクールなものについては改訂版をご覧ください。

Haskell-結果に20回適用されるアッカーマン関数-99文字

これは、ackermann関数に基づいて思いつくことができる最高のhaskellソリューションです。nmのソリューションとの類似点に気付くかもしれません。i= round $ log piはそこからインスピレーションを受け、残りは偶然です：D

i=round$log pi
n?m|m<i=n+i|n<i=i?(m-i)|True=(n-i)?m?(m-i)
a n=n?n
b=a.a.a.a
main=print$b$b$b$b$b$i

ackermann関数をそれ自体で20回実行します。

• 1、
• 3、
• 61、
• a（61,61）、
• a（a（61,61）、a（61,61））---これを₂（61）または₄（1）と呼びます---
• ₃（61）
• ...
• ₁₈（61）、または₂₀（1）。これは約g _18であると思います（以下を参照）。

推定に関しては、ウィキペディアは言います：

a（m、n）= 2↑ ^m-2（n + 3）-3

このことから、a3（1）= a（61,61）= 2↑ ⁵⁹ 64 + 3がわかります。これは、g3 = 3↑ ⁴ 3 より明らかに大きいです。その後、各レベルは次の処理を実行します（_nの重要でない定数を破棄します）。

• g _n = 3↑ ^{g _n-1} 3
• a _n〜 = 2↑ ^{a _n-1}（a _n-1）

これらがほぼ等しい場合、₂₀（1）〜= g ₁₈です。a _nの最終項（a _n-1）は3よりもはるかに大きいため、潜在的にg ₁₈よりも高くなります。1回の反復でそれが後押しされ、レポートが返されるかどうかを判断できるかどうかを確認します。

x86マシンコード-100バイト（MSDOS .comファイルとしてアセンブル）

注：ルールを少し曲げることがあります

このプログラムは、2 ^{（65536 * 8 + 32）}ナインを出力し、スコアを （10 ^{2 524320} -1）/ 1000000にします。

カウンタとして、このプログラムはスタック全体（64kiB）と2つの16ビットレジスタを使用します。

アセンブルされたコード：

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

アセンブリ：

ORG 0x100

SECTION .TEXT
            mov bh, [b_ss]
            mov dx, ss
            mov [b_ss], dx
            mov [b_sp], sp
            mov ss, bx
            xor sp, sp
            mov bx, inthackdst
            inc bx
            mov ah, [inthacksrc]
            mov [bx], ah
            mov al, [nine]
            xor ah, ah
            inc ah
            inc ah
            inc ah
inthacksrc: adc ah, ah
            inc ah
            add ah, ah
            xor cx, cx
fillstack:  push cx
nine:       cmp sp, cx
            jnz fillstack
regloop:    xor dx, dx
dxloop:     xor cx, cx
cxloop:     xor bx, bx
inthackdst: int '?'
            inc cx
            jnz cxloop
            inc dx
            jnz dxloop
            pop cx
            inc cx
            jnz restack
popmore:    cmp sp, dx
            jz end
            pop cx
            inc cx
            jz popmore
restack:    push cx
            xor cx, cx
            cmp sp, dx
            jnz restack
            jmp regloop
end:        mov sp, [b_sp]
            mov ax, [b_ss]
            mov ss, ax
            ret

b_ss:       dw 'SX'
b_sp:       db 'X'

C

ファイルサイズは45バイトです。

プログラムは次のとおりです。

main(){long d='~~~~~~~~';while(--d)printf("%ld",d);}

そして、生成される数は10 ^（10 ^（10 ^ 1.305451600608433））より大きくなります。

std outにリダイレクトしたファイルは現在16 Gbを超えており、まだ成長しています。

より良いコンピューターがあれば、プログラムは妥当な時間で終了します。

私のスコアは、倍精度浮動小数点では計算できません。

GNU Bash、10 ^40964096²/ 80 ^ 3≈10↑↑2.072820169

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C count=$C$C|tr \\$((C-C)) $SHLVL'

合理的なシステムではC = 4096。SHLVLは小さな正の整数です（通常、/ bin / shがbashかどうかに応じて1または2になります）。

64ビットUNIXのみ：

スコア：〜10 ^（40964096409640964096 * 40964096409640964096）/ 88 ^ 3

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C$C$C$C count=$C$C$C$C$C|tr \\$((C-C)) $SHLVL'

C、10 ^ 10 ^ 2485766≈10↑↑3.805871804

unsigned a['~'<<'\v'],l='~'<<'\v',i,z;main(){while(*a<~z)for(i=l;printf("%u",~z),i--&&!++a[i];);}

258048符号なし整数の配列を作成します。unsigned longは、プログラムが長すぎるため、符号なしlongにはできません。未定義の動作を使用したくないため、これらは署名されていません。このコードは適切なC（main（）からの戻りがないことを除く）であり、通常のマシンでコンパイルおよび実行されますが、長時間実行されますが。このサイズは、非ASCII文字を使用せずに法的に表現できる最大のサイズです。

最後の要素から開始して配列をループします。の数字を出力し2^32-1、要素をインクリメントし、要素が0にラップされていない場合はループをドロップします。このようにして(2^32 - 1)^254048 = 2^8257536、ループを行い、毎回10桁を出力します。

以下は、より限られたデータ範囲での原理を示すサンプルコードです。

#include <stdio.h>
unsigned int a[3],l=3,i,f;

int
main(int argc, char *argc){
        while (*a<4) {
        for (i = l; i-- && (a[i] = (a[i] + 1) % 5) == 0;);
            for (f = 0; f < l; f++)
                printf("%lu ", a[f]);
            printf("\n");
        }
}

結果は、およそ10 ^ 10 ^ 2485766を100万で割ったもので、それでもなおおよそ10 ^ 10 ^ 2485766です。

Powershell（2.53e107976 /72³= 6.78e107970≈10↑↑1.701853371）

これには、実行に5秒以上かかります。

-join(-split(gci \ -r -EA:SilentlyContinue|select Length))-replace"[^\d]"

現在のドライブ上のすべてのファイルのバイト長を取得して連結します。正規表現は、数字以外の文字を取り除きます。

Python 3、スコア= ack（126,126）/ 100 ^ 3

g=len('"');i=ord('~');f=lambda m,n:(f(m-g,f(m,n-g))if n else f(m-g,g))if m else n+g
print(f(i,i))

f関数はackermann関数で、呼び出すのにちょうど十分なスペースがあります。

編集：以前は「else n + 1」でしたが、これはチャレンジルールに違反していました。SimplyBeautiful Artへの称賛です。

JavaScript 98文字

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(m.E<<k<<k<<k<<m.E);i+=j)a+=k;alert(a)

2.718e + 239622337≈10↑↑2.9232195202を生成します

2.718e + 239622331≈10↑↑2.9232195197をわずかに上回るスコアの場合

ブラウザがクラッシュすることなく作成できる最大のサイズです。

（console.log（a）は完全な出力を表示します）

これらを実行しないでください：

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(k<<k<<k<<k<<k<<k<<k);i+=j)a+=k;alert(a)

2.718 + e121333054704≈10↑↑3.0189898069（別名2.718 * 10 ^（1.213 * 10 ^ 12）を出力して、長い回答と比較します：

より極端なバージョン、ブラウザがクラッシュしなかった場合：（80文字）

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<k;i+=j)a+=k;alert(a)

e * 10 ^（10 ^ 19）≈10↑↑3.106786869689と同じサイズの数値を作成します

編集：更新されたコードの元のソリューションは2.718e + 464のみを生成しました

Python 3：98文字、≈10↑↑256

変数引数関数の使用：

E=lambda n,*C:E(*([~-n][:n]+[int("%d%d"%(k,k))for k in C]))if C else n;print(E(*range(ord('~'))))

事実上、Eは最初の引数をデクリメントし、残りの引数を増やします。ただし、引数に-1を入れる代わりに引数をドロップします。すべてのサイクルが最初の引数を減らすか、引数の数を減らすので、これは終了することが保証されています。使用される増加関数はint（ "％d％d"％（k、k））で、k ** 2 + 2 * kと10 * k ** 2 + kの間の結果を返します。私のコードでは*記号を使用していますが、乗算ではありません。規則の明確なポイントはシンボル自体ではなく特定の操作を制限することだったので、可変数の引数を扱うために使用されています。

Eがどれだけ速くなるかのいくつかの例：

E(1,1) = 1111
E(0,1,1) = E(11,11) = (approx) 10^8191
E(1,1,1) = E(1111,1111) = (approx) 10^(10^335)
E(2,1,1) = E(11111111,11111111) = (approx) 10^(10^3344779)

そのうちの最初の2つだけが、妥当な時間内にコンピューターで実行可能です。

次に、EがE(*range(ord('~')))- によって呼び出されます。

E(0,1,2,3,4,5, ... ,121,122,123,124,125)

私はこれがどれほど大きいか完全にはわかりません（私はそれを無駄に近づけようと試みてきました）-しかしそれが〜本当に〜大きいことは明らかです。

例として、約12サイクルで、結果は次のようになります：（技術的にはもう少し）

E(2**27211,2**27211,2**27212,2**27212,2**27212,2**27212,2**27213,2**27213,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636)

結果の推定：

増加するステップをで近似するlambda k: 10 * k**2と、関数は次のように記述できます。

E(n, C₁, C₂, ... Cᵥ) ≈ E(10^(n²/2) ⋅ C₁²ⁿ, 10^(n²/2) ⋅ C₂²ⁿ, ... 10^(n²/2) ⋅ Cᵥ²ⁿ)
                     ≈ E(10^((10^(n²/2) ⋅ C₁²ⁿ)²/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )
                     ≈ E(10^((10^n² ⋅ C₁⁴ⁿ)/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )

ここで行っている関連することは、10の累乗の塔を構築することです。そのため、最終的なスコアは10↑↑256に近似できます。

（部分的ではあるが）より良い結果推定：

これは、10 * k**2他の推定と同じものを使用します。

E(0, b) = 10 * b**2
E(1, b) = 10 * (10 * b**2)**2 = 10 * 100 * b**4 = 10**3 * b**4
E(2, b) = 10 * (10**3 * b**4)**2 = 10 * (10**6 * b**8) = 10**7 * b**8
E(a, b) = 10**(2**(a+1)-1) * b**(2**(a+1))

以前の推定では、次のようになります。

E(a, b) = 10**(a**2/a) * b**(2*a)

それが使用するため、実際の値よりも著しく小さいa**2代わりに2**a10および使用するa*2代わりに2**aBのため。

C（スコア≈10 ^ 20 000 000 000≈10↑↑3.005558275）

• 最大20 GBの出力
• 41文字（41 ^ 3は何も意味しない）

main(){for(;rand();printf("%d",rand()));}

rand()出力にもかかわらず、シード関数がないため、決定論的です。