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 26 )
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:
Einfach schön Kunst , Rubin f & psgr; 0 (X (Ω M + X (Ω M + 1 Ω M + 1 ) )) + 29 (9 9 9 )
Steven H , Pyth f ψ (Ω Ω ) + ω² + 183 (256 27! )
Undichte Nonne , Python 3 f ε 0 (9 9 9 )
Fejfo , Python 3 f ω ω 6 (f ω ω 5 (9e999))
Steven H , Python 3 f ω ω + ω² (9 9 9 99 )
Einfach schöne Kunst , Rubin f ω + 35 (9 9 99 )
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:
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.