以下の要件を満たす最短のプログラム（バイト単位で測定される長さ）を作成します。

• 入力なし
• 出力は標準出力へ
• 実行は最終的に終了します
• 出力バイトの合計数がGrahamの数を超えています

プログラムは、無制限のリソースにアクセスできる理想的なコンピューター^1で「正常な」終了まで実行され、必要に応じて（構文を変更せずに）共通のプログラミング言語が変更されると仮定します。これらの仮定のため、これを一種のゲダンケン実験と呼ぶかもしれません。

物事を始めるために、急成長している階層で_{fω+ 1}（99）を計算する73バイトのRubyプログラムを以下に示します。

f=proc{|k,n|k>0?n.times{n=f[k-1,n]}:n+=1;n};n=99;n.times{n=f[n,n]};puts n

¹編集：より正確には、既存のシステムを使用して、ストレージサイズに上限がないように変更します（ただし、常に有限です）。命令の実行時間は変更されることは想定されていませんが、マシンは動作寿命に上限がないという点で理想的であると想定されています。

GolfScript（49 47文字）

4.,{\):i\.0={.0+.({<}+??\((\+.@<i*\+}{(;}if.}do

多くの説明については、ワームの寿命を参照してください。要するに、これはfより数大きな印刷_{ω ^ω}（2）。

ハスケル、 _{59 57 55} 63

(f%s)1=s;(f%s)n=f.(f%s)$n-1
main=print$((flip((%3)%(3^))3)%4)66

仕組み：%単純に関数を取得しn-1、その上で時間を合成しsます。つまり%3、関数fを受け取り、nそれfを3 n-1回連続して適用することに等しい関数を返します。この高階関数のアプリケーションを反復すると、急成長する関数のシーケンスが得られます。累乗法から始まり、まさにクヌース矢印フォレストのサイズのシーケンスなど
((%3)%(3^))1 n = (3^)n     = 3ⁿ = 3↑n
((%3)%(3^))2 n = ((3^)%3)n = (3↑)ⁿ⁻¹ $ 3 = 3↑↑n
((%3)%(3^))3 n = (((3^)%3)%3)n = (3↑↑)ⁿ⁻¹ $ 3  = 3↑↑↑n
です。((%3)%(3^))n 3これは3 ↑ⁿ 3、グラハムの数の計算に表示されるものです。あとは、関数を作成するだけです(\n -> 3 ↑ⁿ 3) ≡ flip((%3)%(3^))34回（計算の開始点となる矢印の数）の上に64回以上、グラハムの数よりも大きい数を取得します。の対数（とてつもなく遅い関数です！）g₆₅がまだより大きいことは明らかなg₆₄=Gので、その数を出力すると、出力の長さはを超えGます。

⬛

Pyth、29 28バイト

M?*GHgtGtgGtH^ThH=ZTV99=gZTZ

ハイパーオペレーションのラムダを定義し、再帰的に呼び出します。グラハムの数の定義と似ていますが、値が大きくなっています。

この：

M?*GHgtGtgGtH^3hH

ほぼPythonに等しいラムダを定義します

g = lambda G, H:
  g(G-1, g(G, H-1)-1) if G*H else 3^(H+1)

これにより、ハイパーオペレーション関数g（G、H）= 3↑ ^{G + 1}（H + 1）が得られます。
したがって、たとえば、g（1,2）= 3↑ ² 3 = 7,625,597,484,987で、ここでテストできます。

V<x><y>本体をy、x回数実行するループを開始します。
=gZTここでのループの本体は、次と同等ですZ=g(Z,10)

コード：

M?*GHgtGtgGtH^3hH=Z3V64=gZ2)Z

グラハムの数を与えて、64回以上ハイパーオペレーションを再帰的に呼び出す必要があります。

しかし、私の答えでは、1桁Tを10に初期化されたで置き換え、再帰の深さを99に増やしました。Graham 配列表記を使用すると、Grahamの数は[3,3,4,64]で、プログラムはより大きな[10,11,11,99]を出力します。また)、ループを閉じて1バイトを節約するものも削除したため、99回の反復で連続する各値を出力します。

Python（111 + n）、n = length（x）

これは回答者のRubyプログラムほど短くはありませんが、この可能性を排除するためにとにかく投稿します。

Ackermann関数を使用し、Ackermann関数の別の呼び出しからの値であるmおよびnでAckermann関数を呼び出し、1000回再帰します。

これはおそらくグラハムの数よりも大きいでしょうが、正確な長さを誰も知らないので、私にはわかりません。大きくなければ簡単に拡張できます。

x=999
b='A('*x+'5,5'+')'*x
def A(m,n):n+1 if m==0 else A(m-1,A(m,n-1)if n>0 else 1)
exec('print A('%s,%s')'%(b,b))

ルビー、54 52 50バイト

f=->b{a*=a;eval"f[b-1];"*b*a};eval"f[a];"*a=99;p a

ルビー、85 81 76 71 68 64 63 59 57バイト

f=->a,b=-a{eval"a*=b<0?f[a,a]:b<1?a:f[a,b-1];"*a};p f[99]

f（a + 1）> _{fω+ 1}（a）の非常に急速に成長する階層。

Ruby、61バイト

f=->a,b=-a{a<0?9:b==0?a*a:f[f[a-1,b],b>0?b-1:f[a,b+1]]};f[99]

基本的には、ねじれのあるアッカーマン関数です。

ルビー、63 59バイト

n=99;(H=->a{b,*c=a;n.times{b ?H[[b-1]*n*b+c]:n+=n}})[n];p n

別のRuby、74 71バイト

def f(a,b=a)a<0?b:b<0?f(a-1):f(a-1,f(a,b-1))end;n=99;n.times{n=f n};p n

基本的にアッカーマンは自分自身に対して99回機能します。

Python：85

f=lambda a,a:a*a
exec'f=lambda a,b,f=f:reduce(f,[a]*b,1)'*99
exec'f('*64+'3'+',3)'*64

おそらく74 +にlength(X)短縮できます：

f=lambda a,a:a*a
exec'f=lambda a,b,f=f:reduce(f,[a]*b,1)'*int('9'*X)
f(3,3)

X結果のハイパーオペレーション3, 3がGrahamsの数値よりも大きくなるような適切な大きな数値はどこにありますか（この数値が99999999999それより小さい場合、いくつかのバイトが保存されます）。

注：pythonコードは対話型インタープリターで実行されるため、結果はstdoutに出力されると想定してい9ます。それ以外の場合は、の呼び出しの各ソリューションにバイトを追加しますprint。

Javascript、83バイト

別のアッカーマン関数ソリューション。

(function a(m,n,x){return x?a(a(m,n,x-1),n,0):(m?a(m-1,n?a(m,n-1):1):n+1)})(9,9,99)

JavaScript、68バイト、ただしES6を使用するには競合しない

a=(x,y)=>y?x?a(a(x-1,y)*9,y-1):a(9,y-1):x;b=x=>x?a(9,b(x-1)):9;b(99)

a 関数は、基数9の上矢印表記に似ています。

       /a(a(x-1,y)*9,y-1)  x>0, y>0
a(x,y)=|a(9,y-1)           x=0, y>0
       \x                  y=0

b関数：b（x）= b ^x（9）。

b(99)〜fは_{ω+ 1}（99）はグラハム数<Fと比較して、_{ω+ 1}（64）。