BigNum Bakeoff Neustart

12

Einige von Ihnen kennen vielleicht den BigNum Bakeoff , der sehr interessant endete. Das Ziel kann mehr oder weniger so zusammengefasst werden, dass ein C-Programm geschrieben wird, dessen Ausgabe unter bestimmten Einschränkungen und theoretischen Bedingungen am größten ist, z. B. ein Computer, auf dem das Programm ausgeführt werden könnte.

In diesem Sinne stelle ich eine ähnliche Herausforderung dar, die allen Sprachen offen steht. Die Bedingungen sind:

  • Maximal 512 Bytes .

  • Das Endergebnis muss in STDOUT gedruckt werden. Das ist deine Punktzahl. Wenn mehrere Ganzzahlen gedruckt werden, werden sie verkettet.

  • Die Ausgabe muss eine Ganzzahl sein. (Hinweis: Unendlichkeit ist keine ganze Zahl .)

  • Keine eingebauten Konstanten größer als 10, aber Ziffern / Ziffern sind in Ordnung (z. B. ist die Avogadro-Konstante (als eingebaute Konstante) ungültig, 10000 jedoch nicht.)

  • Das Programm muss beendet werden, wenn genügend Ressourcen zur Ausführung bereitgestellt werden.

  • Die gedruckte Ausgabe muss deterministisch sein, wenn genügend Ressourcen für die Ausführung bereitgestellt werden.

  • Sie erhalten genügend Ganzzahlen oder Bigint, damit Ihr Programm ausgeführt werden kann. Wenn Ihr Programm beispielsweise das Anwenden grundlegender Operationen auf Zahlen unter 10 1.000.000 erfordert, können Sie davon ausgehen, dass der Computer, auf dem dies ausgeführt wird, Zahlen mit mindestens 10 1.000.000 verarbeiten kann . (Hinweis: Ihr Programm kann auch auf einem Computer ausgeführt werden, der Zahlen bis zu 10 2.000.000 verarbeitet. Wenn Sie also nur die maximale Ganzzahl aufrufen, die der Computer verarbeiten kann, führt dies nicht zu deterministischen Ergebnissen.)

  • Sie erhalten genügend Rechenleistung, damit Ihr Programm in weniger als 5 Sekunden ausgeführt werden kann. (Machen Sie sich also keine Sorgen, wenn Ihr Programm eine Stunde lang auf Ihrem Computer ausgeführt wurde und nicht in Kürze beendet wird.)

  • Keine externen Ressourcen. Denken Sie also nicht daran, diese Ackermann-Funktion zu importieren, es sei denn, sie ist integriert.

Alle magischen Gegenstände werden vorübergehend von einer großzügigen Gottheit ausgeliehen.

Extrem groß mit unbekannter Grenze

wobei B³F die Church-Kleene-Ordnungszahl mit der Grundfolge von ist

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

Bestenliste:

  1. Einfach schön Kunst , Rubin f & psgr; 0 (X (Ω M + X (Ω M + 1 Ω M + 1 ) )) + 29 (9 9 9 )

  2. Steven H , Pyth f ψ (Ω Ω ) + ω² + 183 (256 27! )

  3. Undichte Nonne , Python 3 f ε 0 (9 9 9 )

  4. Fejfo , Python 3 f ω ω 6 (f ω ω 5 (9e999))

  5. Steven H , Python 3 f ω ω + ω² (9 9 9 99 )

  6. Einfach schöne Kunst , Rubin f ω + 35 (9 9 99 )

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

Einige Randnotizen:

Wenn wir Ihre Punktzahl nicht überprüfen können, können wir sie nicht in die Rangliste aufnehmen. Vielleicht möchten Sie also erwarten, Ihr Programm ein wenig zu erklären.

Wenn Sie nicht verstehen, wie groß Ihre Anzahl ist, erklären Sie Ihr Programm und wir werden versuchen, es herauszufinden.

Wenn Sie ein Programm vom Typ Loader verwenden , werde ich Sie in eine separate Kategorie mit dem Namen "Extrem groß mit unbekannter Grenze" einordnen, da die Nummer des Loaders keine nicht triviale Obergrenze in Bezug auf die schnell wachsende Hierarchie für 'hat. Standard-Grundsequenzen.

Zahlen werden über die schnell wachsende Hierarchie eingestuft .

Für diejenigen, die lernen möchten, wie man die schnell wachsende Hierarchie verwendet, um wirklich große Zahlen zu approximieren, hoste ich nur dafür einen Discord-Server . Es gibt auch einen Chatraum: Ordinalität .

Ähnliche Herausforderungen:

Größte druckbare Anzahl

Golf eine Nummer größer als TREE (3)

Kürzestes Abschlussprogramm, dessen Ausgabegröße Grahams Zahl überschreitet

Für diejenigen, die einige einfache Programme sehen möchten, die die schnell wachsende Hierarchie für kleine Werte ausgeben, sind sie hier:

Ruby: schnell wachsende Hierarchie

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

etc.

Um von f_xzu gehen f_(x+1), fügen wir eine Schleife der hinzu n.times{...}.

Ansonsten diagonalisieren wir gegen alle vorherigen z

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)

etc.

Einfach schöne Kunst
quelle
Zählen Zahlen als eingebaute Konstanten?
PyRulez
3
@CloseVoters Wie kann das zu weit gefasst sein? Nun, das Auffordern des Benutzers, eine Zahl in unendlich vielen Zahlen auszugeben, ist nicht dasselbe wie das Auffordern des Benutzers, eine von unendlich vielen Aufgaben auszuwählen. Um fair zu sein , bitten Sie den Benutzer, dasselbe auch zu tun. 4 enge Stimmen als zu breit bereits ...
user202729
1
@ Οurous Ja, das können Sie annehmen. Beachten Sie jedoch, dass die Ausgabe immer noch deterministisch sein muss, wenn Ihrem Programm mehr Ressourcen zur Verfügung stehen, einschließlich einer schnelleren Berechnung.
Einfach schöne Kunst
1
Ich habe im anderen Kommentarbereich angegeben, warum ich denke, dass die eingeschränkte Brainfuck Busy Beaver-Funktion exponentiell sein wird, aber ich möchte allgemein hinzufügen, dass ich nicht denke, dass die Church-Kleene-Ordnungszahl die geeignete Ebene für ein Computerprogramm sein wird . Eine Funktion, die man mit einem Programm codieren kann, ist berechenbar und sollte daher in die nachweislich rekursiven Funktionen einer ausreichend starken rekursiven Klangtheorie fallen. Diese Theorie wird eine rekursive Beweis-theoretische Ordnungszahl haben, und diese Funktion wird unter dieser Ordnungszahl in der FGH liegen, unter der Annahme vernünftiger grundlegender Sequenzen.
Deedlit
1
Natürlich kann die eigentliche Busy Beaver-Funktion nicht in ein Programm codiert werden (abgesehen von hypercomputationalen Sprachen), und eingeschränkte Busy Beaver-Funktionen, die programmiert werden können, müssen notwendigerweise viel langsamer wachsen.
Deedlit

Antworten:

7

Rubin, f ψ 0 (X (Ω M + X (Ω M + 1 Ω M + 1 ) )) + 29 (9 9 9 )

Dabei ist M die erste Mahlo-Ordnungszahl, X die Chi-Funktion (Mahlo-Kollapsfunktion) und ψ die Ordnungskollapsfunktion.

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

Probieren Sie es online aus!

Code-Aufschlüsselung:

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

Mathe-Aufschlüsselung:

freduziert abasierend auf n,b,q.

Die Grundidee ist, ein extrem verschachteltes zu haben aund es wiederholt zu reduzieren, bis es sich auf reduziert a=0. Der Einfachheit halber sei

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

Machen wir uns vorerst nur Sorgen n.

Für jede ganze Zahl erhalten kwir f[k,n]=k-1, damit wir das sehen können

g[k,n]=n+k

Wir haben dann für jede d, f[[0,d],n]=nso können wir sehen , dass

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

Wir haben dann für jeden c,d,e, f[[c,0,e],n]=f[[c,d,0],n]=c. Beispielsweise,

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

Wir haben dann für c,d,esolche, dass es nicht in den vorherigen Fall fällt , f[[c,d,e],n]=[[c,d,f[e,n]],f[d,n],e]. Hier wird es langsam kompliziert. Einige Beispiele:

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

Von dort steigt es schnell an. Einige Punkte von Interesse:

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.

Wenn fwir schließlich mehr Argumente der Funktion sowie mehr Fälle für das Array einführen, können wir die meisten benannten berechenbaren Notationen übertreffen. Einige besonders bekannte:

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
Einfach schöne Kunst
quelle
1
Ordinale Erklärung?
CalculatorFeline
Ist dies Ihre bisher größte definierte Nummer? Es scheint so!
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)

Erfordert keine nicht leere Eingabe, aber der Wert davon wird nicht verwendet.

Erläuterung (für die neue und tatsächlich vernünftig bewertete Version):

=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

Es ist sehr schwer für mich, die Größe zu berechnen, vor allem, weil es spät am Tag ist und ich mit schnell wachsenden Hierarchien nicht besonders vertraut bin oder wie ich überhaupt versuchen würde, herauszufinden, wie oft Q das durchläuft y()Wringer. Obwohl ich jetzt mehr über Ordnungszahlen weiß, habe ich noch keine Ahnung, wie ich den Wert der Ordnungszahl berechnen soll, die durch die rekursive Definition in meinem Programm dargestellt wird. Ich würde dem Discord-Server beitreten, aber das steht unter einem Pseudonym. Ich möchte lieber nicht mit meinem richtigen Namen verknüpft werden.

Leider habe ich wahrscheinlich bereits gegen die Ruby-Antwort verloren, da ich relativ wenig über diese schnell wachsenden Hierarchien weiß. Es ist schwer für mich zu sagen. Ich habe vielleicht die Ruby-Antwort geschlagen, bin mir aber nicht 100% sicher. ¯ \ _ (ツ) _ / ¯

Steven H.
quelle
Wenn ich das richtig verstehe, liegt Ihre Punktzahl wahrscheinlich irgendwo im Stadion von 27^^^27^^27^^4oder f<sub>4</sub>(27^^27^^4)) ≈ f<sub>4</sub>(f<sub>3</sub>(f<sub>3</sub>(19))).
Einfach schöne Kunst
Ich habe eine kleine Änderung vorgenommen, an die ich gestern hätte denken sollen, aber irgendwie nicht - ich habe einen yRückgriff gemacht, um zu operieren, y(Q-1)anstatt nur zu operieren Q. Wie wirkt sich das auf die Punktzahl aus?
Steven H.
1
Ich bin mir nicht ganz sicher, was los ist. Tut y(Q) = L(y(Q-1))an sich?
Einfach schöne Kunst
1
Ich denke, wir werden in einem Chatroom mehr Glück haben .
Steven H.
@SimplyBeautifulArt Es ist wahrscheinlich am besten, dafür keine schnell wachsende Hierarchie-Notation zu verwenden, da sie klein ist.
PyRulez
3

Pyth, f 3 + σ -1 + ω 2 (256 26 )

Wobei σ m [n] die maufgerufene Busy Beaver-Funktion Σ ist n: σ m [n] = Σ m (n). Die Reihenfolge -1soll bedeuten, dass der Busy Beaver hier nicht auf einer echten Turingmaschine aufgerufen wird, sondern eine Annäherung mit einem endlichen Wickelband von QElementen. Dadurch kann das Problem des Anhaltens für diese Programme gelöst werden.

=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\'

Die TL; DR ist, dass dies alle möglichen BrainF ** k-Programme der Länge Q erstellt, sie in einer Umgebung ausführt, in der der Maximalwert einer Ganzzahl Q und die Bandlänge Q ist, und alle Zustände aus diesen Operationen zusammen kompiliert füge (das ist das 3+) an Q hinzu und wiederhole das Obige auf einer Skala von f ω 2 .

Ich habe immer noch ~ die Hälfte der Charaktere, mit denen ich arbeiten kann, wenn ich etwas mehr machen möchte, aber bis wir herausfinden, wo dies ist, lasse ich es einfach so wie es ist.

Steven H.
quelle
Ich habe σ in der Rangliste etwas besser erklärt.
Einfach schöne Kunst
4
Es sieht für mich nicht so aus, als ob diese spezielle Busy Beaver-Funktion so schnell wächst. Mit einer Grenze von Q ganzen Zahlen zwischen 0 und Q gibt es nur (Q + 1) ^ Q mögliche Bänder und Q mögliche Positionen im Programm, so dass es höchstens Q * (Q + 1) ^ Q mögliche Zustände von geben kann ein laufendes Programm. Ein Programm muss also innerhalb von Q * (Q + 1) ^ Q Schritten oder überhaupt nicht anhalten. Die Anzahl der möglichen Programme ist auch durch eine exponentielle Obergrenze begrenzt. Für mich sieht es so aus, als ob diese Busy Beaver-Funktion eine exponentielle Obergrenze hat und die endgültige Funktion in der Größenordnung von $ f _ {\ omega ^ 2} $ liegt.
Deedlit
2

Python, f 3 (f 3 (141)), 512 Bytes

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

Dies ist keine wirklich gültige Antwort, aber ich wollte sie trotzdem posten. Ein kurzer Überblick:

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

Wie auch immer, ich weiß nicht, ob diese Antwort technisch legal ist, aber es hat Spaß gemacht, sie zu schreiben. Fühlen Sie sich frei, alle Fehler zu bearbeiten, die Sie im Code finden.

ich..
quelle
Ich denke, das ist f_3 (9) und es ist definitiv legal. Sie würden jedoch eine weitaus größere Anzahl erhalten for j in range(f(x)): for j in range(f(x)): x = f(x), wenn Sie sogar verschachteln . Begleiten Sie uns in Chat zu diskutieren , warum!
Steven H.
Warum ist es keine gültige Antwort?
Einfach schöne Kunst
Ich habe nicht ganz bekommen , die Frage, so dass ich nur gemacht , was ich dachte , war richtig.
i ..
1

Rubin, wahrscheinlich ~ 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

Probieren Sie es online aus!

Ungefähre mathematische Erklärung:

Das Folgende entspricht ungefähr dem obigen Programm, ist jedoch vereinfacht, damit es leichter zu verstehen ist.

G(0,k) = k ist unsere Grundfunktion.

Zur Bewertung G(n,k)nehmen kund schreiben wir es als G(n-1,1) + ... + G(n-2,1) + ... + G(0,1).

Ändern Sie dann alle G(x,1)'s in G(x,2)' s und subtrahieren Sie 1vom gesamten Ergebnis.

Schreiben Sie es in der obigen Form mit G(x,2)where um x<nund lassen Sie den Rest am Ende. Wiederholen, ändern G(x,2)zu G(x,3)usw.

Wenn das Ergebnis erreicht ist -1, geben Sie die Basis zurück (die b, die sich in befinden würde G(x,b).)

Beispiele:

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

Beim Rechnen habe ich das gefunden

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

Und darüber hinaus neigt es dazu, ein bisschen haarig zu werden.

Im Allgemeinen haben wir

G(n,k+G(n-1,1)) ~ G(n-1,G(n,k)), large enough n.
Einfach schöne Kunst
quelle
1

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

Ich werde bald eine Erklärung bekommen.

Steven H.
quelle
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)

Probieren Sie es online aus!

Undichte Nonne
quelle
N = 9 ** 9e99 sollte etwas größer sein
fejfo
als wessen Antwort?
Undichte Nonne
Ich meine, wenn Sie das erste wie durch N = 9 ** 9e99 ersetzen, sollte die Ausgabe etwas größer sein, weil 9e99> 9 ** 9. Natürlich ist es immer noch deine Antwort.
Fejfo
@fejfo Ich meine, es würde mein Ranking nicht ändern.
Undichte Nonne
2
Spielt das eine Rolle?
Fejfo
1

Python 3, 323 Bytes, 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 '))

Probieren Sie es online aus!

Erläuterung

Python 3 ist eine wirklich rekursive Sprache. Dies bedeutet, dass eine Funktion nicht nur sich selbst aufrufen kann, sondern auch andere Funktionen als Eingabe- oder Ausgabefunktionen übernehmen kann. Funktionen zu verwenden, um sich selbst zu verbessern, ist das, worauf mein Programm basiert.

f = Lambda x, a: [a (x), e (x) ((x, a)) [1]]

Definition

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)

Definition erklärt

a(x)=9^x a ist die Basisfunktion, ich habe diese Funktion gewählt, weil x> 0 => a (x)> x`, wodurch Fixpunkte vermieden werden.

b(x,f)=a(x), f^xb ist die allgemeine Verbesserungsfunktion, sie nimmt jede Funktion auf und gibt eine bessere Version davon aus. b kann sogar auf sich selbst angewendet werden:b(x,b)[1]=b^x b(x,b^x)[1]=b^(x*x)

Aber um die Kraft von bzu nutzen, um sich zu verbessern b, müssen Sie die Ausgabe von b nehmen und als neues b verwenden. Dies ist, was c0 tut:

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

die allgemeinere c (n) -Funktion nimmt das n letzte Argument (beginnend mit 0) so c(1)(…,f,a)=f(…,f,a)und c(2)(…,f,a,b)=f(…,f,a,b). *lbedeutet, dass l ein Array ist und l[~n]das letzte Argument n verwendet

d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in ld verwendet c0 zum Aktualisieren von b und b zum Aktualisieren aller anderen Eingabefunktionen (von denen aufgrund der Liste ein beliebiger Betrag vorhanden sein kann)
d(x,b,c,d)>9^x,b^x,c^x,d^xundd²(x,b,c,d)>a²(x), b^(9↑↑x), c^(9↑↑x), d^(9↑↑x)

aber d wird noch besser, wenn Sie es mit c kombinieren:
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)=…

Je mehr c (x) Sie am Ende hinzufügen, desto mächtiger wird es. Das erste c0 bleibt immer 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)=…
Das zweite lässt iterierte Versionen zurück:

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

Wann d^xendgültig berechnet c4wird, wird eine viel iteriertere Version des dnächsten Males dauern . Wann c4^xendgültig berechnet c3wird, wird eine viel iteriertere Version von c4... benötigt.
Dies erzeugt eine wirklich leistungsstarke Version der Iteration, weil d:

  1. Verbessert die bVerwendungc0
  2. Verbessert die c0Verwendungb
  3. Verbessert alle Verschachtelungsebenen mit b Die verbessert sich selbst. Dies bedeutet, dass d leistungsfähiger wird, wenn es stärker iteriert wird.

Das Erstellen dieser langen Kette von c ist das, was 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]tut.
Es verwendet c0^x, um das zu umgehen, c0was nur geben würde d.
Dies [1]bedeutet, dass schließlich die zweite Ausgabe von zurückgegeben wird d^…. Also b^….

Zu diesem Zeitpunkt fiel mir nichts ein, was mit e (x) zu tun hätte, um die Ausgabe signifikant zu erhöhen, außer die Eingabe zu erhöhen.

So f(x,a)=a(x),e(a(x))(x,a)[1](x)verwendet die b^…erzeugte durch e(x)die Ausgabe eine bessere Basisfunktion und verwendet diese Basisfunktion aufzurufen e(x)mit einem größeren Eingang.

g(x)=e(x)(x,f)[1](x,a)[1](x)verwendet ein Finale e(x)zum Verschachteln fund erzeugt eine wirklich mächtige Funktion.

Fgh Annäherung

Ich werde Hilfe brauchen, um diese Zahl mit irgendeiner Art von Fgh zu approximieren.

Alte Version : f ω ω 6 (f ω ω 5 (9e999)), Probieren Sie es online aus! Revisionsverlauf der Erklärung

fejfo
quelle
Eigentlich, f_1(x) = x+xaber auf lange Sicht ist das nicht so wichtig.
Einfach schöne Kunst
Könnten Sie Ihre grundlegenden Sequenzen etwas näher erläutern?
Einfach schöne Kunst
@SimplyBeautifulArt ow ja, ich habe vergessen, das zu aktualisieren, nachdem ich es von geändert habe x*x.
Fejfo
@SimplyBeautifulArt Meine Antwort verwendet keine Ordnungszahlen, daher fällt es mir schwer, sie mit Ordnungszahlen zu erklären. Alles, was ich wirklich tun kann, ist die Definition meiner Funktionen und eine Annäherung an den Effekt im fgh. Beispiel:a2(f_n)~=f_{n+1}
fejfo
1

Ruby, f & epsi; 0 2 (5), 271 Bytes

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]

Probieren Sie es online aus!

Dies basiert auf der m (n) -Karte .

Erläuterung:

m[0][f0][k] = f0[f0[...f0[k]...]]mit kIterationen von f0.

m[1][f0][f1][k] = f0[f0[...f0[f1]...]][k]mit kIterationen von f0.

m[2][f0][f1][f2][k] = f0[f0[...f0[f1]...]][f2][k]mit kIterationen von f0.

Im allgemeinen wird m[n]in nimmt n+2Argumente, iteriert das erste Argument f0, kmal auf das zweite Argument, und dann die sich ergebende Funktion auf das dritte Argument gilt (wenn es vorhanden ist ), gilt dann die sich ergebende Funktion auf das vierte Argument (falls vorhanden), etc.

Beispiele

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

Im Allgemeinen 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

Im Allgemeinen 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

Im Allgemeinen m[1][m[0]][n↦n+1] = f_ωin der schnell wachsenden Hierarchie.


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

und die endgültige Ausgabe ist

m[5][m[4]][m[3]][m[2]][m[1]][m[0]][g][6]
Einfach schöne Kunst
quelle