100バイト未満で成長が最も遅い関数を作成します


23

あなたの仕事は、成長が最も遅い関数を100バイト以内で作成することです。

プログラムは、入力として非負の整数を受け取り、非負の整数を出力します。プログラムをPと呼びましょう。

次の2つの基準を満たす必要があります。

  • ソースコードは100バイト以下である必要があります。
  • すべてのKに対してNがあり、n> = NごとにP(n)> Kになります。つまり、lim (n->∞) P(n)=∞です。(これが「成長する」ことの意味です。)

「スコア」は、プログラムの基礎となる機能の成長率です。

より具体的には、プログラムPは、すべてのn> = N、P(n)<= Q(n)のようなNがあり、P(n )<Q(n)。どちらのプログラムも他のプログラムより優れている場合、それらは結び付けられます。(本質的に、どのプログラムが遅いかは、lim (n->∞) P(n)-Q(n)の値に基づいています。)

最も遅い成長関数は、前の段落の定義に従って、他のどの関数よりもゆっくり成長する関数として定義されます。

これはであるため、最も遅い成長プログラムが勝ちます!

ノート:

  • スコアリングを支援するために、プログラムが計算する関数を答えに入れてみてください。
  • また、(理論的な)入力と出力をいくつか入れて、どれだけ時間がかかるかを人々に教えてください。


3
効果的な戦略は、急成長する関数を記述し、その逆関数を使用することです。つまり、少なくとも必要な値を生成する最小の入力を見つけます。おそらくこれはだまされているのでしょうか?
-xnor

「より具体的に」段落の3分の1が欠落していました。<これは、Markdownの後に文字が続くことがHTMLタグの始まりであると考えているためです。質問を投稿する前にプレビューしてください:P
ETHproductions

1
どのような大規模な公理を仮定できますか?
ピーターテイラー

1
答えをテストするタイムマシンは提供されていますか?
魔法のタコUr

回答:


13

ハスケル、98バイト、スコア= F ε 0 -1N

_#[]=0
k#(0:a)=k#a
k#(a:b)=1+(k#(([1..k]>>fst(span(>=a)b)++[a-1])++b))
f n=[k|k<-[0..],k#[k]>n]!!0

使い方

これは、ベクレミシェフのワームゲームに関連する非常に急速に成長している関数の逆関数を計算します。その成長率は、に匹敵するF ε 0F αがある急成長している階層とε 0が最初であるイプシロン番号

他の回答と比較するために、注意してください


私はここの説明が好きです。
PyRulez

Googology Wikiの急速に成長する階層への紹介へのリンクを入れることができます
MilkyWay90

18

Brachylog、100バイト

llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll

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

これはおそらく他のいくつかの派手な答えの遅さに近いところではありませんが、誰もこのシンプルで美しいアプローチを試していないとは信じられませんでした。

単純に、入力数の長さを計算し、次にこの結果の長さ、次にこの他の結果の長さを計算します...合計で100回。

これはlog(log(log ... log(x))と同じ速さで増加し、100 base-10ログになります。

数値を文字列として入力する場合、試行できる入力では非常に高速に実行されますが、1を超える結果が表示されることはありません:D


8
純粋な狂気のためだけに+1:o事実:すべてを上限にすると、ゼリーでも機能します。:P
ハイパーニュートリノ

5
2を出力する最初の数は10↑↑99です。
小麦ウィザード

11

JavaScript(ES6)、逆アッカーマン関数*、97バイト

*私が正しければ

A=(m,n)=>m?A(m-1,n?A(m,n-1):1):n+1
a=(m,n=m,i=1)=>{while(A(i,m/n|0)<=Math.log2(n))i++;return i-1}

関数Aアッカーマン関数です。関数aは、逆アッカーマン関数であることになっています。正しく実装した場合、ウィキペディアは、が等しくなる5までヒットしないと述べています。私は周りを取得します。m2^2^2^2^16StackOverflow1000

使用法:

console.log(a(1000))

説明:

アッカーマン関数

A=(m,n)=>                           Function A with parameters m and n
         m?                   :n+1  If m == 0, return n + 1; else,
           A(m-1,n?        :1)       If n == 0, return A(m-1,1); else,
                   A(m,n-1)          return A(m-1,A(m,n-1))

逆アッカーマン関数

a=(m,n=m,i=1)=>{                                                Function a with parameter m, with n preinitialized to m and i preinitialized to 1
                while(A(i,m/n|0)<=Math.log2(n))                 While the result of A(i, floor(m/n)) is less than log₂ n,
                                               i++;             Increment i
                                                   return i-1}  Return i-1

2
ただし、スタックオーバーフローは適切ではありませんか?
-NoOneIsHere

m = 2 ^^ 7まで5にならないというあなたの声明は間違っています。m = 2 ^^ 7-3まで5にヒットしませんが、2 ^^ 7-1では5 です。-3は2 ^^ 7に比べて非常に小さいですが、5A5 = 2 ^^ 7-3 <2 ^^ 7。(^^は
四分割を

8

純粋な悪:評価

a=lambda x,y:(y<0)*x or eval("a("*9**9**9+"x**.1"+",y-1)"*9**9**9)
print a(input(),9**9**9**9**9)//1

eval内のステートメントは、長さが7 * 10 10 10 10 10 10 8.57の文字列を作成します。これは、それぞれが同様の長さの文字列を構築するラムダ関数への呼び出しだけで構成され、最終的に0 になります。これは、以下のEschewメソッドと同じ複雑さを持ちますが、if-or-or制御ロジックに依存するのではなく、巨大な文字列を一緒に壊します(そして、最終的な結果はより多くのスタックを取得しています...おそらく?)。y

yPythonがエラーをスローすることなく提供および計算できる最大値は2です。これは、max-floatの入力を1に戻すのに十分です。

長さ7,625,597,484,987の文字列は大きすぎます:OverflowError: cannot fit 'long' into an index-sized integer

停止する必要があります。

避けるにはMath.log:(問題の)(10th-)ルートに行く、スコア:Y = 1から効果的に区別できない機能。

数学ライブラリをインポートすると、バイト数が制限されます。それをやめて、log(x)関数をほぼ同等のものに置き換えましょう:x**.1ほぼ同じ文字数ですが、インポートを必要としません。どちらの関数も入力に対して準線形出力を持ちますが、x 0.1さらにゆっくりと成長ます。しかし、私たちはあまり気にせず、同じ数の文字を消費しながら大きな数に対して同じ基本成長パターンを持っていることだけを気にします(たとえばx**.9、同じ数の文字ですが、より速く成長するので、まったく同じ成長を示す値です)。

さて、16文字でどうするか。どうでしょう...私たちのラムダ関数を拡張してアッカーマンシーケンスプロパティを持たせますか 多数の回答がこのソリューションに影響を与えました。

a=lambda x,y,z:(z<0)*x or y and a(x**.1,z**z,z-1)or a(x**.1,y-1,z)
print a(input(),9,9**9**9**99)//1

ここでのz**z部分は、との正しい入力に近い場所でこの関数を実行できないようにします。使用できる最大値は9と3で、Pythonがサポートする最大の浮動小数点数であっても、1.0の値を返します(注:while 1.0数値が6.77538853089e-05より大きい場合、再帰レベルを上げると、この関数の出力が1に近づき、1を超えたままになります。一方、前の関数は0に近づき、0を超えたまま値を移動しました。浮動小数点数がすべての重要なビットを失うほど多くの操作が発生します)。yz

0と2の再帰値を持つように元のラムダ呼び出しを再構成します...

>>>1.7976931348623157e+308
1.0000000071

比較は、この関数が返す「1からのオフセット」の代わりに「0からのオフセット」に言及されている場合7.1e-9よりも確実に小さくなっています、6.7e-05

実際のプログラムの基本再帰(z値)は10 10 10 10 1.97レベルの深さで、yが使い果たされるとすぐに10 10 10 10 10 1.97にリセットされるため(初期値9で十分です)発生する再帰の総数を正確に計算する方法すら知りません。数学的知識の終わりに達しました。同様に、**n累乗の1つを初期入力から2 次に移動z**zすることで、再帰の数が改善されるかどうか(逆も同様)かどうかはわかりません。

さらに多くの再帰を使用してさらに遅くすることができます

import math
a=lambda x,y:(y<0)*x or a(a(a(math.log(x+1),y-1),y-1),y-1)
print a(input(),9**9**9e9)//1
  • n//1 -2バイトを節約 int(n)
  • import mathmath.1バイトを節約from math import*
  • a(...) 合計8バイトを節約 m(m,...)
  • (y>0)*x バイト節約しますy>0and x
  • 9**9**994によるカウントバイト増加し、約によって再帰の深さを増加させる2.8 * 10^x場合には、x古い深さ(または大きさグーゴルプレックスに近づい深さ:10 10 94)。
  • 9**9**9e9バイト数を5増やし、再帰深さを非常に大きくします。再帰の深さは10 10 10 9.93になりました。参照のため、googolplexは10 10 10 2です。
  • ラムダ宣言により、追加のステップで再帰が増加m(m(...))a(a(a(...)))ます。コストは7バイトです

新しい出力値(9再帰深度):

>>>1.7976931348623157e+308
6.77538853089e-05

再帰の深さは、同じ入力値を使用した以前の結果と比較した場合を除き、この結果が文字通り意味をなさないレベルまで爆発しました。

  • log25回と呼ばれるオリジナル
  • 最初の改善はそれを81回と呼びます
    • 実際のプログラムでは、1e99それを呼ぶだろう2または10について10 2.3
  • このバージョンは729回呼び出します
    • 実際のプログラムでは、(9呼び出すであろう9 993または弱10 10 95倍)。

ラムダインセプション、スコア:???

ラムダが好きだと聞いたので...

from math import*
a=lambda m,x,y:y<0and x or m(m,m(m,log(x+1),y-1),y-1)
print int(a(a,input(),1e99))

私はこれを実行することさえできません。たった99層の再帰でもオーバーフローをスタックします。

古いメソッド(以下)は(整数への変換をスキップして)戻ります:

>>>1.7976931348623157e+308
0.0909072713593

新しいメソッドは、(完全なgoogolではなく)9層の侵入を使用して戻ります:

>>>1.7976931348623157e+308
0.00196323936205

これは、アッカーマンシーケンスと同様の複雑さで、大きなものではなく小さなものになると思います。

また、ETHproductionsのおかげで、スペースを3バイト節約できたので、これは削除できないことに気づきました。

古い答え:

関数log(i + 1)の整数切り捨ては、ラムダ処理されたラムダを使用して20 25回(Python)繰り返されました。

PyRulezの答えは、2番目のラムダを導入してスタックすることで圧縮できます。

from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(x(x(i)))))
print int(y(y(y(y(y(input()))))))

99使用される100文字。

これにより、元の12に対して20 25の反復が生成されます。さらに、スタックを追加するint()代わりに使用することで2文字を節約floor()できx()ます。ラムダの後のスペースを削除できる場合(現時点では確認できません)、5番目y()を追加できます。可能!

from math完全修飾名(例:)を使用してインポートをスキップする方法がある場合x=lambda i: math.log(i+1))、さらに多くの文字が保存され、別のスタックが可能になりますがx()、Pythonがそのようなことをサポートしているかどうかはわかりません(そうではないと思います)。できた!

これは、本質的にXCKDのブログ投稿で使用されている大きな数字と同じトリックですが、ラムダ宣言のオーバーヘッドにより3番目のスタックが排除されます。

from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(i)))
z=lambda i:y(y(y(i)))
print int(z(z(z(input()))))

これは、計算されたスタックの高さ2ラムダを超える3ラムダで可能な最小の再帰です(ラムダを2呼び出しに減らすと、スタックの高さが2ラムダバージョンのスタックの高さより18低くなります)が、残念ながら110文字が必要です。


参考までに、私はトッププログラムで103バイトをカウントします
-ETHproductions

@ETHproductionsおっと。私はおそらくint変換せずにカウントを行い、いくつかのスペアがあると思った。
Draco18s

私は考えてあなたが後のスペース削除することができimportた後、スペースをy<0。Pythonはあまり知らないので、
確信が持て

また、おそらくy<0and x or m(m,m(m,log(x+1),y-1),y-1)別のバイトを節約するために(いつになるxとは0y<0
限り

2
さて... (の値が大きい場合)のlog(x)正のパワーよりもゆっくりと成長し、これはロピタルのルールを使用して示すのは難しくありません。現在のバージョンでは何回も実行されると確信しています。しかし、それらの力は単に増加するため、事実上、これは(非常に小さな)正の力です。つまり、ログ関数の1回の反復よりも実際に速く成長することを意味します(ただし、当然ながら、気付く前に非常に大きな値を調べる必要があります... )。xx(...(((x**.1)**.1)**.1)** ...)x**(.1** (whole bunch))xx
-mathmandan

4

Haskell、100バイト

f 0 a b=a^b
f c a b=foldr(f$c-1)a$[0..b]>>[a]
i=length.show
0#x=i x
y#x=i$(y-1)#x
g=(f(f 9 9 9)9 9#)

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

このソリューションは、急速に成長する関数の逆をとるのではなく、かなり緩やかに成長する関数(この場合length.show)を取り、それを何回も適用します。

最初に関数を定義しますffKnuthの上矢印表記のやつれたバージョンで、少し速く成長します(少し控えめな表現ですが、扱っている数値は非常に大きいため、物事の壮大なスキームでは...)。私たちは、のベースケースを定義f 0 a bすることがa^bまたはaのパワーをb。次に、のインスタンスに(f$c-1)適用される一般的なケースを定義しb+2ますa。コンストラクトのようなKnuth上矢印表記を定義していたb場合、それをのインスタンスに適用しますがab+2実際にはゴルファーであり、成長が速いという利点があります。

次に、演算子を定義します#。 時間a#blength.show適用されるように定義されていますb a。のすべてのアプリケーションはlength.showlog 10にほぼ等しく、これは急速に成長している関数ではありません。

次にg、整数を取り、整数length.show回適用する関数を定義します。具体的にはlength.show、入力に適用されますf(f 9 9 9)9 9。これがどれだけ大きいかに入る前に、見てみましょうf 9 9 9f 9 9 9あるより大きい 9↑↑↑↑↑↑↑↑↑9巨大なマージンにより、(9つの矢印)。9↑↑↑↑↑↑↑↑↑9(9本の矢印)と9↑↑↑↑↑↑↑↑↑↑9(10本の矢印)の間のどこかにあると思います。現在、これは想像を絶するほど大きな数であり、存在するコンピューターに(バイナリ表記で)格納するには大きすぎます。私たちは、そのを取ると私たちの最初の引数として置くことをf私たちの値がより大きくなることを意味9↑↑↑↑↑↑...↑↑↑↑↑↑9してf 9 9 9間にある矢印。この数値はあまりにも大きいため、説明するつもりはありません。正義ではできないと思います。

それぞれlength.show、整数の10を底とする対数にほぼ等しくなります。つまり、ほとんどの数値fは、適用されると1を返します。1以外を返す最小数はで10↑↑(f(f 9 9 9)9 9)、2を返します。それについて少し考えてみましょう。前に定義した数値と同じくらいひどく大きいので、2を返す最小の数値は10の倍数です。Thats 1の後に10↑(f(f 9 9 9)9 9)ゼロが続きます。

n最小の入力を出力する一般的な場合、任意のnはでなければなりません(10↑(n-1))↑↑(f(f 9 9 9)9 9)

このプログラムは、小さなn(宇宙に何倍もある)でも膨大な時間とメモリを必要とすることに注意してください。これをテストする場合f(f 9 9 9)9 9は、はるかに小さい数に置き換えることをお勧めします。必要に応じて1または2を試してください1以外の出力を取得します。


まあ、この種の質問でプログラムを実行するのにどれだけ時間がかかるか、どのくらいのメモリが必要なのか、誰も気にかけないと思います。
単に美しいアート

3

APL、Apply log(n + 1)e^9^9...^9times、チェーンe^9^9...^9の長さはチェーンの長さから1倍を引いたものなどです。

⌊((⍟1+⊢)⍣((*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣⊢)))))))))))))))))))))9))⊢

これを実行する方法はありますか?
-Draco18s

7
@ Draco18sは、実質的に無限のメモリを備えた量子コンピューターを入手し、まともなAPLディストリビューションをインストールし、それが老化防止血清を作成するのを待つ時間を費やします。
ウリエル

ハハ。じゃあ :p
Draco18s

これは無限に近づいていますか?
-PyRulez

@PyRulezは、他のソリューションとまったく同じですが、ログでの反復回数が多くなっています。しかし、より多くの反復は依然として同じクロージングです-同様に指数化することによって拒否されます。私はわからなかったe^n^n...^n私は定数にそれを回したので一部が、それは本当かもしれない
ウリエル

3

MATL、42バイト

iXI:`2*.]X{oXH1H/16L+XKxI:`Yl.]K+XKXdXzXGx

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

このプログラムは、オイラー・マスケローニ定数を使用した調和シリーズに基づいています。私は彼のMATL言語で@LuisMendoのドキュメントを読んでいたので(大文字で書かれているので重要に見えます)、この定数に気づきました。低速成長関数の式は次のとおりです。 enter image description here

ここで、 εk〜1 / 2k

最大10000回の反復をテストし(TIOには大きすぎるため、Matlabで)、スコアが10未満なので、非常に遅いです。

enter image description here

説明:

 iXI      % ask user input (number of iterations)

:`2*.]    % do...while loop, multiply by 2

X{        % convert numeric array into cell array

o         % convert to double precision array 

XH1H/     % copy to clipboard H and divide by 1: now we have an array of 1/2k

16L       % Euler–Mascheroni constant 

+         % addition (element-wise, singleton expansion)

XKxI:`    % save, clear the stack, do...while loop again

  Yl      % logarithm 

  .]      % break, ends the loop

K+XK      % paste from clipboard K, sum all

Xd        % trim: keep the diagonal of the matrix 

Xz        % remove all zeros

XG        % plot (yes it plots on-line too!)

x         % clear the stack
          % (implicit) display

実証的証明:(ln k)+常に赤のln k +γ+ εkが青より上。

enter image description here

(ln k)+ 1 のプログラムは

Matlab、47 18 14バイト

n=input('')
A=(1:n)
for k=1:n
A(k)=log(k)+1
end

N = 100の経過時間が、私のラップトップ上0.208693sであるが、唯一と0.121945sことは興味深いd=rand(1,n);A=d*0;さらに少ないと、と0.112147s A=zeros(1,n)。ゼロがスペースの無駄である場合、速度を節約します!しかし、私はこのトピックから逸​​脱しています(おそらく非常に遅い)。

編集:このMatlab表現を単純化するのを手伝ってくれたStewieに感謝します。

 @(n)log(1:n)+1

高速関数の逆であるだけでなく+1
PyRulez

1
興味深いメモに関する興味深いSO投稿。:)
スティーヴィー・グリフィン

ちなみに、下部にあるスクリプトをゴルフしてください(バイトカウントを含めたため):最後のMATLABスクリプトは、単に:n=input('');A=log(1:n)+1、または名前のない匿名関数(14バイト):@(n)log(1:n)+1です。MATLABについてはわかりませんがA=log(1:input(''))+1、Octaveで動作します...
Stewie Griffin

ありがとう@Stewie n=input('');A=log(1:n)+1、作品@(n)log(1:n)+1(MATLABでハンドルを持つ確かに有効な関数が、入力が求められていない)していない、A=log(1:input(''))+1作品や短縮することができますlog(1:input(''))+1
Jドウ

無名関数で私が意味したのはこれでした。これは、入力をコマンドラインではなく関数引数(メタポスト)として指定することで少なくともこのサイトで)バイトを節約する「通常の」方法です。また、f=それだけにすることが可能なので、カウントする必要はありません@(n)log(1:n)+1が続くans(10)最初の10個の番号を取得します。
スティーヴィーグリフィン

2

Python 3、100バイト

関数log(i + 1)のフロアは、999999999999999999999999999999999999999回反復しました。

上記の数をさらに大きくするために指数を使用できます...

from math import *
s=input()
exec("s=log(s+1);"*99999999999999999999999999999999999)
print(floor(s))

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


2
ソリューションは実際に機能する必要がありますか?これにより、OverflowErrorがスローされます。
ETHproductions

2
このような問題の@ETHproductionsでは、無限のメモリとCPUを搭載したマシン上で、ソリューションが理論的に実行可能であればよいことが一般に受け入れられています。これを試してみたい場合は、99999 ... 999を999程度に
減らしてください

3
では、なぜ使用しないの9**9**9**...**9**9e9ですか?
電卓

2

関数log(i + 1)のフロアが14回繰り返されました(Python)

import math
x=lambda i: math.log(i+1)
print int(x(x(x(x(x(x(x(x(x(x(x(x(x(x(input())))))))))))))))

これがうまくいくとは思っていませんが、良いスタートだと思いました。

例:

  • e ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n->〜n(約n)

int代わりに使用する場合floor、別のものに適合することができますx(
ベータ崩壊

@BetaDecayさて、更新しました。
-PyRulez

1
表現はそうではありe^e^e^e...^nませんか?また、なぜ後にスペースがあり:ますか?
電卓

@CalculatorFelineはコードゴルフではないため、100バイト未満である必要があります。
チョイス

そう?別のx()呼び出しを追加できるようにバイトを保存することの何がそんなに悪いのですか?
電卓

2

ルビー、100バイト、スコア-1 = F ω ω+ 1(N 2

基本的に私の最大数のPrintableから借りた、ここに私のプログラムがあります:

->k{n=0;n+=1 until(H=->z,a=[0]*z{b,*c=a;z.times{z+=b ?H[z,b==1?c:[b>1?b-1:z]*z+c]:z};z};H[n*n]>k);n}

オンラインで試す

基本的にFの逆数計算ω ω+ 1(N 2)で急速に成長階層。最初のいくつかの値は

x[0] = 1
x[1] = 1
x[2] = 1
x[3] = 1
x[4] = 2

そして、それは2非常に長い時間出力し続けます。でもx[G] = 2Gグラハムの数はどこですか。


しかし、fがFGHであるg(f <sub>ω9001CK</ sub> 3)についてはどうですか?
user75200

@ user75200 fghは、計算できない序数に対して十分に定義されていません。
単に美しいアート

FGH 、基本シーケンスを持っているため、計算不可能な序数に対して明確に定義されています。計算できないだけです。
user75200

@ user75200いいえ。基本的なシーケンスは非常にarbitrary意的です。ω9001CK[x] = xを定義して、長さω9001CKの基本シーケンスを得ることができます。これ、有限のxに対して計算可能です、たいてい望んでいないものです。「明確に定義された」とは、誰もが同意できる計算不可能な序数の標準的な基本的な順序がないことを意味しました。
単に美しいアート

基本シーケンスが一意ではないのは事実ですが、可算序数の基本シーケンスの長さはωであると想定されています。
アンデルスカセオルグ

0

Mathematica、99バイト

(±は1バイトと仮定)

0±x_=1±(x-1);y_±0=y+1;x_±y_:=(y-1)±x±(x-1);(i=0;NestWhile[(++i;#±#±#±#±#±#±#±#)&,1,#<k&/.k->#];i)&

最初の3つのコマンドはx±y、評価することを定義しますAckermann(y, x)

関数の結果は、f(#)=#±#±#±#±#±#±#±#値がパラメーターの値に到達する前に1に適用する必要がある回数です。f(#)=#±#±#±#±#±#±#±#(つまり、f(#)=Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[#, #], #], #], #], #], #], #])非常に速く成長するにつれて、関数は非常に遅く成長します。


0

Clojure、91バイト

(defn f (apply +(for[n(range %)](/(loop[r 1 v n](if(< v 1)r(recur(* r v)(Math/log v))))))))

の計算はsum 1/(n * log(n) * log(log(n)) * ...)、私がここから見つけ。しかし、関数の長さは101バイトになったため、明示的な反復回数をドロップし、その数が1より大きい限り反復する必要がありました。次の入力の出力例10^i

0 1
1 3.3851305685279143
2 3.9960532565317575
3 4.232195089969394
4 4.370995106860574
5 4.466762285601703
6 4.53872567524327
7 4.595525574477128
8 4.640390570825608

この修正されたシリーズはまだ分岐していると思いますが、今ではそれを証明する方法を知っています。

3番目のシリーズでは、部分的な用語が10を超える前に、実際には用語のgoogolplex数が必要です。


0

Javascript(ES6)、94バイト

(p=j=>i=>h=>g=>f=>x=>x<2?0:1+p(p(j))(j(i))(i(h))(h(g))(g(f))(f(x)))(_=x=>x)(_)(_)(_)(Math.log)

説明

Id を指す x => x以下をます。

最初に見てみましょう:

p = f => x => x < 2 ? 0 : 1 + p(p(f))(f(x))

p(Math.log) ほぼ等しい log*(x)

p(p(Math.log))ほぼ等しいlog**(x)(あなたが取ることができる回数log*値が最大1になるまでの)。

p(p(p(Math.log))) ほぼ等しい log***(x)

逆アッカーマン関数 alpha(x)は、作成する必要がある最小回数にほぼ等しいp、値が最大1になるまで。

次に使用する場合:

p = g => f => x => x < 2 ? 0 : 1 + p(p(g))(g(f))(f(x))

その後、私たちは書くことができます alpha = p(Id)(Math.log)

しかし、それはかなり退屈なので、レベルの数を増やしましょう。

p = h => g => f => x => x < 2 ? 0 : 1 + p(p(h))(h(g))(g(f))(f(x))

これはalpha(x)、構築する方法と似ていますが、実行する代わりに、実行log**...**(x)しますalpha**...**(x)

なぜここで止まるのですか?

p = i => h => g => f => x => x < 2 ? 0 : 1 + p(p(i))(i(h))(h(g))(g(f))(f(x))

前の関数がの場合f(x)~alpha**...**(x)、これは今~ f**...**(x)です。最終的なソリューションを得るために、このレベルをもう1つ実行します。


p(p(x => x - 2)) ほぼ等しいlog**(x)log*値が最大で1になるまでの回数)」。私はこの声明を理解していません。p(x => x - 2)2値が最大1になるまで減算できる回数」である必要があるように思えます。つまり、p(x => x-2) `は「2で割る」関数でなければなりません。したがってp(p(x => x - 2))、「値が最大で1になるまで2で割ることができる回数」でなければなりません...つまりloglog*またはではなく関数でなければなりませんlog**。おそらくこれを明確にすることができますか?
-mathmandan

@mathmandanは、その行でタイプミスをしたように見えますがp = f => x => x < 2 ? 0 : 1 + p(p(f))(f(x))、そうでpp(f)なく、他の行のように渡されfます。
es1024
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.