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

• Steven H , Pyth f _{3 + B³F + ω²} (256 ²⁶ )

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 ₃ (f ₃ (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.

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

Pyth, f _{ψ (Ω ^Ω ) + ω ² +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. ¯ \ _ (ツ) _ / ¯

Pyth, f _{3 + σ -1 + ω ²} (256 ²⁶ )

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 _{ω ²} .

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.

Python, f ₃ (f ₃ (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.

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.

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.

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!

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

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]