Ihr Ziel ist es, ein Programm zu schreiben, das eine Zahl druckt. Je größer die Zahl, desto mehr Punkte erhalten Sie. Aber sei vorsichtig! Die Codelänge ist in der Bewertungsfunktion sowohl begrenzt als auch stark gewichtet. Ihre gedruckte Nummer wird durch den Würfel der Anzahl der Bytes geteilt, die Sie für Ihre Lösung verwendet haben .
Nehmen wir an, Sie haben gedruckt 10000000
und Ihr Code ist 100
byteslang. Ihre endgültige Punktzahl wird sein 10000000 / 100^3 = 10
.
Es gibt noch andere Regeln, um diese Herausforderung etwas zu erschweren.
- In Ihrem Code können keine Ziffern verwendet werden (0123456789).
- Sie können mathematisch / physikalisch / etc. Konstanten, aber nur , wenn sie weniger als 10 (zB können Sie verwenden Pi ~ = 3,14 , aber Sie können nicht die Verwendung Avogadro - Konstante = 6e23)
- Rekursion ist zulässig, aber die generierte Zahl muss endlich sein (daher wird Unendlich nicht als Lösung akzeptiert. Ihr Programm muss unter der Annahme unbegrenzter Zeit und unbegrenzten Speichers korrekt beendet werden und die angeforderte Ausgabe generieren).
- Sie können die Operationen
*
(Multiplizieren),/
(Dividieren),^
(Potenzieren) und andere Methoden nicht verwenden, um sie anzuzeigen (z. B.2 div 2
nicht zulässig). - Ihr Programm kann mehr als eine Zahl ausgeben, wenn Sie dies benötigen . Nur der Höchste zählt für die Wertung;
- Sie können jedoch Zeichenfolgen verketten: Dies bedeutet, dass jede Folge benachbarter Ziffern als einzelne Zahl betrachtet wird.
- Ihr Code wird so wie er ist ausgeführt. Dies bedeutet, dass der Endbenutzer keine Codezeile bearbeiten oder eine Zahl oder etwas anderes eingeben kann.
- Die maximale Codelänge beträgt 100 Byte.
Bestenliste
- Steven H. , Pyth ≈ f φ (1,0,0) +7 (256 26 ) / 1000000 [1]
- Einfach schöne Kunst , Rubin ≈ f φ 121 (ω) (126) [1]
- Peter Taylor , GolfScript ≈ f ε 0 + ω + 1 (17) / 1000 [1]
- res , GolfScript ≈ f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (126)))))))) [1]
- Simply Beautiful Art , Rubin ≈ f ω ω2 +1 (1983)
- eaglgenes101 , Julia ≈ f ω3 (127)
- col6y , Python 3, ≈ (127 → 126 → ... → 2 → 1) / 99 3 [1] [3]
- Toeofdoom , Haskell, ≈ a 20 (1) / 99 3 [1]
- Fraxtil , dc, ≈ 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15/100 3 [3]
- Magenta , Python, ≈ ack (126, 126) / 100 3 ≈ 10 ↑ 124 129
- Kendall Frey , ECMAScript 6, ≈ 10 3 ↑ 4 3 /100 3 [1]
- Ilmari Karonen , GolfScript, ≈ 10 ↑ 3 10 377 /18 3 [1]
- BlackCap , Haskell, ≈ 10 ↑↑ 65503/100 3
- rekursiv , Python, ≈ 2 ↑↑ 11/95 3 ≈ 10 ↑↑ 8.63297 [1] [3]
- nm , Haskell, ≈ 2 ↑↑ 7/100 3 ≈ 10 ↑↑ 4,63297 [1]
- David Yaw , C, ≈ 10 10 4 × 10 22 /83 3 ≈ 10 ↑↑ 4,11821 [2]
- PRIMO , Perl, 10 ≈ (12750684161!) 5 × 2 27 /100 3 ≈ 10 ↑↑ 4,11369
- Art , C, ≈ 10 10 2 × 10 6 /98 3 ≈ 10 ↑↑ 3,80587
- Robert Sørlie , x86, ≈ 10 2 2 19 +32 / 100 3 ≈ 10 ↑↑ 3.71585
- Tobia , APL, ≈ 10 10 353 /100 3 ≈ 10 ↑↑ 3,40616
- Darren Stone , C, 10 10 97.61735 / 98 3 ≈ 10 ↑↑ 3.29875
- ecksemmess , C, ≈ 10 2 320 /100 3 ≈ 10 ↑↑ 3,29749
- Adam Speight , vb.net, ≈ 10 5000 × (2 64 ) 4 /100 3 ≈ 10 ↑↑ 3,28039
- Joshua , bash, ≈ 10 10 15 /86 3 ≈ 10 ↑↑ 3,07282
Fußnoten
- Wenn jedes Elektron im Universum ein Qubit wäre und jede Überlagerung davon zum Speichern von Informationen genutzt werden könnte (was theoretisch möglich ist , solange Sie nicht wissen müssen , was gespeichert wird), benötigt dieses Programm mehr Speicher als es könnte existiert möglicherweise und kann daher nicht ausgeführt werden - jetzt oder zu irgendeinem denkbaren Zeitpunkt in der Zukunft. Wenn der Autor beabsichtigt, einen Wert größer als ≈3 ↑↑ 3.28 auf einmal zu drucken, gilt diese Bedingung.
- Dieses Programm benötigt mehr Speicher als derzeit vorhanden, aber nicht so viel, dass es theoretisch nicht auf einer mageren Anzahl von Qubits gespeichert werden kann, und daher könnte eines Tages ein Computer existieren, auf dem dieses Programm ausgeführt werden kann.
- Alle derzeit verfügbaren Interpreter geben einen Laufzeitfehler aus, oder das Programm wird ansonsten nicht wie vom Autor beabsichtigt ausgeführt.
- Das Ausführen dieses Programms führt zu irreparablen Schäden an Ihrem System.
Edit @primo : Ich habe einen Teil der Anzeigetafel mit einer hoffentlich einfacher zu vergleichenden Notation aktualisiert, wobei Dezimalstellen den logarithmischen Abstand zur nächsthöheren Potenz angeben . Zum Beispiel 10 ↑↑ 2,5 = 10 10 √10 . Ich habe auch einige Punkte geändert, wenn ich der Meinung bin, dass die Analyse des Benutzers fehlerhaft ist.
Erklärung dieser Notation:
Wenn ja 0 ≤ b < 1
, dann .a↑↑b = ab
Wenn ja b ≥ 1
, dann .a↑↑b = aa↑↑(b-1)
Wenn ja b < 0
, dann .a↑↑b = loga(a↑↑(b+1))
12e10
(12 * 10 ^ 10) als12*10^10
?500b
, ist dies ungültig? Das heißt, können wir alle nicht numerischen Dinge, die ein Programm ausgibt, ignorieren? Und wenn ja, würde so etwas als50r7
zählen507
?Antworten:
GolfScript; Ergebnis mindestens f ε_0 + ω + 1 (17) / 1000
In Anlehnung an den Vorschlag von res , die Antwort auf die Frage " Lebensdauer eines Wurms" zu verwenden, stelle ich zwei Programme vor, die seine Herleitung von Howards Lösung erheblich verbessern.
Sie haben ein gemeinsames Präfix, modulo den Funktionsnamen:
berechnet,
g(g(1)) = g(5)
wog(x) = worm_lifetime(x, [x])
ungefähr als f ε 0 wächst (wobei res notes "die Funktion in der schnell wachsenden Hierarchie ist , die ungefähr mit der gleichen Geschwindigkeit wächst wie die Goodstein-Funktion").Das etwas einfacher (!) Zu analysieren ist
.{foo}*
Kartenx
zufoo^x x
.so gibt
g^(g(5)) ( g(5) )
; Die weiteren 8 Iterationsstufen ähneln der Pfeilverkettung. Einfach ausgedrückt: Wennh_0 = g
undh_{i+1} (x) = h_i^x (x)
dann berechnen wirh_10 (g(5))
.Ich denke, dass dieses zweite Programm mit ziemlicher Sicherheit viel besser abschneidet. Diesmal ist das der Funktion zugewiesene Label
g
ein Zeilenvorschub.Diesmal nutze ich besser
^
als andere Funktion.nimmt
x
den Stapel auf und geht,x
gefolgt von einer Zeichenkette, diex
Kopien.{
von enthält,g
gefolgt vonx
Kopien von}*
; Anschließend wird die Zeichenfolge ausgewertet. Da ich einen besseren Ort zum Brennen von Ersatzcharakteren hatte, beginnen wir mitj_0 = g
; wennj_{i+1} (x) = j_i^x (x)
dann die erste auswertung von^
rechnernj_{g(5)} (g(5))
(die ich mir ziemlich sicher schon vor dem vorigen programm geschlagen habe). Ich führe dann^
16 weitere Male aus; also wennk_0 = g(5)
undk_{i+1} = j_{k_i} (k_i)
dann rechnet esk_17
. Ich bin (wieder) dankbar, res für die Schätzung vonk_i
>> f ε_0 + ω + 1 (i).quelle
.{foo}*
Kartenx
zufoo^x (x)
. Wenn wir nehmenh_0 (x) = g^4 (x)
undh_{i+1} (x) = h_i^x (x)
dann ist der berechnete Werth_9 (g(3))
. Ihrf(x) = g^(4x) (x) = h_0^x (x) = h_1 (x)
.*
funktioniert. Es ist sicher zu sagen, dass h_0 (x) = g ^ 4 (x) >> f_eps_0 (x); folglich definiert die Beziehung h_ {i + 1} (x) = h_i ^ x (x) effektiv eine "beschleunigte" schnell wachsende Hierarchie, so dass h_i (x) >> f_ (eps_0 + i) (x). Dh die berechnete Zahl h_9 (g (3)) ist sicherlich viel größer als f_ (eps_0 + 9) (g (3)). Was g (3) betrifft, so kann ich zeigen, dass es größer als g_4 ist, die vierte Zahl in der g_i-Sequenz, die zur Definition von Grahams Zahl verwendet wird (das ist g_64).j_i ~ f_{eps_0 + i}
; Mach dask_i ~ f_{eps_0 + i omega + i^2}
?k_i ~ f_{ε_0 + ω}^i (k_0)
. Hier ist die Begründung: k_ {i + 1} = j_ {k_i} (k_i) = j_ω (k_i) ~ f_ {ε_0 + ω} (k_i) ~ f_ {ε_0 + ω} ^ 2 (k_ {i-1}) ... ~ f_ {ε_0 + ω} ^ {i + 1} (k_0), also k_i ~ f_ {ε_0 + ω} ^ i (k_0). Eine sehr konservative Untergrenze für k_i, ganz im Sinne der schnell wachsenden Hierarchie, ist dannk_i >> f_{ε_0 + ω}^i (i) = f_{ε_0 + ω + 1} (i)
.Windows 2000 - Windows 8 (3907172 / 23³ = 321)
HINWEIS: NICHT LAUFEN!
Speichern Sie Folgendes in einer Batchdatei und führen Sie es als Administrator aus.
Ausgabe bei Ausführung auf einem 4-TB-Laufwerk mit der ersten gedruckten Nummer in Fettdruck.
quelle
Your printed number will be divided for the number of bytes you used for your solution^3.
GolfScript, Punktzahl: viel zu viel
OK, wie groß kann eine Zahl in ein paar Zeichen GolfScript sein?
Beginnen wir mit dem folgenden Code ( danke, Ben! ), Der gedruckt wird
126
:Als nächstes wiederholen wir es 126 Mal und geben uns eine Zahl von ungefähr 1,26126 × 10 377 :
(Das ist eine Wiederholung der Zeichenfolge, keine Multiplikation. Nach den Regeln sollte es also in Ordnung sein.)
Wiederholen wir diese 378-stellige Zahl etwas mehr als 10 377 Mal:
Dieses Programm wird nie beendet, da es versucht, eine Zahl mit etwa 10 380 ≈ 2 1140 Stellen zu berechnen . Kein jemals gebauter Computer könnte eine so große Zahl speichern, noch könnte ein solcher Computer jemals mit bekannter Physik gebaut werden; die Anzahl der Atom im beobachtbaren Universum wird geschätzt , dass etwa 10 bis seine 80 , so dass selbst wenn wir irgendwie nutzen könnten alle Materie im Universum diese große Zahl zu speichern, würden wir immer noch irgendwie etwa 10 bis zu stopfen haben 380 /10 80 = 10 300 Stellen in jedes Atom!
Nehmen wir jedoch an, dass wir Gottes eigenen GolfScript-Interpreter haben, der in der Lage ist, eine solche Berechnung durchzuführen, und dass wir immer noch nicht zufrieden sind. OK, lass uns das nochmal machen!
Die Ausgabe dieses Programms hätte, wenn sie beendet werden könnte, ungefähr 10 10 383 Stellen und würde somit ungefähr 10 10 10 383 entsprechen .
Aber warte! Das Programm wiederholt sich immer wieder ... warum verwandeln wir es nicht in eine Schleife?
Hier wird der Schleifenkörper ungefähr 10 377- mal ausgeführt, was uns eine theoretische Ausgabe ergibt, die aus ungefähr 10 10⋰ 10 377 Ziffern besteht, wobei der Turm mit iterierten Potenzen von 10 ungefähr 10 377 Schritte lang ist. (Eigentlich ist das eine grobe Unterschätzung, da ich die Tatsache vernachlässige, dass die Zahl, die wiederholt wird, jedes Mal länger wird, aber relativ gesehen ist das ein kleines Problem.)
Aber wir sind noch nicht fertig. Fügen wir eine weitere Schleife hinzu!
Um eine Annäherung solcher Zahlen überhaupt richtig aufzuschreiben, ist eine esoterische mathematische Notation erforderlich. Zum Beispiel sollte in der Knuth-Aufwärtspfeil-Notation die vom obigen Programm (theoretisch) ausgegebene Zahl ungefähr 10 ↑ 3 10 377 betragen . Geben oder nehmen Sie ein paar (oder 10 377 ) Zehnerpotenzen, vorausgesetzt, ich habe die Mathematik richtig ausgeführt.
Zahlen wie diese gehen weit über "unglaublich groß" hinaus und in den Bereich von "unvorstellbar". Nach wie vor ist es nicht nur unmöglich, solche Zahlen zu zählen oder aufzuschreiben (wir haben diesen Punkt bereits im dritten Beispiel überschritten), sondern sie haben buchstäblich keine vorstellbare Verwendung oder Existenz außerhalb der abstrakten Mathematik. Wir können aus den unter Beweis stellen Axiome der Mathematik , dass solche Zahlen existieren, so wie wir es von der GolfScript Spezifikation nachweisen können , die oben programmieren würde sie berechnen, wenn die Grenzen von Realität und Platz Lagerung nicht eingreifen), aber es gibt buchstäblich nichts in das physikalische Universum, mit dem wir in jedem Sinne zählen oder messen können.
Trotzdem benutzen Mathematiker manchmal noch größere Zahlen . (Theoretisch) Rechen Zahlen , dass große ein wenig mehr Arbeit nimmt - statt nur mehr nisten Schleifen nacheinander, müssen wir Rekursion verwenden , um die teleskopartig Tiefe der verschachtelten Schleifen. Grundsätzlich sollte es jedoch möglich sein, ein kurzes GolfScript-Programm (weit unter 100 Bytes, wie ich erwarten würde) zu schreiben, um (theoretisch) eine beliebige Zahl zu berechnen, die beispielsweise in Conway- Kettenpfeilnotation ausgedrückt werden kann ; Die Details bleiben als Übung. ;-)
quelle
"...No computer ever built could store a number that big...
Korrigieren Sie mich, wenn ich falsch liege, aber ich glaube nicht, dass dies hier zutrifft. Wird nicht nur wiederholt 3 Stellen auf einmal "gespeichert" und gedruckt (?), So dass das Endergebnis nicht gespeichert werden muss.JavaScript 44 Zeichen
Dies mag ein wenig betrügerisch erscheinen:
alert((Math.PI+''+Math.E).replace(/\./g,""))
Ergebnis = 31415926535897932718281828459045/44 ^ 3 ≈ 3.688007904758867e + 26 ≈ 10 ↑↑ 2.1536134004
quelle
"."
/\./g
m=Math,p=m.PI,e=m.E,s="",alert((p*p*p+s+e*e*e).replace(/\./g,s))
stattdessen tun , Ihre Punktzahl ist dann 3100627668029981620085536923187664/63 ^ 3 = 1.240017943838551e + 28C, Score = 10 10 97,61735 / 98 3 ≈ 10 ↑↑ 2,29874984
Ich schätze die Hilfe bei der Wertung. Erkenntnisse oder Korrekturen sind willkommen. Hier ist meine Methode:
n = die Verkettung jeder Zahl von 1 bis 2 64 -1, 4- mal wiederholt (2 64 -1) . Zunächst schätze ich die kumulative Anzahl der Stellen von 1 bis 2 64 -1 (die "Teilfolge") wie folgt: Die endgültige Zahl in der Teilfolge ist 2 64 -1 =
18446744073709551615
mit 20 Stellen. Somit haben mehr als 90% der Zahlen in der Untersequenz (die mit1
.. beginnen9
) 19 Ziffern. Nehmen wir an, dass die restlichen 10% durchschnittlich 10 Stellen sind. Es wird viel mehr als das sein, aber dies ist eine niedrige Schätzung für einfache Mathematik und kein Schummeln. Diese Folge wird 4 Mal wiederholt (2 64 -1) , also die Längevon n beträgt mindestens (0,9 × (2 64 -1) × 19 + 0,1 × (2 64 -1) × 10) × (2 64 -1) 4 = 3,86613 × 10 97 Stellen. In den Kommentaren unten bestätigt @primo, dass die Länge von n 4,1433 x 10 97 beträgt . Also wird n selbst 10 zu dieser Potenz sein, oder 10 10 97.61735 .l = 98 Zeichen Code
Score = n / l 3 = 10 10 97,61735 / 98 3
Voraussetzung: Muss auf einem 64-Bit-Computer ausgeführt werden
sizeof(long) == 8
. Mac und Linux werden es schaffen.quelle
'z'
ist der konstante Wert122
. Richtig?printf("%d",n)
wird die Zahl viel größer machen. Außerdem bedeutet 64-Bit-Computer nicht 64-Bit-Longs. Windows verwendet zum Beispiel das LLP64-Modell, so lange sind es noch 32 Bit0..2^64-1
ist genau 357823770363079921190 Ziffern lang. Wiederholte(2^64-1)^4
Zeiten sind 4.1433x10 ^ 97. Nehmen wir 10 zu dieser Potenz ist power10^10^97.61735
10 ↑↑ 3.29875. Ich denke, Sie behaupten eine Zehnerpotenz, die Sie nicht haben (beachten Sie, wo3.866×10^97
wurde3.866^10^97
.2.0
statt97
.10^10^10^2.00
=10^10^97.6
. Ich werde das jetzt in meiner Partitur widerspiegeln.Python 3 - 99 Zeichen - (höchstwahrscheinlich) deutlich größer als Grahams Zahl
Ich habe mir eine schneller wachsende Funktion ausgedacht, die auf einer Erweiterung der Ackermann-Funktion basiert.
http://fora.xkcd.com/viewtopic.php?f=17&t=31598 hat mich inspiriert, aber Sie müssen nicht hinsehen, um meine Nummer zu verstehen.
Hier ist die modifizierte Version der ackermann-Funktion, die ich in meiner Analyse verwenden werde:
Meine Funktion
A
im obigen Code ist technisch nicht dieselbe, aber sie ist tatsächlich stärker. Die folgende Anweisung ersetzt die dritte Zeile der obigen Definition:(a muss mindestens 1 sein, also muss es stärker sein)
Für meine Zwecke gehe ich jedoch davon aus, dass es dasselbe ist wie das einfachere, da die Analyse bereits teilweise für Ackermanns Funktion und daher für diese Funktion durchgeführt wurde, wenn sie zwei Argumente hat.
Es ist garantiert, dass meine Funktion irgendwann nicht mehr rekursiv ist, weil sie immer entweder ein Argument entfernt, das erste Argument dekrementiert oder dasselbe erste Argument beibehält und das zweite Argument dekrementiert.
Größenanalyse
Grahams Nummer, AFAIK, kann wie folgt dargestellt
G(64)
werden:Wobei a
↑^(n)
b die Aufwärtspfeilnotation von knuth ist.Auch:
Die im obigen Programm angegebene Nummer lautet
A(0,1,2,3,4,...,123,124,125)
.Da
g^64(4)
es sich um Grahams Zahl handelt und ich davon ausgehe, dass meine Rechnung korrekt ist, ist sie kleiner alsA(1,64,100)
, und meine Zahl ist bedeutend größer als Grahams Zahl.Bitte weisen Sie auf Fehler in meiner Mathematik hin - auch wenn dies nicht der Fall ist, sollte dies die größte Zahl sein, die bisher berechnet wurde, um diese Frage zu beantworten.
quelle
range(ord('~'))
? Hätten Sie nichtrange(125)
weniger Bytes benötigen können, um eine höhere Anzahl von Bytes einzupressenrange(A(9,9,9))
?Perl - Score ≈ 10 ↑↑ 4.1
Wieder einmal missbrauchen wir die Regex-Engine von Perl, um durch eine unvorstellbare Anzahl von Kombinationen zu mahlen, diesmal mithilfe eines rekursiven Abstiegs.
Im innersten Teil des Ausdrucks haben wir ein Bare
.
, um eine unendliche Rekursion zu verhindern und somit die Rekursionsebenen auf die Länge der Zeichenkette zu beschränken.Was wir am Ende haben, ist Folgendes:
... 671088640- mal wiederholt , für insgesamt 12750684161 Nestings - was meinen vorherigen Versuch von 23 Nestings ziemlich gründlich in Verruf bringt . Es ist bemerkenswert, dass Perl nicht einmal daran drosselt (die Speichernutzung liegt wieder bei ungefähr 1,3 GB), obwohl es eine Weile dauern wird, bis die erste print-Anweisung überhaupt ausgegeben wird.
Aus meiner vorherigen Analyse unten kann geschlossen werden, dass die Anzahl der ausgegebenen Stellen in der Größenordnung von (! 12750684161) 671088640 liegt , wobei ! K die linke Fakultät von k ist (siehe A003422 ). Wir können dies als (k-1) approximieren ! , die streng kleiner ist, aber in der gleichen Größenordnung.
Und wenn wir wolframalpha fragen :
... was meine Punktzahl kaum verändert. Ich war mir sicher, dass das mindestens 10 ↑↑ 5 sein würde . Ich denke, der Unterschied zwischen 10 ↑↑ 4 und 10 ↑↑ 4.1 ist viel größer als man denkt.
Perl - Score ≈ 10 ↑↑ 4
Missbrauch der Perl-Regex-Engine, um Kombinatorik für uns zu betreiben. Der eingebettete Codeblock
(??{print})
fügt das Ergebnis direkt in den regulären Ausdruck ein . Da$_
es sich ausschließlich aus2
s zusammensetzt (und das Ergebnis vonprint
ist immer1
), kann dies niemals übereinstimmen und lässt Perl alle möglichen Kombinationen durchlaufen, von denen es nicht wenige gibt.Konstanten verwendet
$^F
- die maximale Systemdateikennung (normalerweise)2
.$]
- die Versionsnummer von Perl, ähnlich wie5.016002
.$_
ist dann eine Zeichenfolge, die die 671088640- mal2
wiederholte Ziffer enthält . Die Speichernutzung liegt konstant bei ca. 1,3 GB, die Ausgabe beginnt sofort.Analyse
Definieren wir P k (n) als die Häufigkeit, mit der die print-Anweisung ausgeführt wird, wobei k die Anzahl der Verschachtelungen und n die Länge der Zeichenfolge plus eins ist (nur weil ich keine Lust habe, n + 1 zu schreiben) überall).
(.*.*)*
P 2 (n) = [ 2, 8, 28, 96, 328, 1120, 3824, 13056, ... ]
((.*.*)*)*
P 3 (n) = [ 3, 18, 123, 900, 6693, 49926, 372615, 2781192, ... ]
(((.*.*)*)*)*
P 4 (n) = [ 4, 56, 1044, 20272, 394940, 7696008, 149970676, 2922453344, ... ]
((((.*.*)*)*)*)*
P 5 (n) = [ 5, 250, 16695, 1126580, 76039585, 5132387790, 346417023515, 23381856413800, ... ]
(((((.*.*)*)*)*)*)*
P 6 (n) = [ 6, 1452, 445698, 137050584, 42142941390, 12958920156996, ... ]
((((((.*.*)*)*)*)*)*)*
P 7 (n) = [ 7, 10094, 17634981, 30817120348, 53852913389555, ... ]
usw. Im Allgemeinen kann die Formel wie folgt verallgemeinert werden:
wo
Das heißt, die linke Fakultät von k , dh die Summe aller Fakultäten kleiner als k (siehe A003422 ).
Ich konnte keine geschlossenen Formen für D k und E k bestimmen , aber das spielt keine große Rolle, wenn wir das beobachten
und
Mit 23 Verschachtelungen erhalten wir eine ungefähre Punktzahl von:
Das sollte eigentlich fast genau sein.
Um dies jedoch in eine etwas einfacher zu visualisierende Notation zu bringen, können wir die Basis des inneren Exponenten approximieren:
und dann der Exponent selbst:
und dann frage wolframalpha :
Womit Sie auch einfach 10 ↑↑ 4 anrufen und fertig sind.
quelle
Javascript, 10 ↑↑↑↑ 210
100 Zeichen:
Basierend auf der Beobachtung, dass maximales Iterieren
f
der optimale Weg ist, ersetzte ich die 13 Aufrufef
durch 3 Ebenen verschachtelter Schleifenf
, die jeweilsz
mal aufgerufen werden (wobei dief
Anzahl zunimmtz
).Ich habe die Punktzahl analytisch auf einem Blatt Papier geschätzt - ich schreibe sie ein, wenn jemand daran interessiert ist, sie zu sehen.
Verbesserte Punktzahl: 10 ↑↑ 13
Nochmal Javascript in genau 100 Zeichen:
Dies verbessert meine ursprüngliche Antwort auf drei Arten:
Durch die Festlegung
z
des globalen Bereichs müssen wir nichto.z
jedes Mal neu eingeben .Es ist möglich, einen Getter für den globalen Gültigkeitsbereich (Fenster) und den Typ
f
anstelle von zu definiereno.f
.Wenn Sie mehr Iterationen von haben,
f
ist dies mehr wert, als(Math.E+'').replace('.','')
wenn Sie mit einer größeren Zahl beginnen. Verwenden Sie daher anstelle von (= 2718281828459045, 27 Zeichen)~~Math.E+''
(= 2, 11 Zeichen) und verwenden Sie die geborgenen Zeichen, umf
häufiger anzurufen .Da, wie weiter unten analysiert, jede Iteration aus einer Zahl in der Größenordnung M eine größere Zahl in der Größenordnung 10 M erzeugt , erzeugt dieser Code nach jeder Iteration
Score: ~ 10 10 10 10 10 16 ≈ 10 ↑↑ 6,080669764
Javascript, in genau 100 Zeichen:
Jeder
o.f
ruft die while-Schleife für insgesamt 5 Schleifen auf. Nach nur der ersten Iteration liegt die Punktzahl bereits über 10 42381398144233621 . Bei der zweiten Iteration konnte Mathematica nicht einmal die Anzahl der Stellen im Ergebnis berechnen .Hier ist eine exemplarische Vorgehensweise für den Code:
Drin
Beginnen Sie mit 2718281828459045, indem Sie das Komma von entfernen
Math.E
.Iteration 1
Verketten Sie die absteigende Folge von Zahlen,
eine neue (gigantische) Zahl bilden,
Wie viele Ziffern enthält diese Nummer? Nun, es ist die Verkettung von
In Mathematica
Mit anderen Worten, es ist 2,72 × 10 42381398144233625 .
Meine Punktzahl nach nur der ersten Iteration: 2,72 × 10 42381398144233619 .
Iteration 2
Das ist aber nur der Anfang. Wiederholen Sie nun die Schritte, beginnend mit der gigantischen Zahl ! Das heißt, verketten Sie die abnehmende Folge von Zahlen,
Also, was ist meine neue Punktzahl, Mathematica?
Iteration 3
Wiederholen.
Iteration 4
Wiederholen.
Iteration 5
Wiederholen.
Analytischer Score
In der ersten Iteration haben wir die Anzahl der Stellen in der Verkettung der absteigenden Folge berechnet, beginnend mit 2718281828459045, indem wir die Anzahl der Stellen in gezählt haben
Diese Summe kann durch die Formel dargestellt werden,
wobei Z die Startnummer bezeichnet ( z. B. 2718281828459045) und O Z seine Größenordnung bezeichnet ( z. B. 15, da Z ≤ 10 15 ). Unter Verwendung von Äquivalenzen für endliche Summen kann das Obige explizit ausgedrückt werden als
was sich, wenn wir 9 ≈ 10 nehmen, noch weiter auf reduziert
und schließlich, indem wir Terme erweitern und sie durch Verringern der Größenordnung ordnen, erhalten wir
Da wir nur an der Größenordnung des Ergebnisses interessiert sind, ersetzen wir Z durch "eine Zahl in der Größenordnung von O Z ", dh 10 O Z -
Schließlich werden der zweite und der dritte Term gestrichen, und die letzten beiden Terme können gelöscht werden (ihre Größe ist trivial)
von dem die erste Amtszeit siegt.
Angepasst,
f
nimmt eine Zahl in der Größenordnung von M und erzeugt eine Zahl ungefähr in der Größenordnung von M (10 M ).Die erste Iteration kann leicht von Hand überprüft werden. 2718281828459045 ist eine Zahl in der Größenordnung von 15 -
f
sollte daher eine Zahl in der Größenordnung von 15 (10 15 ) ∼ 10 16 ergeben . In der Tat ist die produzierte Anzahl von zuvor 2,72 · 10 42381398144233625 - das sind 10 42381398144233625 · 10 10 16 .Wenn man feststellt, dass M kein signifikanter Faktor in M (10 M ) ist, folgt die Größenordnung des Ergebnisses jeder Iteration einem einfachen Tetrationsmuster:
LaTeX-Quellen
quelle
f
die Zahlz
in etwa aus eigener Kraft gewonnen wird. Das ist so etwas wie↑↑↑
. Natürlich ist die Punktzahl nicht so2↑↑↑2
, wie2↑↑↑5+1
es scheint. Würden Sie zustimmen, sollte ich das in die Rangliste aufnehmen?i=o.z;while(i--)...
Sie die Schleifenzeiten nicht auso.z
, da eine Schleife auf einer Ganzzahlvariablen basiert undo.z
abhängig von der Wortgröße Ihres Interpreters eine Zeichenfolge enthält, die größer als die größte darstellbare Ganzzahl ist. Angenommen, Ihr Interpreter kann eine solche Zeichenfolge nicht in int konvertieren, sonderni
beginnt jedes Mal mit dem größten darstellbaren ganzzahligen Wert, z. B. 2 ^ 63, und nicht mit dem aktuellen Wert vono.z
.APL, 10 ↑↑ 3.4
Hier ist mein überarbeiteter Versuch:
100 Zeichen / Byte * -Programm, das auf der aktuellen Hardware ausgeführt wird (benötigt eine vernachlässigbare Menge an Speicher und reguläre 32-Bit-Int-Variablen), obwohl der Abschluss sehr lange dauern wird.
Sie können es tatsächlich auf einem APL-Interpreter ausführen und es beginnt mit dem Drucken von Ziffern. Wenn dies ausgefüllt werden darf, wird eine Zahl mit 10 × 123456789 und 44 Ziffern gedruckt .
Daher ist die Punktzahl 10 10 × 123456789 44 /100 3 ≈ 10 10 353 ≈ 10 ↑↑ 3,406161
Erläuterung
⎕D
ist eine vordefinierte konstante Zeichenfolge gleich'0123456789'
n←⍎⎕D
definiert n als die durch diese Zeichenfolge dargestellte Zahl: 123456789 (die <2 31 ist und daher als Regelungsvariable verwendet werden kann){⍞←⎕D}
druckt die 10 Ziffern ohne Zeilenvorschub auf die Standardausgabe{⍞←⎕D}⍣n
werde es n- mal tun (⍣
ist der "Power Operator": es ist weder *, /, noch ^, weil es keine mathematische Operation ist, es ist eine Art Schleife){⍞←n}⍣n⍣n
Der vorherige Vorgang wird n- mal wiederholt , daher werden die 10 Ziffern n 2- mal gedruckt{⍞←n}⍣n⍣n⍣n
werde es n 3 mal tun⍣n
, also druckt es n 44- mal die Zeichenfolge'0123456789'
.⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ *: APL kann in einem eigenen (älteren) Einzelbyte -Zeichensatz geschrieben werden, der APL-Symbole den oberen 128-Byte-Werten zuordnet
. Aus diesem Grund kann ein Programm mit N Zeichen , das nur ASCII-Zeichen und APL-Symbole verwendet, als N Byte lang betrachtet werden.
quelle
100 cubed
(100 ^ 3) für mich.{⍞←⎕D}
zu⍞←
denen spart drei Bytes , die Sie eine weitere hinzufügen können⍣n
und machen⊢n←⍎⎕D
in⌽⍕n←⍎⎕D
für eine 80-fache Steigerung. Wenn Sie das Laufen mit erlauben,⎕PP←17
verwenden Sie×⍨
stattdessen⌽⍕
fast die doppelte Anzahl der gedruckten Stellen.Haskell, Punktzahl: (2 2 2 65536 -3) / 1000000 ≈ 2 ↑↑ 7 ≈ 10 ↑↑ 4.6329710779
Dieses Programm besteht aus genau 100 Byte reinem Haskell-Code. Es wird die vierte Ackermann-Zahl gedruckt, die schließlich die gesamte verfügbare Energie, Materie und Zeit des Universums und darüber hinaus verbraucht (wodurch die weiche Grenze von 5 Sekunden leicht überschritten wird).
quelle
o=length[]
!q
Am Ende bekommst du ein Extra und sparst dir ein Byte dazu.Python, 2 ↑↑ 11/830584 ≈ 10 ↑↑ 8.632971 (Knuth-Aufwärtspfeil-Notation)
Wahrscheinlich hat kein Computer genug Speicher, um dies erfolgreich auszuführen, aber das ist nicht wirklich die Schuld des Programms. Wenn die Mindestsystemanforderungen erfüllt sind, funktioniert es.
Ja, dies führt eine Bitverschiebung bei Booleschen Werten durch.
True
wird1
in diesem Zusammenhang dazu gezwungen . Python hat Ganzzahlen beliebiger Länge.quelle
print True<<(True<<(True<<(True<<True<<True)))
, und das gibt eine 19k-Zeichenfolge aus.t=True
und danach verwendent
?$python -c 'print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))' Traceback (most recent call last): File "<string>", line 1, in <module> OverflowError: long int too large to convert to int
GolfScript 3.673e + 374
Ich denke, das
*
ist erlaubt, da es die Wiederholung von Strings anzeigt, nicht die Multiplikation.Erläuterung: Es
'~'(
verbleibt 126 (der ASCII-Wert von "~") auf dem Stapel. Kopieren Sie dann die Nummer, konvertieren Sie sie in eine Zeichenfolge und wiederholen Sie die Zeichenfolge 126 Mal. Das gibt126126126126...
was ungefähr1.26 e+377
. Die Lösung besteht aus 7 Zeichen, also dividieren durch7^3
, für eine Punktzahl von ungefähr3.673e+374
quelle
Ruby, wahrscheinlich unendlich, 54 Zeichen
x wird mit 97 initialisiert. Wir wiederholen dann die folgende Prozedur: Generiere x Zufallszahlen zwischen 0 und 1. Wenn sie alle gleich sind, beende und drucke x. Andernfalls doppelte x und wiederhole. Da Rubys Zufallszahlen eine Genauigkeit von 17 Stellen haben, beträgt die Wahrscheinlichkeit, in einem Schritt zu enden, 1 in (10e17) ^ x. Die Wahrscheinlichkeit, innerhalb von n Schritten zu enden, ist daher die Summe für x = 1 bis n von (1 / 10e17) ^ (2 ^ n), die zu 1 / 10e34 konvergiert. Dies bedeutet, dass für jede Zahl, egal wie groß, es überwiegend unwahrscheinlich ist, dass dieses Programm eine geringere Zahl ausgibt.
Nun ist natürlich die philosophische Frage, ob ein Programm, das weniger als 1 zu 10 ^ 34 Chancen hat, mit Schritt n für ein beliebiges n zu enden, jemals beendet werden kann. Wenn wir nicht nur von unendlicher Zeit und Kraft ausgehen, sondern davon, dass das Programm in der Lage ist, mit zunehmender Geschwindigkeit mit einer Geschwindigkeit zu laufen, die über der Geschwindigkeit liegt, mit der die Wahrscheinlichkeit eines Abbruchs abnimmt, können wir meines Erachtens tatsächlich die Wahrscheinlichkeit von machen Beenden bis zum Zeitpunkt t, der beliebig nahe bei 1 liegt.
quelle
GolfScript, ≈ f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (126))))))))
Dies wurde schamlos aus einer anderen Antwort von @Howard übernommen und beinhaltet Vorschläge von @Peter Taylor.
Mein Verständnis von GolfScript ist begrenzt, aber ich glaube, die oben genannten Operatoren
*
und^
sind nicht die vom OP verbotenen arithmetischen Operatoren.(Ich werde dies gerne löschen, wenn @Howard seine eigene Version einreichen möchte, die dieser sicherlich überlegen wäre.)
Dieses Programm berechnet eine Zahl, die etwa Fs ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (126)))))) ))) - eine neunfache Iteration von f ε 0 - wobei f ε 0 die Funktion in der schnell wachsenden Hierarchie ist , die ungefähr mit der gleichen Geschwindigkeit wächst wie die Goodstein-Funktion. (f ε 0wächst so schnell, dass die Wachstumsraten der Friedman'schen n (k) -Funktion und der k-fachen Conway-Kettenpfeile selbst im Vergleich zu nur einem einzigen nicht iterierten f ε 0 praktisch unbedeutend sind .)
quelle
'',:o;'oo',:t;
weist nur die Werte0
zuo
und2
zut
; wenn das gerade ist um fehlende Stellen zu arbeiten , dann kann es schwer zu abgekürzt wird,:o)):t;
, mit der Ausnahme , dass es kein Grund zu löschent
in erster Linie , weil man schreiben kann ,expr:t;{...}:f;[[[t]f]f]f
wie[[[expr:t]{...}:f~]f]f
Speicher weitere 3 Zeichen.o
: Ich bin mir ziemlich sicher,[0 126]f
dass einer größer sein wird, als[126]f
Sie einen Buchstaben speichern und die Ausgabe erhöhen. Obwohl Sie dort eine leere Zeichenfolge belassen, was wahrscheinlich die Sache kaputt macht: Es könnte besser sein, zu beginnen[[,:o'~'=]
[
sind unnötig, da Sie nichts anderes auf dem Stapel haben.Gleichstrom, 100 Zeichen
Wenn genügend Zeit und Speicher vorhanden sind, berechnet dies eine Zahl um 15 ↑ ¹ I 15. Ich hatte ursprünglich die Hyperoperationsfunktion implementiert , benötigte jedoch zu viele Zeichen für diese Herausforderung. Daher entfernte ich die Bedingungen
n = 2, b = 0
undn >= 3, b = 0
und wandelte dien = 1, b = 0
Bedingung in umn >= 1, b = 0
.Die einzigen arithmetischen Operatoren, die hier verwendet werden, sind Addition und Subtraktion.
BEARBEITEN: Wie in den Kommentaren versprochen, ist hier eine Aufschlüsselung der Funktionen dieses Codes:
Wie erwähnt, weicht dies von der Hyperoperationsfunktion dadurch ab, dass die Basisfälle für die Multiplikation und höher durch den Basisfall für die Addition ersetzt werden. Dieser Code verhält sich so, als ob
a*0 = a^0 = a↑0 = a↑↑0 ... = a
anstelle des mathematisch korrektena*0 = 0
unda^0 = a↑0 = a↑↑0 ... = 1
. Infolgedessen werden Werte berechnet, die etwas höher sind als sie sein sollten, aber das ist keine große Sache, da wir größere Zahlen anstreben. :)BEARBEITEN: Ich habe gerade bemerkt, dass eine Ziffer versehentlich in den Code eingedrungen ist, in dem Makro, für das Inkremente ausgeführt werden
n=0
. Ich habe es entfernt, indem ich es durch 'F' (15) ersetzte, was den Nebeneffekt hat, dass jede Inkrementoperation um 15 skaliert wird. Ich bin nicht sicher, wie sehr dies das Endergebnis beeinflusst, aber es ist jetzt wahrscheinlich viel größer.quelle
Keine Laufzeitbeschränkung mehr? OK dann.
Muss das Programm auf modernen Computern lauffähig sein?
Beide Lösungen verwenden eine 64-Bit-Kompilierung, dh
long
eine 64-Bit-Ganzzahl.C: größer als 10 (2 64 -1) 2 64 , was wiederum größer als 10 10 355393490465494856447 ≈ 10 ↑↑ 4.11820744 ist
88 Zeichen.
Um diese Formeln zu vereinfachen, benutze ich
t = 2^64-1 = 18446744073709551615
.main
ruftf
mit einem Parameter von auft
, der beit
jedem Ausdruck des Werts die Schleifenzeiten durchläuftt
, und ruftf
mit einem Parameter von auft-1
.Insgesamt Ziffern gedruckt:
20 * t
.Jeder dieser Aufrufe von
f
mit einem Parameter vont-1
iteriert diet
Zeiten, gibt den Wert aust
und ruft f mit einem Parameter von auft-2
.Gesamtzahl der gedruckten Stellen:
20 * (t + t*t)
Ich habe dieses Programm mit dem Äquivalent von 3-Bit-Ganzzahlen ausprobiert (ich habe festgelegt
i = 8
und hatte einen Hauptaufruff(7)
). Es traf die Druckanweisung 6725600 mal. Das7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7
klappt also glaube ich, dass dies die endgültige Zählung für das gesamte Programm ist:Gesamtzahl der gedruckten Stellen:
20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))
Ich bin mir nicht sicher, wie ich (2 64 -1) 2 64 berechnen soll . Diese Summe ist kleiner als (2 64 ) 2 64 , und ich benötige eine Zweierpotenz, um diese Berechnung durchzuführen. Daher berechne ich (2 64 ) 2 64 -1 . Es ist kleiner als das tatsächliche Ergebnis, aber da es eine Zweierpotenz ist, kann ich es zum Vergleich mit anderen Ergebnissen in eine Zehnerpotenz umwandeln.
Weiß jemand, wie man diese Summierung durchführt oder wie man (2 64 -1) 2 64 in 10 n konvertiert ?
Aber denken Sie daran, das ist die Anzahl der gedruckten Stellen. Der Wert der Ganzzahl ist 10, also 10 ^ 10 ^ 355393490465494856447
Dieses Programm hat eine Stapeltiefe von 2 ^ 64. Das sind 2 ^ 72 Bytes Speicher, nur um die Schleifenzähler zu speichern. Das sind 4 Milliarden Terabyte Schleifenzähler. Ganz zu schweigen von den anderen Dingen, die für 2 ^ 64 Rekursionsebenen auf den Stapel kommen würden.
Bearbeiten: Zwei Tippfehler wurden korrigiert und ein genauerer Wert für log2 (10) verwendet.
Bearbeiten 2: Warten Sie eine Sekunde, ich habe eine Schleife, die printf außerhalb ist. Lassen Sie uns das beheben. Initialisierung hinzugefügt
i
.Edit 3: Verdammt, ich habe die Mathematik bei der vorherigen Bearbeitung durcheinander gebracht. Fest.
Dieser wird auf modernen Computern ausgeführt, wird jedoch in Kürze nicht beendet.
C: 10 ^ 10 ^ 136 ≈ 10 ↑↑ 3.329100567
98 Zeichen.
Dies wird die bitweise Inverse von Null, 2 ^ 64-1, einmal für jede Iteration ausgeben. 2 ^ 64-1 ist eine 20-stellige Zahl.
Anzahl der Stellen =
20 * (2^64-1)^7
= 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187500Rundung der Programmlänge auf 100 Zeichen, Punktzahl = gedruckte Zahl / 1.000.000
Ergebnis = 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187494
quelle
%u
druckte 32-Bit-Zahlen sogar mit einer 64-Bit-Kompilierung, so dass ich es mir zurll
Gewohnheit machte, in einem 32-Bit-Compiler zu schreiben.%llu
wäre fürlong long
und%lu
wäre richtig fürlong
.%u
ist immer 32-Bit,%llu
ist immer 64-Bit, ob als 32 oder 64-Bit kompiliert. Für die Lösung hier ist jedochlong
eine 64-Bit-Version erforderlich. Sie haben also Recht, dies%lu
ist ausreichend.i
.R -
4941 Zeichen Code, 4.03624169270483442 * 10 ^ 5928 ≈ 10 ↑↑ 2.576681348druckt aus [reproduziert hier nur den Anfang]:
quelle
cat
ist insofern eine seltsame Funktion, als das erste Argument ist...
. Also geht alles vor dem ersten genannten Argument auf...
(und wirdcat
sep
cat(abs(.Random.seed),,"")
ECMAScript 6 - 10 ^ 3 ↑↑↑↑ 3/884736
(3 ↑↑↑↑ 3 ist G (1), wobei G (64) Grahams Zahl ist)
Ausgabe: 10 ^ 3 ↑↑↑↑ 3
Hinweise:
. Der KürzeG
ist die Funktion, bei der G (64) Grahams Zahl ist. Die Eingabe ist eine Ganzzahl. Die Ausgabe ist eine unäre Zeichenfolge, die mit 0 geschrieben wurdehalberentfernt.K
ist die Knuth-Aufwärtspfeil-Funktion a ↑ n b, wobei a implizit 3 ist. Die Eingabe ist n, eine unäre Zeichenfolge, und b, eine unäre Zeichenfolge. Die Ausgabe ist eine unäre Zeichenfolge.u
ist "1".v
ist "0000" oder G (0)e
ist "000".quelle
Maximum code length is 100 bytes;
Ansonsten ist dies nahezu unschlagbarC
(Mit Entschuldigung an Darren Stone)
n = 2 ^ 64 stellige Zahl (9 ...)
l = 100 Zeichen Code
Ergebnis 1e + 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936570 ≈ 10 ↑↑ 3.2974890744
[Score = n ^ 5 / l ^ 3 = (10 ^ (2 ^ 320) -1) / (100 ^ 3) = (10 ^ 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576-1) / (10 ^ 6]
Beachten Sie, dass ich es verdiene, für diese Antwort gnadenlos ausgepeitscht zu werden, aber nicht widerstehen konnte. Ich empfehle aus offensichtlichen Gründen nicht, wie ich bei StackExchange zu handeln. :-P
EDIT: Es wäre noch schwieriger, der Versuchung zu widerstehen, mit so etwas zu gehen
... aber ich nehme an, dass eine beabsichtigte, aber nicht spezifizierte Regel war, dass die gesamte Ziffernfolge, aus der die Nummer besteht, gedruckt werden muss.
quelle
)
, aber das ist in Ordnung, weil Sie im Moment nur 96 Zeichen haben.New Ruby: score ~ f ω ω2 +1 (126 2 2 126 )
wobei f α (n) die schnell wachsende Hierarchie ist.
Probieren Sie es online!
Das
*n
sind nur String- und Array-Multiplikationen, also sollten sie in Ordnung sein.Ungolfed-Code:
Dabei wird
b.-b<=>0
eine Ganzzahl zurückgegeben, die1
näher an0
als liegtb
.Erläuterung:
Es wird
n
zu Beginn jedes Aufrufs von gedrucktH
.H[[]]
verdoppelt sichn
(n
Zeiten), dhn = n<<n
.H[[0,a,b,c,...,z]]
AnrufeH[[a,b,c,...,z]]
(n
Zeiten).H[[k+1,a,b,c,...,z]]
ruft anH[[k]*n+[a,b,c,...,z]]
(n
mal), wo[k]*n = [k,k,...,k]
.H[[-1,a,b,c,...,z]]
AnrufeH[[n]*n+[a,b,c,...,z]]
(n
Zeiten).H[[-(k+1),a,b,c,...,z]]
AnrufeH[[-k]*n+[a,b,c,...,z]]
(n
Zeiten).H[k] = H[[k]]
.Mein Programm wird initialisiert
n = 126
und anschließendH[-n-1]
126 2 2 126 Mal aufgerufen .Beispiele:
H[[0]]
werde anrufenH[[]]
was zutrifftn = n<<n
(n
mal).H[[0,0]]
werde anrufenH[[0]]
(n
mal).H[[1]]
werde anrufenH[[0]*n]
(n
mal).H[[-1]]
werde anrufenH[[n]*n]
(n
mal).H[[-1,-1]]
werde anrufenH[[n]*n+[-1]]
(n
mal).H[[-3]]
werde anrufenH[[-2]*n]
(n
mal).Probieren Sie es online!
Siehe Revisionen für andere coole Dinge.
quelle
Haskell-Ackermann-Funktion, die 20-mal auf das Ergebnis angewendet wurde - 99 Zeichen
Dies ist die beste Haskell-Lösung, die ich basierend auf der Ackermann-Funktion finden kann - Sie können Ähnlichkeiten mit der Lösung von nm feststellen, das i = round $ log pi wurde von dort inspiriert und der Rest ist Zufall: D
Es führt die ackermann-Funktion 20-mal aus, beginnend mit eins, wobei die Sequenz die folgende ist
Wie für die Schätzung, sagt Wikipedia:
a (m, n) = 2 ↑ m - 2 (n + 3) - 3
Daraus können wir a3 (1) = a (61,61) = 2 ↑ 59 64 + 3 ersehen , was deutlich größer ist als g1 = 3 ↑ 4 3, es sei denn, die 3 am Anfang ist weitaus wichtiger als ich denke. Danach führt jede Ebene Folgendes aus (Verwerfen der unbedeutenden Konstanten in einem n ):
Wenn diese ungefähr äquivalent sind, dann ist a 20 (1) ~ = g 18 . Der Endterm in a n (a n-1 ) ist weit größer als 3, daher ist er möglicherweise höher als g 18 . Ich werde sehen, ob ich herausfinden kann, ob das auch nur eine einzige Iteration beschleunigen und zurückmelden würde.
quelle
length"a"
Speichert ein paar Bytes und ermöglicht Ihnen einen anderen.a
x86-Maschinencode - 100 Byte (zusammengestellt als MSDOS .com-Datei)
Hinweis: Kann die Regeln ein wenig verbiegen
Dieses Programm gibt 2 (65536 * 8 + 32) Neunen aus, was eine Punktzahl von (10 2 524320 -1) / 1000000 ergibt
Als Zähler verwendet dieses Programm den gesamten Stapel (64 KB) plus zwei 16-Bit-Register
Zusammengesetzter Code:
Versammlung:
quelle
C
Die Dateigröße beträgt 45 Bytes.
Das Programm ist:
Und die produzierte Anzahl ist größer als 10 ^ (10 ^ (10 ^ 1.305451600608433)).
Die Datei, auf die ich std umgeleitet habe, ist derzeit über 16 GB groß und wächst weiter.
Das Programm würde in angemessener Zeit beendet, wenn ich einen besseren Computer hätte.
Meine Punktzahl ist mit Gleitkommazahlen mit doppelter Genauigkeit nicht berechenbar.
quelle
GNU Bash, 10 ^ 40964096² /
80 ^ 3 ≈ 10 ↑↑ 2.072820169C = 4096 auf jedem vernünftigen System. SHLVL ist eine kleine positive Ganzzahl (normalerweise entweder 1 oder 2, je nachdem, ob / bin / sh bash ist oder nicht).
Nur 64-Bit-UNIX:
Ergebnis: ~ 10 ^ (40964096409640964096 * 40964096409640964096) / 88 ^ 3
quelle
bash -c 'bash -c "echo \$SHLVL"'
stat --printf
arbeite nicht Versuchen Siestat -c %s
C, 10 ^ 10 ^ 2485766 ≈ 10 ↑↑ 3.805871804
Wir erstellen ein Array von 258048 Ganzzahlen ohne Vorzeichen. Es konnten keine Longs ohne Vorzeichen sein, da das Programm dadurch zu lang wurde. Sie sind unsigniert, da ich kein undefiniertes Verhalten verwenden möchte. Dieser Code ist das richtige C (abgesehen von der fehlenden Rückkehr von main ()) und wird auf jedem normalen Computer kompiliert und ausgeführt. Er wird jedoch noch lange ausgeführt . Diese Größe ist die größte, die wir legal ausdrücken können, ohne Nicht-ASCII-Zeichen zu verwenden.
Wir durchlaufen das Array beginnend mit dem letzten Element. Wir drucken die Ziffern von
2^32-1
, inkrementieren das Element und löschen die Schleife, wenn das Element nicht auf 0 gesetzt ist. Auf diese Weise wiederholen wir die(2^32 - 1)^254048 = 2^8257536
Zeiten und drucken jedes Mal 10 Ziffern.Hier ist ein Beispielcode, der das Prinzip in einem begrenzten Datenbereich zeigt:
Das Ergebnis ist ungefähr 10 ^ 10 ^ 2485766 geteilt durch eine Million, was immer noch ungefähr 10 ^ 10 ^ 2485766 entspricht.
quelle
Powershell (2.53e107976 / 72³ = 6.78e107970 ≈ 10 ↑↑ 1.701853371)
Dies dauert weit mehr als 5 Sekunden.
Es ruft die Bytelänge jeder Datei auf Ihrem aktuellen Laufwerk ab und verkettet sie. Regex entfernt alle nichtstelligen Zeichen.
quelle
0
.-ea(+'')
, um die Größe zu reduzieren (''
konvertiert in eine Zahl0
, die der Enum-Wert von istSilentlyContinue
). Sie können\D
für den Ersatz Regex verwenden, der der gleiche ist wie[^\d]
. Und Sie können einfach verwenden,%{$_.Length}
anstattselect Length
die Spaltenüberschriften loszuwerden. Und dann können Sie das-split
und-replace
auch loswerden , wobei Sie-join(gci \ -ea(+'')-r|%{$_.Length})
37 Zeichen kürzer bleiben (ich habe auch die Parameter neu angeordnet, weil die Klammern sowieso benötigt werden+''
).Python 3, score = ack (126, 126) / 100 ^ 3
Die f-Funktion ist die ackermann-Funktion, die ich gerade genug Platz habe, um aufzurufen.
Edit: zuvor "else n + 1", was gegen die Herausforderungsregeln verstieß - Kudos für Simply Beautiful Art.
quelle
f(m-g,g)
zuf(m-g,m)
.f(m-g,i)
. Außerdem verwenden Sie am Ende der ersten Zeile eine Zahl. Ich glaube, Sie wollten verwendenn+g
, worauf ich hinweisen werde,n+n
wird größer sein.JavaScript 98 Zeichen
generiert 2.718e + 239622337 ≈ 10 ↑↑ 2.9232195202
Für eine Punktzahl von nur etwas mehr als 2.718e + 239622331 ≈ 10 ↑↑ 2.9232195197
Das ist das größte, das ich machen kann, ohne dass der Browser abstürzt.
(console.log (a) zeigt die vollständige Ausgabe an)
Führen Sie diese nicht aus:
würde 2,718 + e121333054704 ≈ 10 ↑↑ 3,0189898069 (aka 2,718 * 10 ^ (1,213 * 10 ^ 12) ausgeben, um mit der längeren Antwort zu vergleichen:
Extremere Version, wenn Ihr Browser nicht abgestürzt ist: (80 Zeichen)
Dies würde eine Zahl in der Größenordnung von e * 10 ^ (10 ^ 19) ≈ 10 ↑↑ 3.106786869689 erzeugen
Bearbeiten: Aktualisierte Code-Originallösung generiert nur 2.718e + 464
quelle
Python 3: 98 Zeichen, ≈ 10 ↑↑ 256
Verwenden einer Variablenargumentfunktion:
Tatsächlich dekrementiert E das erste Argument, während der Rest der Argumente erhöht wird, mit der Ausnahme, dass es das Argument löscht, anstatt -1 in die Argumente einzufügen. Da jeder Zyklus entweder das erste Argument dekrementiert oder die Anzahl der Argumente verringert, ist garantiert, dass dies beendet wird. Die verwendete ansteigende Funktion ist int ("% d% d"% (k, k)), was ein Ergebnis zwischen k ** 2 + 2 * k und 10 * k ** 2 + k ergibt. Mein Code verwendet das Symbol * - aber nicht als Multiplikation. Es wird verwendet, um mit variablen Anzahlen von Argumenten zu arbeiten, die meiner Meinung nach den Regeln folgen sollten, da der klare Punkt der Regeln darin bestand, bestimmte Operationen einzuschränken, nicht die Symbole selbst.
Einige Beispiele, wie schnell E wird:
Nur die ersten beiden können in angemessener Zeit auf meinem Computer ausgeführt werden.
Dann wird E aufgerufen durch
E(*range(ord('~')))
- was bedeutet:Ich bin nicht ganz sicher, wie groß das ist (ich habe versucht, es ohne Erfolg zu approximieren) - aber es ist offensichtlich, dass es ~ wirklich ~ groß ist.
Als Beispiel, ungefähr zwölf Zyklen in, ist das Ergebnis ungefähr: (technisch ein bisschen mehr als)
Ergebnisschätzung:
Wenn wir uns dem zunehmenden Schritt annähern
lambda k: 10 * k**2
, kann die Funktion als beschrieben werdenDie relevante Sache, die wir hier tun, ist, einen Turm aus Zehnerpotenzen aufzubauen, sodass die endgültige Punktzahl als 10 ↑↑ 256 angenähert werden kann.
Bessere (wenn auch teilweise) Ergebnisschätzung:
Dies verwendet dasselbe
10 * k**2
wie die andere Schätzung.Nach der vorherigen Schätzung wäre es:
Welches ist deutlich kleiner als der tatsächliche Wert, da es
a**2
anstelle2**a
für die 10 unda*2
anstelle2**a
für die b verwendet.quelle
C (Punktzahl ≈ 10 ^ 20 000 000 000 ≈ 10 ↑↑ 3,005558275)
Trotz
rand()
der Ausgabe ist deterministisch, da es keine Seed-Funktion gibt.quelle
rand()
als Abbruchbedingung macht es nicht deterministisch. Darüber hinaus sollte das Aufrufenrand()
jeder Iteration es schrecklich langsam machen. Verwenden Sie stattdessen etwas wie inLONG_MAX
definiertlimits.h
.non deterministic
Rücken, weil es keinen Samen gibt, wie du geschrieben hast.~' '
statt mitrand()
gedruckt%u
? Zwei Bytes weniger Quelle und ein höherer Wert.