BigNumベイクオフリブート


12

皆さんの中には、BigNum Bakeoffに精通している人もいるかもしれません。目標は、多少の制約と理論的条件、たとえばプログラムを実行できるコンピューターの下で、出力が最大になるCプログラムを作成することで多少要約できます。

同じ精神で、私はすべての言語に開かれた同様の課題を提起しています。条件は次のとおりです。

  • 最大512バイト

  • 最終結果はSTDOUTに出力する必要があります。これがあなたのスコアです。複数の整数が出力される場合、それらは連結されます。

  • 出力は整数でなければなりません。(注:Infinityは整数ではありません。)

  • 10を超える組み込み定数はありませんが、数字/桁は問題ありません(たとえば、Avogadroの定数(組み込み定数として)は無効ですが、10000は無効です)。

  • 実行するのに十分なリソースが提供されたら、プログラムを終了する必要があります

  • 実行するのに十分なリソースが提供される場合、印刷出力は確定的でなければなりません。

  • プログラムを実行するのに十分な整数またはbigintが提供されます。たとえば、プログラムで10 1,000,000より小さい数値に基本操作を適用する必要がある場合、これを実行しているコンピューターは少なくとも10 1,000,000までの数値を処理できると想定できます。(注:最大10 2,000,000までの数値を処理するコンピューターでプログラムを実行することもできます。そのため、コンピューターが処理できる最大整数を呼び出しても、確定的な結果は得られません。)

  • 5秒未満でプログラムの実行を完了するのに十分な計算能力が提供されます。(プログラムがコンピューターで1時間実行されていて、すぐに終了しない場合でも心配する必要はありません。)

  • 外部リソースはないので、組み込みでない限り、そのアッカーマン関数をインポートすることを考えないでください。

すべての魔法のアイテムは一時的に寛大な神から借りています。

限界が不明で非常に大きい

ここで、B³Fは、次の基本シーケンスを持つChurch-Kleene序数です。

B³F[n] = B³F(n), the Busy Beaver BrainF*** variant
B³F[x] = x, ω ≤ x < B³F

リーダーボード:

  1. 単に美しいアート、ルビー F ψ 0(X(Ω M + X(Ω M + 1 Ω M + 1))+ 29(9 9 9

  2. スティーブン・H、Pyth F ψ(Ω Ω)+ω²+ 183(256 27!

  3. 漏洩ヌン、Pythonの3 F ε 0(9 9 9

  4. fejfo、Pythonの3 F ω ω 6(F ω ω 5(9e999))

  5. スティーブンH、Pythonの3 F ω ω +ω²(9 9 9 99

  6. 単に美しいアート、ルビー F ω+ 35(9 9 99

  7. i ..、Python 2、f 3(f 3(141))

いくつかのサイドノート:

スコアを確認できない場合、リーダーボードに掲載できません。そのため、プログラムを少し説明することを期待したいかもしれません。

同様に、番号の大きさがわからない場合は、プログラムを説明してください。それを解決しようとします。

あなたが使用している場合はローダの数のプログラムの種類を、私はと呼ばれる別のカテゴリにあなたを配置します「未知の限界が非常に大規模な」 Loaderの数が上限」の急成長の階層の面で拘束非自明なを持っていないので、標準の基本シーケンス。

番号は、急成長している階層を介してランク付けされます

急成長する階層を使用して非常に大きな数を概算する方法を学びたい人のために、私はそのためだけにDiscordサーバーをホストしています。チャットルーム:Ordinalityもあります。

同様の課題:

印刷可能な最大数

TREE(3)よりも大きい数のゴルフ

出力サイズがGrahamの数を超える最短の終了プログラム

小さな値に対して急速に成長する階層を出力するいくつかの簡単なプログラムを見たい人のために、ここにあります:

Ruby:急成長している階層

#f_0:
f=->n{n+=1}

#f_1:
f=->n{n.times{n+=1};n}

#f_2:
f=->n{n.times{n.times{n+=1}};n}

#f_3:
f=->n{n.times{n.times{n.times{n+=1}}};n}

#f_ω:
f=->n{eval("n.times{"*n+"n+=1"+"}"*n);n}

#f_(ω+1):
f=->n{n.times{eval("n.times{"*n+"n+=1"+"}"*n)};n}

#f_(ω+2):
f=->n{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}};n}

#f_(ω+3):
f=->n{n.times{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}}};n}

#f_(ω∙2) = f_(ω+ω):
f=->n{eval("n.times{"*n+"eval(\"n.times{\"*n+\"n+=1\"+\"}\"*n)"+"}"*n);n}

行くためにf_xf_(x+1)、我々は一つのループを追加しますn.times{...}

それ以外の場合、前のすべての例に対して対角化しています

f_ω(1) = f_1(1)
f_ω(2) = f_2(2)
f_ω(3) = f_3(3)

f_(ω+ω)(1) = f_(ω+1)(1)
f_(ω+ω)(2) = f_(ω+2)(2)
f_(ω+ω)(3) = f_(ω+3)(3)


数字は組み込み定数としてカウントされますか?
PyRulez

3
@CloseVotersこれはどのように広すぎるのでしょうか...さて、ユーザーに無限の数で1つの数値を出力するように依頼することは、ユーザーに無限に多くのタスクの1つを選択するように依頼することとは異なります。この質問を公平にするために、ユーザーにも同じことをするように依頼してください。4近い投票が既に広すぎると
...-user202729

1
@Οurousはい、あなたはそう思うかもしれません。しかし、より高速な計算を含む、より多くのリソースがプログラムに与えられた場合でも、出力は決定論的でなければならないことに注意してください。
単に美しいアート

1
他のコメントセクションで、境界付きのBrainfuck Busy Beaver関数が指数関数的であると思う理由を述べましたが、より一般的には、Church-Kleene序数がどのコンピュータープログラムにとっても適切なレベルになるとは思いません。 。プログラムでコーディングできる関数は計算可能であるため、十分に強力な再帰音響理論の証明可能な再帰関数に分類する必要があります。その理論は、再帰的証明理論順序を持ち、その関数は、合理的な基本シーケンスを仮定して、FGHでその順序より下になります。
ディードリット

1
もちろん、実際のBusy Beaver関数をプログラムにコーディングすることはできません(ハイパーコンピューティング言語は別として)。また、プログラムできる制限付きBusy Beaver関数は、必然的に成長が遅くなります。
ディードリット

回答:


7

ルビー、F ψ 0(X(Ω M + X(Ω M + 1 Ω M + 1))+ 29(9 9 9

ここで、Mは最初のMahloの「序数」、Xはカイ関数(マーロ崩壊関数)、ψは序数崩壊関数です。

f=->a,n,b=a,q=n{c,d,e=a;!c ?[q]:a==c ?a-1:e==0||e&&d==0?c:e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:n<1?9:!d ?[f[b,n-1],c]:c==0?n:[t=[f[c,n],d],n,c==-1?[]:d==0?n:[f[d,n,b,t]]]};(x=9**9**9).times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{h=[];x.times{h=[h,h,h]};h=[[-1,1,[h]]];h=f[h,p x*=x]until h!=0}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}

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

コード内訳:

f=->a,n,b=a,q=n{          # Declare function
                c,d,e=a;          # If a is an integer, c=a and d,e=nil. If a is an array, a=[c,d,e].compact, and c,d,e will become nil if there aren't enough elements in a (e.g. a=[1] #=> c=1,d=e=nil).
                        !c ?[q]:          # If c is nil, return [q], else
                                a==c ?a-1:          # If a==c, return a-1, else
                                          e==0||e&&d==0?c:          # If e==0 or e is not nil and d==0, return c, else
                                                          e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:          # If e is not nil, return an array inside an array, else
                                                                                             n<1?9:          # If n<1, return 9, else
                                                                                                   !d ?[f[b,n-1],c]:          # If d is nil, return [f[b,n-1],c], else
                                                                                                                    c==0?n:          # If c==0, return n, else
                                                                                                                           [t=[f[c,n],d],n,c==-1?[]:d==0?n:[f[d,n,b,t]]]          # t=[f[c,n],d]. If c==-1, return [t,n,[]], else if d==0, return [t,n,n], else return [t,n,[f[d,n,b,t]]].
                                                                                                                                                                        };          # End of function
                                                                                                                                                                          (x=9**9**9)          # Declare x
                                                                                                                                                                                     x.times{...}          # Looped within 33 x.times{...} loops
                                                                                                                                                                                                 h=[];          # Declare h
                                                                                                                                                                                                      x.times{h=[h,h,h]};          # Nest h=[h,h,h] x times
                                                                                                                                                                                                                         h=f[h,p x*=x]          # Apply x*=x, print x, then h=f[h,x]
                                                                                                                                                                                                                                      until h==0          # Repeat previous line until h==0

数学の内訳:

fa基づいて減少しn,b,qます。

基本的な考え方は、極端にネストしa、それがに減少するまで繰り返し削減することa=0です。簡単にするため、

g[0,n]=n
g[a,n]=g[f[a,n],n+1]

今のところ、心配することはありませんn

任意の整数に対してk、が得られるf[k,n]=k-1ので、

g[k,n]=n+k

その後、任意のdf[[0,d],n]=nがあるので、それを見ることができます

g[[0,d],n]
= g[f[[0,d],n],n+1]
= g[n,n+1]
= n+n+1

私たちは、その後、いずれかのために、持っていますc,d,ef[[c,0,e],n]=f[[c,d,0],n]=c。例えば、

g[[[0,d],0,e],n]
= g[f[[[0,d],0,e]],n+1]
= g[[0,d],n+1]
= (n+1)+(n+1)+1
= 2n+3

その後c,d,e、前のケースに該当しないようなものがありf[[c,d,e],n]=[[c,d,f[e,n]],f[d,n],e]ます。これが複雑になり始めるところです。いくつかの例:

g[[[0,d],1,1],n]
= g[f[[[0,d],1,1],n],n+1]
= g[[[0,d],1,0],0,[0,d]],n+1]
= g[f[[[0,d],1,0],0,[0,d]],n+1],n+2]
= g[[[0,d],1,0],n+2]
= g[f[[[0,d],1,0],n+2],n+3]
= g[[0,d],n+3]
= (n+3)+(n+3)+1
= 2n+7

#=> Generally g[[[0,d],1,k],n] = 2n+4k+3

g[[[0,d],2,1],n]
= g[f[[[0,d],2,1],n],n+1]
= g[[[[0,d],2,0],1,[0,d]],n+1]
= g[f[[[[0,d],2,0],1,[0,d]],n+1],n+2]
= g[[[[[0,d],2,0],1,n+1],0,[[0,d],2,0]]],n+2]
= g[f[[[[[0,d],2,0],1,n+1],0,[[0,d],2,0]]],n+2],n+3]
= g[[[[0,d],2,0],1,n+1],n+3]
= ...
= g[[[0,d],2,0],3n+6]
= g[f[[[0,d],2,0],2n+6],3n+7]
= g[[0,d],3n+7]
= (3n+7)+(3n+7)+1
= 6n+15

そこから急速に立ち上がります。興味深い点:

g[[[0,d],3,[0,d]],n] ≈ Ack(n,n), the Ackermann function
g[[[0,d],3,[[0,d],0,0]],63] ≈ Graham's number
g[[[0,d],5,[0,d]],n] ≈ G(2^^n), where 2^^n = n applications of 2^x, and G(x) is the length of the Goodstein sequence starting at x.

最終的に、より多くのf関数の引数と配列のケースを導入することで、ほとんどの名前付きの計算可能な表記法を上回ることができます。いくつかの特に知られているもの:

g[[[0],3,[0,d]],n] ≈ tree(n), the weak tree function
g[[[[0],3,[0,d]],2,[0,d]],n] ≈ TREE(n), the more well-known TREE function
g[[[[0,d]],5,[0,d]],n] >≈ SCG(n), sub-cubic graph numbers
g[[[0]],n] ≈ S(n), Chris Bird's S function

1
通常の説明?
CalculatorFeline

これはまだあなたの最大の定義された数ですか?そう見えます!
ThePlasmaRailgun

3

Pyth、F ψ(Ω Ω)+ω 2 183(〜256 27!

=QC`.pGL&=^QQ?+Ibt]0?htb?eb[Xb2yeby@b1hb)hbXb2yeb@,tb&bQ<b1=Y_1VQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQ.v%%Fms["*s[.v"*\\^2d"\"%s"*\\^2d"\"")Qs["=Y.v+*"*\\^2Q"\"*3]"*\\^2Q"\"Q\YuyFYHpQ)

空でない入力が必要ですが、その値は使用されません。

説明(新しい、実際に得点の高いバージョンの場合):

=QC`.pG                   Sets the value of the autofill variable to app. 256^27!  
                                  27! ~= the number of characters in the string
                                  containing all permutations of the alphabet. 
                                  We interpret that string as a base-256 number.
       L                  Define a function y(b,global Q):
        &=^QQ             Set Q to Q^Q and:
        ?+Ibt]0           If (?) the variable (b) is (I)nvariant on (+)adding itself
                             to the empty array (i.e. if it's an array itself):
               ?htb        If the second element of b is not 0:
                   ?eb         If the last element is not 0
                       [Xb2yeby@b1hG)   return [b with its last element replaced with y(b[-1]), y(b[1]), b[0]]
                     hb                 else return b[0]
                 Xb2yeb     else return b with its last element replaced with y(b[-1])
           @,tb&bQ<b1      If b isn't an array,return:
                               either b-1 if it's a standard ordinal (1 or more)
                               or Q if b is ω
                               or 0 if b is 0
 =Y_1                          Set the global variable Y to -1 (representing ω)
 VQ                        Q times, do (the rest of the explanation):
  VQVQ....VQ               Iterate from 0 to Q-1 183 times, each subiteration
                              reading the most recent value of Q when it starts:
  .v%%Fms["*s[.v"*\\^2d"\"%s"*\\^2d"\"")Q
                            Iterate from 0 to Q-1 Q times, each subiteration 
                               reading the most recent value of Q when it starts:                        
 s["=Y.v+*"*\\^2Q"\"*3]"*\\^2Q"\"Q
                             Y = [Y,Y,Y] Q times, stacking with previous iterations.
 uyFYHpQ)                    Run y_x(Y) for x incrementing until y_(x-1)(Y)=0

このサイズを計算するのは非常に困難です。これは主に1日の終わりであり、急成長する階層やQが何回通過するかを把握しようとする方法にあまり精通していないためです。y()絞り器。 現在、序数についてはよく知っていますが、プログラムの再帰的な定義で表される序数の値を計算する方法はまだわかりません。Discordサーバーに参加しますが、それは仮名であり、実際の名前にはリンクされません。

残念ながら、急成長している階層についてはほとんど知らないので、Rubyの答えにすでに負けている可能性があります。私に伝えるのは難しいです。 Rubyの答えを破ったかもしれませんが、100%確信はありません。¯\ _(ツ)_ /¯


私が正しく理解している場合、あなたのスコアは、おそらく27^^^27^^27^^4、またはの球場のどこかにありf<sub>4</sub>(27^^27^^4)) ≈ f<sub>4</sub>(f<sub>3</sub>(f<sub>3</sub>(19)))ます。
単に美しいアート

昨日考えていたはずの小さな変更を行いましたが、どういうわけか、単にy操作するのではy(Q-1)なく、操作するために再帰を行いましたQ。これはスコアにどのように影響しますか?
スティーブンH.

1
何が起こっているのか完全にはわかりません。DOES y(Q) = L(y(Q-1))、それ自体が?
単に美しいアート

1
これをチャットルームでやるほうが幸運だと思う。
スティーブンH.

@SimplyBeautifulArtこの種の小さなため、急成長している階層表記を使用しないことがおそらく最善です。
PyRulez

3

Pyth、F 3 +σ -12(256 26

ここで、σ M [n]の順のビジービーバー関数Σであり、m上で呼び出さn:σ M [N] =Σ M(N)。順序-1は、ここのBusy Beaverが真のチューリングマシンで呼び出されているのではなく、Q要素の有限なラッピングテープでの近似であることを示すことです。これにより、これらのプログラムで停止する問題を解決できます。

=QCGM.x-Hlhf!-/T4/T5.__<GH0M.x+Hlhf!-/T4/T5._>GHlGL=.<QC`m.uX@[XN2%h@N2l@N1XN2%t@N2l@N1XN1X@N1@N2%h@@N1@N2l@N1XN1X@N1@N2%t@@N1@N2l@N1XW!@@N1@N2N2nFKtPNXW@@N1@N2N2gFK)@hNeN3%heNlhNd)bLym*F[]d^UQQUQUld)^U6QJ"s*].v*\mQ"
.v+PPPP*JQ"+*\mQ\'

TL; DRは、長さQのすべての可能なBrainF ** kプログラムを作成し、整数の最大値がQでテープ長がQである環境でそれらを実行し、これらの操作からのすべての状態を一緒にコンパイルすることです。追記(そのだ3+Q)は、Fの規模で上方繰り返すω 2

もっと何かをしたいのであれば、私はまだ〜半分のキャラクターと一緒に仕事をしますが、これがどこにあるかが分かるまではそのままにしておきます。


リーダーボードでσのより良い説明をしました。
単に美しいアート

4
この特定のBusy Beaver機能がそれほど急速に成長しているように思えません。0からQの間のQ整数の制限では、(Q + 1)^ Qの可能なテープとプログラム内のQの可能な位置のみがあるため、最大でQ *(Q + 1)^ Qの可能な状態実行中のプログラム。したがって、プログラムはQ *(Q + 1)^ Qステップ内で停止するか、まったく停止しない必要があります。可能なプログラムの数も、指数の上限によって制限されます。したがって、このBusy Beaver関数には指数関数的な上限があり、最終的な関数は$ f _ {\ omega ^ 2} $のオーダーになるようです。
Deedlit

2

python、f 3(f 3(141))、512バイト

import math
def f(x):
    return math.factorial(x)  
x=9
for j in range(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(x))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))):
    x=f(x)
print x

これは実際には有効な答えではありませんが、とにかく投稿したかったです。簡単な要約:

import math # imports the factorial function
def f(x):
    return math.factorial(x) # shortens the factorial operation
x=9 # sets x to highest available number
for j in range(f(...f(x)...)): # repeats * A LOT *
    x=f(x) # does the factorial of x
print x # outputs the result

とにかく、この答えが技術的に合法かどうかはわかりませんが、書くのは楽しかったです。コードで見つかったエラーは自由に編集してください。


これはf_3(9)であり、間違いなく合法だと思います。for j in range(f(x)): for j in range(f(x)): x = f(x)ただし、を入れ子にすると、はるかに大きな数になります。チャットに参加して、理由を話し合ってください!
スティーブンH.17年

なぜそれが有効な答えではないのですか?
単に美しいアート

質問はあまり得られなかったので、自分が正しいと思ったものを作りました。
i ..

1

ルビー、おそらく〜fω+ 35(9 9 99

G=->n,k{n<1?k:(f=->b,c,d{x=[]
c<G[b,d]?b-=1:(x<<=b;c-=G[b,d])while c>=d
x<<[c]}
x=f[n-1,k,b=1]
(b+=1;*u,v=x;x=v==[0]?u:v==[*v]?u<<[v[0]-1]:u+f[n-1,G[v,b]-1,b])while x[0]
b)};(n=9**9**99).times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n=G[n,n]}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}};p n

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

おおよその数学の説明:

以下は上記のプログラムとほぼ同じですが、わかりやすくするために簡略化されています。

G(0,k) = k 基本機能です。

評価するためにG(n,k)、私たちはそれをとっkて書きG(n-1,1) + ... + G(n-2,1) + ... + G(0,1)ます。

その後のすべての変更G(x,1)「内のをG(x,2)S」と減算1結果全体から。

を使用して上記の形式で書き換えG(x,2)、where を使用し、x<n残りを最後に残します。繰り返し、に変更G(x,2)するG(x,3)など。

結果が到達したら、-1ベースを返します(bそれはにありG(x,b)ます)。

例:

G(1,1):

1: 1 = G(0,1)
2: G(0,2) - 1 = 1
3: 1 - 1 = 0
4: 0 - 1 = -1      <----- G(1,1) = 4

G(1,2):

1: 2 = G(0,1) + G(0,1)
2: G(0,2) + G(0,2) - 1 = G(0,2) + 1
3: G(0,3) + 1 - 1 = G(0,3)
4: G(0,4) - 1 = 3
5: 3 - 1 = 2
6: 2 - 1 = 1
7: 1 - 1 = 0
8: 0 - 1 = -1      <----- G(1,2) = 8

G(1,3):

1: 3 = G(0,1) + G(0,1) + G(0,1)
2: G(0,2) + G(0,2) + G(0,2) - 1 = G(0,2) + G(0,2) + 1
3: G(0,3) + G(0,3)
4: G(0,4) + 3
5: G(0,5) + 2
6: G(0,6) + 1
7: G(0,7)
8: 7
9: 6
10:5
11:4
12:3
13:2
14:1
15:0
16:-1      <----- G(1,3) = 16

G(2,5):

1: 5 = G(1,1) + G(0,1)
2: G(1,2) + 1
3: G(1,3)
4: G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + 3
5: G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + 2
6: G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + 1
...
1024: -1      <----- G(2,5) = 1024

いくつかの数学をやって、私はそれを見つけました

G(1,n-1) = 2ⁿ
G(2,n+6) ~ 2^G(2,n),  large enough n.

そしてそれを超えて、少し毛むくじゃらになる傾向があります。

一般的に、我々は持っています

G(n,k+G(n-1,1)) ~ G(n-1,G(n,k)), large enough n.

1

パイソン3、F ω ω +ω*ω(9 9 9 99

from functools import*
h=lambda a,x,b:h(h(a,x,b-1),x-1,a)if x*b else a+b
def f(*x):
    if(any(x[:2]):return reduce(lambda y,z:h(z,y,f(x[0],x[1]-1,*x[2:])),x[::-1])if x[0]*x[1]else(f(x[0]-1,f(x[0]-1,x[0],*x[2:]))if x[0]>x[1]else(f(x[1]-1,f(*([x[1]-1]*2+x[2:])),*x[2:])))
    for a,k in enumerate(x):if k:return f(*[f(*[k]*a,k-1,*x[a+1:])]*a,k-1,*x[a+1:])
    return 0
x,s,g,e,r,z=9**9**9**99,"f(*[%s]*%s)",lambda a,b:a%((b,)*a.count("%")),"x*=eval(\"%s\");","x","x=g(e,g(reduce(g,[s]*x,s),r));"
print(exec(z*x)or eval(r))

すぐに説明します。


1

Pythonの3〜Fのε 0(9 9 9

N=9**9**9
def f(a,n):
 if a[0]==[]:return a[1:]
 if a[0][0]==[]:return[a[0][1:]]*n+a[1:]
 return [f(a[0],n)]+a[1:]
a=eval("["*N+"]"*N)
n=2
while a:a=f(a,n);n+=1
print(n)

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


N = 9 ** 9e99はわずかに大きくなければならない
fejfo

誰の答えよりも?
リーキー修道女

最初のようなものをN = 9 ** 9e99に置き換えると、9e99> 9 ** 9であるため、出力がわずかに大きくなるはずです。もちろん、それはあなたの答えです。
fejfo

@fejfo私のランキングは変わらないということです。
リーキー修道女

2
それは問題ですか?
fejfo

1

Python 3、323バイト、g 9e9(9)

exec("""a=`x:9**x
n=`a,f:`x:a and n(a-1,f)(f(x))or x
c=`n:`l:l[~n](l)
e=`x:n(x,c(0))([x,`l:[a(l[0]),n(*l)],c(0),`l:[a(l[0]),l[2](l[:2])[1]]+map(`i:l[1]((l[0],i))[1],l[2:])]+list(map(c,range(a(x),1,-1))))[1]
f=`l:[l[1](l[0]),e(l[1](l[0]))(l)[1]]
g=`x:e(x)((x,f))[1]((x,a))[1](x)
print(n(9e9,g)(9))""".replace('`','lambda '))

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

説明

Python 3は真に再帰的な言語です。つまり、関数自体を呼び出すことができるだけでなく、関数は他の関数を入力関数または出力関数として使用することもできます。関数を使用して自分自身を改善することが、私のプログラムのベースになっています。

f = lambda x、a:[a(x)、e(x)((x、a))[1]]

定義

a(x)=9^x
b(x,f)=a(x), f^x
c(n)(*l)=l[~n](l)
c(0)=c0 <=> c0(…,f)=f(…,f)
d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in l
e(x)=c0^x(x,b,c0,d,c(a(x)),c(a(x)-1),c(a(x)-2),…,c(3),c(2),c(1))[1] 
f(x,a)=a(x),e(a(x))(x,a)[1](x)
g(x)=e(x)(x,f)[1](x,a)[1](x)
myNumber=g^9e9(9)

定義の説明

a(x)=9^x aはベース関数です。固定小数点を回避するx> 0 => a(x)> x`であるため、この関数を選択しました。

b(x,f)=a(x), f^xbは一般的な改善関数であり、任意の関数を取り込んで、より良いバージョンを出力します。bはそれ自体にも適用できます。b(x,b)[1]=b^x b(x,b^x)[1]=b^(x*x)

しかし、b改善の力を十分に活用するにはb、bの出力を取得して新しいbとして使用する必要があります。これがc0の機能です。

c0(…,f)=f(…,f)
c0(x,b^x)=b^x(x,b^x)[1]>b^(9↑↑x)

より一般的なc(n)関数は、最後のn個の引数(0から始まる)を使用 c(1)(…,f,a)=f(…,f,a)c(2)(…,f,a,b)=f(…,f,a,b)ます。*llは配列で、l[~n]最後のn個の引数を取ることを意味します

d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in lDの用途は(なぜなら、リストの任意の量で存在することができるの)他の入力機能のすべてをアップグレードするB及びBをアップグレードするC0
d(x,b,c,d)>9^x,b^x,c^x,d^xd²(x,b,c,d)>a²(x), b^(9↑↑x), c^(9↑↑x), d^(9↑↑x)

dはcと組み合わせるとさらに良くなります:
c0²(x,b,c0,d)=d^x(9^x,b^x,c0^x,d^x)=… c0(x,b,c0,d,c1)=c1(x,b,c0,d,c1)=d(x,b,c0,d,c1)=9^x,b^x,c0^x,d^x,c1^x c0²(x,b,c0,d,c1)=c0(9^x,b^x,c0^x,d^x,c1^x)=c1^x(9^x,b^x,c0^x,d^x,c1^x)=…

最後にc(x)を追加すると、より強力になります。最初のc0は常にdのままですc0(x,b,c0,d,c4,c3,c2,c1)=c1(…)=c2(…)=c3(…)=c4(…)=d(x,b,c0,d,cX,cX-1,…,c3,c2,c1)=…
が、2番目のc0 は反復バージョンを後に残します。

c0²(x+1,b,c0,d,c4,c3,c2,c1)
=c0(9^x+1,b^x+1,c0^x+1,d^x+1,c4^x+1,c3^x+1,c2^x+1,c1^x+1)
=c1^x(c2^x(c3^x(c4^x(d^x(9^x+1,b^x+1,c0^x+1,d^x+1,c4^x+1,c3^x+1,c2^x+1,c1^x+1)))))

d^xが最終的に計算さc4れるときはd、次回よりずっと多くの反復バージョンが必要になります。場合はc4^x、最終的に計算されるc3のより多くの反復バージョンがかかりますc4、...
これは反復ための本当に強力バージョンを作成しますd

  1. b使用して改善c0
  2. c0使用して改善b
  3. を使用してネスティングのすべての層を改善しますb 。改善自体が改善されます。つまり、dがさらに繰り返されると、dはより強力になります。

cのこの長いチェーンを作成することが、何をするかe(x)=c0^x(x,b,c0,d,c(a(x)),c(a(x)-1),c(a(x)-2),…,c(3),c(2),c(1))[1]です。
それは単に与えるc0^xことをバイパスするために使用しc0ますd
これ[1]は、最終的にの2番目の出力を返すことを意味しd^…ます。だからb^…

この時点で、入力を増やすことを除いて、e(x)を使用して出力を大幅に増やすことは考えられませんでした。

そのため、より良いベース関数を出力するf(x,a)=a(x),e(a(x))(x,a)[1](x)ためにb^…生成元e(x)を使用し、そのベース関数を使用e(x)してより大きな入力で呼び出します。

g(x)=e(x)(x,f)[1](x,a)[1](x)final e(x)を使用してネストfし、非常に強力な関数を生成します。

FGH近似

この数値をあらゆる種類のFGHで概算するのに助けが必要です。

旧バージョン:F ω ω 6(F ω ω 5 (9e999))、オンラインそれをお試しください! 説明の改訂履歴


実際にはf_1(x) = x+x、しかし、長期的には、これはあまり重要ではありません。
単に美しいアート

基本シーケンスについてもう少し説明していただけますか?
単に美しいアート

@SimplyBeautifulArtええ、はいから変更した後、更新するのを忘れましたx*x
fejfo

@SimplyBeautifulArt私の答えは序数を使用しないので、序数で説明するのは難しいです。私が本当にできるのは、関数の定義とfghの効果の近似値を与えることだけです。例:a2(f_n)~=f_{n+1}
fejfo

1

ルビー、F ε 0 2(5)、271のバイト

m=->n{x="";(0..n).map{|k|x+="->f#{k}{"};x+="->k{"+"y=#{n<1??k:"f1"};k.times{y=f0[y]};y";(2..n).map{|l|x+="[f#{l}]"};eval x+(n<1?"":"[k]")+"}"*(n+2)}
g=->z{t="m[#{z}]";(0...z).map{|j|t+="[m[#{z-j-1}]]"};eval t+"[->n{n+n}][#{z}]"}
p m[5][m[4]][m[3]][m[2]][m[1]][m[0]][g][6]

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

これはm(n)mapに基づいています

説明:

m[0][f0][k] = f0[f0[...f0[k]...]]k繰り返しでf0

m[1][f0][f1][k] = f0[f0[...f0[f1]...]][k]k繰り返しでf0

m[2][f0][f1][f2][k] = f0[f0[...f0[f1]...]][f2][k]k繰り返しでf0

一般的に、m[n]取り込みn+2、引数最初の引数を反復する、f0k(存在する場合)第三引数に得られた関数を適用し、第2の引数上回、および(存在する場合)、次いで第四の引数に得られた関数を適用し、等

m[0][n↦n+1][3] = (((3+1)+1)+1 = 6

一般的に、m[0][n↦n+1] = n↦2n

m[0][m[0][n↦n+1]][3] = m[0][n↦2n][3] = 2(2(2(3))) = 24

一般的に、m[0][m[0][n↦n+1]] = n↦n*2^n

m[1][m[0]][3]
= m[0][m[0][m[0][n↦n+1]]][3]
= m[0][m[0][n↦2n]][3]
= m[0][n↦n*2^n][3]
= (n↦n*2^n)[(n↦n*2^n)[n↦n*2^n(3)]]
= (n↦n*2^n)[(n↦n*2^n)[24]]
= (n↦n*2^n)[402653184]
= 402653184*2^402653184

一般的m[1][m[0]][n↦n+1] = f_ωに、急成長する階層。


g[z] = m[z][m[z-1]][m[z-2]]...[m[1]][m[0]][n↦2n][z]

最終出力は

m[5][m[4]][m[3]][m[2]][m[1]][m[0]][g][6]
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.