Ihre Aufgabe ist es, die am langsamsten wachsende Funktion in nicht mehr als 100 Bytes zu erstellen.

Ihr Programm nimmt eine nicht negative Ganzzahl als Eingabe und gibt eine nicht negative Ganzzahl aus. Nennen wir Ihr Programm P.

Es muss die beiden folgenden Kriterien erfüllen:

• Sein Quellcode muss kleiner oder gleich 100 Bytes sein.
• Für jedes K gibt es ein N, so dass für jedes n> = N, P (n)> K. Mit anderen Worten, lim _{(n-> ∞)} P (n) = ∞ . (Dies ist, was es bedeutet, dass es "wächst".)

Ihre "Punktzahl" ist die Wachstumsrate der zugrunde liegenden Funktion Ihres Programms.

Insbesondere wächst das Programm P langsamer als Q, wenn es ein N gibt, so dass für alle n> = N, P (n) <= Q (n), und es mindestens ein n> = N gibt, so dass P (n) ) <Q (n). Wenn keines der Programme besser ist als das andere, sind sie gebunden. (Welches Programm langsamer ist, hängt im Wesentlichen vom Wert von lim _{(n-> ∞)} P (n) -Q (n) ab.)

Die am langsamsten wachsende Funktion wird gemäß der Definition im vorherigen Absatz als diejenige definiert, die langsamer wächst als jede andere Funktion.

Dies ist Wachstum-Rate-Golf , also gewinnt das am langsamsten wachsende Programm!

Anmerkungen:

• Versuchen Sie, die von Ihrem Programm berechnete Funktion in die Antwort aufzunehmen, um die Bewertung zu erleichtern.
• Setzen Sie auch einige (theoretische) Ein- und Ausgaben ein, um den Leuten eine Vorstellung davon zu geben, wie langsam Sie fahren können.

Haskell, 98 Bytes, Score = f _{ε 0} ⁻¹ ( n )

_#[]=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

Wie es funktioniert

Dies berechnet die Umkehrung einer sehr schnell wachsenden Funktion im Zusammenhang mit Beklemishevs Wurmspiel . Die Wachstumsrate ist vergleichbar mit f _{ε 0} , wobei f _α das ist schnell wachsende Hierarchie und & egr; ₀ ist die erste epsilon Zahl .

Beachten Sie zum Vergleich mit anderen Antworten Folgendes

• Exponentiation ist vergleichbar mit f ₂ ;
• iterierte Exponentiation ( Tetration oder ↑↑ ) ist vergleichbar mit f ₃ ;
• ↑↑ ⋯ ↑↑ mit m Pfeilen ist vergleichbar mit f _{m + 1} ;
• Die Ackermann - Funktion ist vergleichbar mit f _ω ;
• wiederholte Iterationen der Ackermann-Funktion (Konstruktionen wie Grahams Zahl ) werden immer noch von f _{ω + 1} dominiert ;
• und ε ₀ ist die Grenze aller Türme ω ^{ω ω ⋰ ω} .

Brachylog , 100 Bytes

llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll

Probieren Sie es online!

Dies ist wahrscheinlich nicht annähernd die Langsamkeit einiger anderer ausgefallener Antworten, aber ich konnte nicht glauben, dass niemand diesen einfachen und schönen Ansatz ausprobiert hatte.

Wir berechnen einfach die Länge der eingegebenen Zahl, dann die Länge dieses Ergebnisses und dann die Länge dieses anderen Ergebnisses ... insgesamt 100 Mal.

Dies wächst so schnell wie log (log (log ... log (x), mit 100 Base-10-Protokollen.

Wenn Sie Ihre Zahl als Zeichenfolge eingeben , wird dies bei jeder Eingabe, die Sie versuchen könnten, extrem schnell ausgeführt, aber Sie dürfen nicht erwarten, jemals ein höheres Ergebnis als 1: D zu erhalten

JavaScript (ES6), Inverse Ackermann-Funktion *, 97 Bytes

* wenn ich es richtig gemacht habe

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}

Funktion Aist die Ackermann-Funktion . Funktion asoll die inverse Ackermann-Funktion sein . Wenn ich es richtig implementiert habe, sagt Wikipedia, dass es nicht treffen wird, 5bis es mgleich ist 2^2^2^2^16. Ich komme StackOverflowherum 1000.

Verwendung:

console.log(a(1000))

Erklärungen:

Ackermann-Funktion

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))

Inverse Ackermann-Funktion

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

Pure Evil: Eval

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

Die Aussage in der eval erzeugt einen String mit einer Länge von 7 * 10 ^{10 10 10 10 10 8,57} , die aus nichts besteht aber mehr Anrufe an die Lambda - Funktion , von denen jede eine Reihe von Konstrukt wird ähnliche Länge, weiter und weiter , bis schließlich yzu 0. Vordergründig Dies ist genauso komplex wie die unten beschriebene Eschew-Methode, aber anstatt sich auf die If- und / oder Control-Logik zu verlassen, werden nur riesige Strings zusammengestoßen (und das Nettoergebnis wird wahrscheinlich mehr gestapelt ...?).

Der größte yWert, den ich liefern und berechnen kann, ohne dass Python einen Fehler auslöst, ist 2, was bereits ausreicht, um eine Eingabe von max-float in die Rückgabe von 1 zu reduzieren.

Eine Zeichenfolge der Länge 7.625.597.484.987 ist einfach zu groß: OverflowError: cannot fit 'long' into an index-sized integer.

Ich sollte aufhören.

Eschew Math.log: Gehen Sie zur (10.) Wurzel (des Problems), Score: Funktion effektiv nicht unterscheidbar von y = 1.

Durch das Importieren der Mathematikbibliothek wird die Anzahl der Bytes eingeschränkt. Heben wir das auf und ersetzen die log(x)Funktion durch etwas in etwa Äquivalentes: x**.1Und das kostet ungefähr die gleiche Anzahl von Zeichen, erfordert aber keinen Import. Beide Funktionen haben eine sublineare Ausgabe in Bezug auf die Eingabe, aber x ^0.1 wächst noch langsamer . Wir kümmern uns jedoch nicht viel darum, wir kümmern uns nur darum, dass es das gleiche Grundwachstumsmuster in Bezug auf große Zahlen hat, während es eine vergleichbare Anzahl von Zeichen verbraucht (z. B. x**.9die gleiche Anzahl von Zeichen, wächst aber schneller, also dort ist ein Wert, der genau das gleiche Wachstum aufweisen würde).

Was tun mit 16 Zeichen? Wie wäre es mit ... der Erweiterung unserer Lambda-Funktion auf Ackermann-Sequenzeigenschaften? Diese Antwort für große Zahlen hat diese Lösung inspiriert.

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

Der z**zTeil hier hindert mich daran, diese Funktion mit nahezu vernünftigen Eingaben für auszuführeny undz . Die größten Werte, die ich verwenden kann, sind 9 und 3, für die ich den Wert 1,0 zurückerhalte, selbst für die größten Float-Python-Unterstützungen (Anmerkung: while 1.0 Wenn der numerische Wert größer als 6,77538853089e-05 ist, verschieben erhöhte Rekursionsstufen die Ausgabe dieser Funktion näher an 1, bleiben jedoch größer als 1, während die vorherige Funktion Werte näher an 0 verschiebt und größer als 0 bleibt, was zu einer sogar moderaten Rekursion dieser Funktion führt führt zu so vielen Operationen, dass die Gleitkommazahl alle signifikanten Bits verliert .

Neukonfiguration des ursprünglichen Lambda-Aufrufs mit Rekursionswerten von 0 und 2 ...

>>>1.7976931348623157e+308
1.0000000071

Wenn der Vergleich mit "Offset von 0" statt "Offset von 1" durchgeführt wird, gibt diese Funktion einen Wert zurück 7.1e-9, der definitiv kleiner als ist 6.7e-05.

Die tatsächlichen Programms Basis Rekursion (z - Wert) 10 ^{10 10 10 1,97} Ebenen tief, sobald y erschöpft sich, es wird zurückgesetzt mit 10 ^{10 10 10 10 1,97} (weshalb ein Anfangswert von 9 genügt), so dass ich don weiß nicht einmal, wie man die Gesamtzahl der auftretenden Rekursionen richtig berechnet: Ich habe das Ende meiner mathematischen Kenntnisse erreicht. Ebenso weiß ich nicht, ob das Verschieben einer der **nExponentiationen von der anfänglichen Eingabe zur sekundären z**zdie Anzahl der Rekursionen verbessern würde oder nicht (ebenso das Umkehren).

Gehen wir noch langsamer mit noch mehr Rekursion

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 - Spart 2 Bytes int(n)
• import math,math. spart 1 Byte mehrfrom math import*
• a(...) spart insgesamt 8 Bytes m(m,...)
• (y>0)*x Speichert ein Byte übery>0and x
• 9**9**99erhöht Bytezahl um 4 erhöht und die Rekursion Tiefe von etwa 2.8 * 10^xwo xdie alten Tiefe (oder eine Tiefe a googolplex Größe kurz vor: 10 ^{10 94} ).
• 9**9**9e9Erhöht die Byteanzahl um 5 und die Rekursionstiefe um ... einen wahnsinnigen Betrag. Rekursionstiefe ist jetzt 10 ^{10 10 9.93} , als Referenz, ein googolplex 10 ^{10 10 2} .
• Lambda Erklärung erhöht Rekursion durch einen zusätzlichen Schritt: m(m(...))auf a(a(a(...)))Kosten 7 Bytes

Neuer Ausgabewert (bei 9 Rekursionstiefe):

>>>1.7976931348623157e+308
6.77538853089e-05

Die Rekursionstiefe ist bis zu dem Punkt explodiert, an dem dieses Ergebnis buchstäblich bedeutungslos ist, außer im Vergleich zu den früheren Ergebnissen, die dieselben Eingabewerte verwenden:

• Das Original wurde log25 Mal aufgerufen
• Die erste Verbesserung nennt es 81 Mal
  • Das tatsächliche Programm würde es 1e99 ² oder ungefähr 10 ^{10 2,3} mal aufrufen
• Diese Version nennt es 729 mal
  • Das tatsächliche Programm würde es (9 ^{9 99} ) ³ oder etwas weniger als 10 ^{10 95} Mal aufrufen ).

Lambda Inception, Kerbe: ???

Ich habe gehört, Sie mögen Lambdas, so ...

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))

Ich kann das nicht einmal ausführen, ich staple Überlauf sogar mit nur 99 Rekursionsebenen.

Die alte Methode (siehe unten) gibt Folgendes zurück (Überspringen der Konvertierung in eine Ganzzahl):

>>>1.7976931348623157e+308
0.0909072713593

Die neue Methode gibt zurück und verwendet nur 9 Einbruchsebenen (anstelle des vollständigen Googols von ihnen):

>>>1.7976931348623157e+308
0.00196323936205

Ich denke, dies ist ähnlich komplex wie die Ackerman-Sequenz, nur klein statt groß.

Auch dank ETHproductions für eine 3-Byte-Einsparung an Speicherplatz, von der ich nicht wusste, dass sie entfernt werden konnte.

Alte Antwort:

Die ganzzahlige Kürzung des Funktionsprotokolls (i + 1) wurde 20 bis 25 Mal (Python) unter Verwendung von Lambda-Lambdas iteriert .

PyRulez 'Antwort kann komprimiert werden, indem ein zweites Lambda eingeführt und gestapelt wird:

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 Zeichen verwendet.

Dies führt zu einer Iteration von 20 bis 25 gegenüber dem Original 12. Außerdem werden 2 Zeichen gespart, indem int()stattdessen floor()ein zusätzlicher x()Stapel verwendet wird. Wenn die Leerzeichen nach dem Lambda entfernt werden können (das kann ich momentan nicht überprüfen), y()kann ein fünftel hinzugefügt werden. Möglich!

Wenn es eine Möglichkeit gibt, den from mathImport zu überspringen, indem ein vollständig qualifizierter Name (z. B. x=lambda i: math.log(i+1))) verwendet wird, werden dadurch noch mehr Zeichen gespeichert und ein weiterer Stapel von Zeichen ermöglichtx() aber ich weiß nicht, ob Python solche Dinge unterstützt (ich vermute nicht). Getan!

Dies ist im Wesentlichen derselbe Trick, der in XCKDs Blog-Post für große Zahlen verwendet wird , jedoch schließt der Mehraufwand bei der Deklaration von Lambdas einen dritten Stapel aus:

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()))))

Dies ist die kleinstmögliche Rekursion mit 3 Lambdas, die die berechnete Stapelhöhe von 2 Lambdas überschreitet (wenn ein Lambda auf zwei Aufrufe reduziert wird, sinkt die Stapelhöhe auf 18, unter die der 2-Lambda-Version), erfordert jedoch leider 110 Zeichen.

Haskell , 100 Bytes

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#)

Probieren Sie es online!

Diese Lösung nimmt nicht die Umkehrung einer schnell wachsenden Funktion an, sondern nimmt in diesem Fall eine ziemlich langsam wachsende Funktion an length.showund wendet sie einige Male an.

Zuerst definieren wir eine Funktion f. fist eine Bastard-Version von Knuths Uparrow-Notation, die etwas schneller wächst (ein bisschen untertrieben, aber die Zahlen, mit denen wir es zu tun haben, sind so groß, dass im großen Schema der Dinge ...). Wir definieren den Grundfall von f 0 a bSein a^boder aSein b. Wir definieren dann den allgemeinen Fall, der (f$c-1)auf b+2Instanzen von angewendet werden soll a. Wenn wir eine Knuth-Uparrow-Notation wie ein Konstrukt definieren würden, würden wir sie auf bInstanzen von anwenden a, aber sie b+2ist tatsächlich golfer und hat den Vorteil, dass sie schneller wächst.

Wir definieren dann den Operator #. a#bist definiert, um length.showauf b aZeiten angewendet zu werden . Jede Anwendung von length.showist ungefähr gleich log ₁₀ , was keine sehr schnell wachsende Funktion ist.

Anschließend definieren wir unsere Funktion g, die eine ganze Zahl aufnimmt und mehrere length.showMale auf die ganze Zahl anwendet . Um genau zu sein, gilt es für length.showdie Eingabe f(f 9 9 9)9 9. Bevor wir uns damit befassen, wie groß das ist, schauen wir uns das an f 9 9 9. f 9 9 9ist um ein Vielfaches größer als 9↑↑↑↑↑↑↑↑↑9 (neun Pfeile). Ich glaube, es liegt irgendwo zwischen 9↑↑↑↑↑↑↑↑↑9(neun Pfeile) und 9↑↑↑↑↑↑↑↑↑↑9(zehn Pfeile). Nun ist dies eine unvorstellbar große Zahl, die viel zu groß ist, um auf einem existierenden Computer gespeichert zu werden (in binärer Notation). Wir nehmen das und setzen es als erstes Argument von uns f, was bedeutet, dass unser Wert größer ist als 9↑↑↑↑↑↑...↑↑↑↑↑↑9beif 9 9 9Pfeile dazwischen. Ich werde diese Zahl nicht beschreiben, weil sie so groß ist, dass ich nicht glaube, dass ich sie gerecht machen kann.

Jedes entspricht length.showungefähr der Logarithmusbasis 10 der ganzen Zahl. Dies bedeutet, dass die meisten Zahlen 1 zurückgeben, wenn fsie auf sie angewendet werden. Die kleinste Zahl, die etwas anderes als 1 10↑↑(f(f 9 9 9)9 9)zurückgibt, ist 2. Denken wir einen Moment darüber nach. So abscheulich groß diese Zahl auch ist, so oft ist die kleinste Zahl, die 2 zurückgibt, 10 aus eigener Kraft. Das ist 1 gefolgt von 10↑(f(f 9 9 9)9 9)Nullen.

Für den allgemeinen Fall nder kleinsten Eingabe muss die Ausgabe irgendeines gegebenen n sein (10↑(n-1))↑↑(f(f 9 9 9)9 9).

Beachten Sie, dass dieses Programm viel Zeit und Speicher für selbst kleine n benötigt (mehr als es im Universum um ein Vielfaches gibt). Wenn Sie dies testen möchten, empfehle ich, es f(f 9 9 9)9 9durch eine viel kleinere Zahl zu ersetzen , versuchen Sie 1 oder 2, wenn Sie möchten bekomme jemals eine andere Ausgabe als 1.

APL, Anwenden log(n + 1), e^9^9...^9mal, wobei die Länge der Kette e^9^9...^9der Länge der Kette minus 1 mal entspricht, und so weiter.

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

MATL , 42 Bytes

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

Probieren Sie es online!

Dieses Programm basiert auf der harmonischen Reihe unter Verwendung der Euler-Mascheroni-Konstante. Als ich die @ LuisMendo-Dokumentation in seiner MATL-Sprache las (mit Großbuchstaben, es sieht also wichtig aus), bemerkte ich diese Konstante. Der Ausdruck für die langsame Wachstumsfunktion lautet wie folgt:

wo εk ~ 1 / 2k

Ich habe bis zu 10000 Iterationen getestet (in Matlab, da es für TIO zu groß ist) und es wird mit unter 10 bewertet, daher ist es sehr langsam.

Erklärungen:

 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

Empirischer Beweis: (ln k ) + 1 in Rot immer über ln k + γ + εk in Blau.

Das Programm für (ln k ) + 1 wurde in erstellt

Matlab, 47 18 14 Bytes

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

Interessanterweise beträgt die verstrichene Zeit für n = 100 auf meinem Laptop 0,208693 Sekunden, aber nur 0,121945 Sekunden d=rand(1,n);A=d*0;und noch weniger 0,112147 Sekunden A=zeros(1,n). Wenn Nullen Platzverschwendung sind, spart das Geschwindigkeit! Aber ich weiche vom Thema ab (wahrscheinlich sehr langsam).

Edit: Danke an Stewie, der dabei geholfen hat , diesen Matlab-Ausdruck auf einfach zu reduzieren:

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

Python 3 , 100 Bytes

Die Etage des Funktionsprotokolls (i + 1) wurde 999999999999999999999999999999999999999 mal durchlaufen.

Man kann Exponenten verwenden, um die obige Zahl noch größer zu machen ...

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

Probieren Sie es online!

Der Fußboden des Funktionsprotokolls (i + 1) wurde 14-mal wiederholt (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())))))))))))))))

Ich erwarte nicht, dass dies sehr gut funktioniert, aber ich dachte, es ist ein guter Anfang.

Beispiele:

• e ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n -> ~ n (ungefähr n)

Rubin, 100 Bytes, score ^-1 = f _{& ohgr; ^{& ohgr; 1 +}} (n ² )

Grundsätzlich von meiner größten druckbaren Nummer ausgeliehen , hier ist mein Programm:

->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}

Probieren Sie es online aus

Berechnet grundsätzlich die Inverse von f _{ω ^{ω + 1}} (n ² ) in der schnell wachsenden Hierarchie. Die ersten Werte sind

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

Und dann wird noch 2sehr lange ausgegeben . Sogar x[G] = 2, wo Gist Grahams Nummer?

Mathematica, 99 Bytes

(unter der Annahme, dass ± 1 Byte dauert)

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

Die ersten 3 Befehle definieren x±y die Auswertung Ackermann(y, x).

Das Ergebnis der Funktion ist, f(#)=#±#±#±#±#±#±#±#wie oft auf 1 angewendet werden muss, bevor der Wert den Wert des Parameters erreicht. Da f(#)=#±#±#±#±#±#±#±#(das heißt f(#)=Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[#, #], #], #], #], #], #], #]) sehr schnell wächst , wächst die Funktion sehr langsam.

Clojure, 91 Bytes

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

Art berechnet das sum 1/(n * log(n) * log(log(n)) * ...), was ich hier gefunden habe . Da die Funktion jedoch 101 Byte lang war, musste ich die explizite Anzahl der Iterationen löschen und stattdessen iterieren, solange die Anzahl größer als eins ist. Beispielausgaben für Eingaben von 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

Ich gehe davon aus, dass diese modifizierte Serie immer noch divergiert, aber jetzt weiß ich, wie ich es beweisen kann.

Die dritte Reihe erfordert tatsächlich eine googolplexe Anzahl von Begriffen, bevor die Teilbegriffe 10 überschreiten.

Javascript (ES6), 94 Byte

(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)

Erklärung :

Idverweist x => xim Folgenden auf.

Werfen wir zunächst einen Blick auf:

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

p(Math.log)ist ungefähr gleich log*(x).

p(p(Math.log))ist ungefähr gleich log**(x)(Anzahl von Malen, die Sie nehmen können, log*bis der Wert höchstens 1 ist).

p(p(p(Math.log)))ist ungefähr gleich log***(x).

Die inverse Ackermann-Funktion entspricht alpha(x)in etwa der Mindestanzahl von Kompositionen, pbis der Wert höchstens 1 beträgt.

Wenn wir dann verwenden:

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

dann können wir schreiben alpha = p(Id)(Math.log).

Das ist jedoch ziemlich langweilig. Erhöhen wir also die Anzahl der Ebenen:

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

Das ist so, wie wir konstruiert haben alpha(x), außer dass log**...**(x)wir es jetzt tun , anstatt es zu tun alpha**...**(x).

Warum hier aufhören?

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

Wenn die vorherige Funktion ist f(x)~alpha**...**(x), ist diese jetzt ~ f**...**(x). Wir tun noch eine Stufe, um unsere endgültige Lösung zu erhalten.