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 10000000und Ihr Code ist 100byteslang. 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 2nicht 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

1. Steven H. , Pyth ≈ f _{φ (1,0,0) +7} (256 ²⁶ ) / 1000000 ^[1]
2. Einfach schöne Kunst , Rubin ≈ f _{φ 121 (ω)} (126) ^[1]
3. Peter Taylor , GolfScript ≈ f _{ε 0 + ω + 1} (17) / 1000 ^[1]
4. res , GolfScript ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126)))))))) ^[1]
5. Simply Beautiful Art , Rubin ≈ f _{ω ^ω2 +1} (1983)
6. eaglgenes101 , Julia ≈ f _ω3 (127)
7. col6y , Python 3, ≈ (127 → 126 → ... → 2 → 1) / 99 ^{3 [1] [3]}
8. Toeofdoom , Haskell, ≈ a ₂₀ (1) / 99 ^{3 [1]}
9. Fraxtil , dc, ≈ 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15/100 ^{3 [3]}
10. Magenta , Python, ≈ ack (126, 126) / 100 ³ ≈ 10 ↑ ¹²⁴ 129
11. Kendall Frey , ECMAScript 6, ≈ 10 ^{3 ↑ 4 3} /100 ^{3 [1]}
12. Ilmari Karonen , GolfScript, ≈ 10 ↑ ³ 10 ³⁷⁷ /18 ^{3 [1]}
13. BlackCap , Haskell, ≈ 10 ↑↑ 65503/100 ³
14. rekursiv , Python, ≈ 2 ↑↑ 11/95 ³ ≈ 10 ↑↑ 8.63297 ^{[1] [3]}
15. nm , Haskell, ≈ 2 ↑↑ 7/100 ³ ≈ 10 ↑↑ 4,63297 ^[1]
16. David Yaw , C, ≈ 10 ^{10 4 × 10 22} /83 ³ ≈ 10 ↑↑ 4,11821 ^[2]
17. PRIMO , Perl, 10 ≈ ^{(12750684161!) 5 × 2 27} /100 ³ ≈ 10 ↑↑ 4,11369
18. Art , C, ≈ 10 ^{10 2 × 10 6} /98 ³ ≈ 10 ↑↑ 3,80587
19. Robert Sørlie , x86, ≈ 10 ^{2 2 19 +32} / 100 ³ ≈ 10 ↑↑ 3.71585
20. Tobia , APL, ≈ 10 ^{10 353} /100 ³ ≈ 10 ↑↑ 3,40616
21. Darren Stone , C, 10 ^{10 97.61735} / 98 ³ ≈ 10 ↑↑ 3.29875
22. ecksemmess , C, ≈ 10 ^{2 320} /100 ³ ≈ 10 ↑↑ 3,29749
23. Adam Speight , vb.net, ≈ 10 ^{5000 × (2 64 ) 4} /100 ³ ≈ 10 ↑↑ 3,28039
24. Joshua , bash, ≈ 10 ^{10 15} /86 ³ ≈ 10 ↑↑ 3,07282

_Fußnoten

1. ^{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.}
2. ^{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.}
3. ^{Alle derzeit verfügbaren Interpreter geben einen Laufzeitfehler aus, oder das Programm wird ansonsten nicht wie vom Autor beabsichtigt ausgeführt.}
4. ^{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))

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:

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g

berechnet, g(g(1)) = g(5)wo g(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

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{.{.{.{.{.{.{.{.{.{g}*}*}*}*}*}*}*}*}*}*

.{foo}*Karten xzu foo^x x.

,:z){[]+z\{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{g}*

so gibt g^(g(5)) ( g(5) ); Die weiteren 8 Iterationsstufen ähneln der Pfeilverkettung. Einfach ausgedrückt: Wenn h_0 = gund h_{i+1} (x) = h_i^x (x)dann berechnen wir h_10 (g(5)).

Ich denke, dass dieses zweite Programm mit ziemlicher Sicherheit viel besser abschneidet. Diesmal ist das der Funktion zugewiesene Label gein Zeilenvorschub.

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:
~
{.['.{
}*'n/]*zip n*~}:^~^^^^^^^^^^^^^^^^

Diesmal nutze ich besser ^als andere Funktion.

.['.{
}*'n/]*zip n*~

nimmt xden Stapel auf und geht, xgefolgt von einer Zeichenkette, die xKopien .{von enthält, ggefolgt von xKopien von }*; Anschließend wird die Zeichenfolge ausgewertet. Da ich einen besseren Ort zum Brennen von Ersatzcharakteren hatte, beginnen wir mit j_0 = g; wenn j_{i+1} (x) = j_i^x (x)dann die erste auswertung von ^rechnern j_{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 wenn k_0 = g(5)und k_{i+1} = j_{k_i} (k_i)dann rechnet es k_17. Ich bin (wieder) dankbar, res für die Schätzung von k_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.

CD|Format D:/FS:FAT/V/Q

Ausgabe bei Ausführung auf einem 4-TB-Laufwerk mit der ersten gedruckten Nummer in Fettdruck.

Legen Sie eine neue Diskette für Laufwerk D: ein
und drücken Sie die EINGABETASTE, wenn Sie fertig sind. Der Typ des Dateisystems ist NTFS.
Das neue Dateisystem ist FAT.
QuickFormatting 3907172M
Die Lautstärke ist zu groß für FAT16 / 12.

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 ³⁷⁷ :

'~'(.`*

(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 ³⁷⁷ Mal:

'~'(.`*.~*

Dieses Programm wird nie beendet, da es versucht, eine Zahl mit etwa 10 ³⁸⁰ ≈ 2 ¹¹⁴⁰ 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 ⁸⁰ , 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 ³⁸⁰ /10 ⁸⁰ = 10 ³⁰⁰ 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 ³⁷⁷ 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 ↑ ³ 10 ^{377 betragen} . Geben oder nehmen Sie ein paar (oder 10 ³⁷⁷ ) 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. ;-)

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

C, Score = 10 ^{10 97,61735} / 98 ³ ≈ 10 ↑↑ 2,29874984

unsigned long a,b,c,d,e;main(){while(++a)while(++b)while(++c)while(++d)while(++e)printf("%lu",a);}

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 ⁶⁴ -1, ^4- mal wiederholt (2 ⁶⁴ -1) . Zunächst schätze ich die kumulative Anzahl der Stellen von 1 bis 2 ⁶⁴ -1 (die "Teilfolge") wie folgt: Die endgültige Zahl in der Teilfolge ist 2 ⁶⁴ -1 = 18446744073709551615mit 20 Stellen. Somit haben mehr als 90% der Zahlen in der Untersequenz (die mit 1.. beginnen 9) 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 ⁴ Mal wiederholt (2 ⁶⁴ -1) , also die Längevon n beträgt mindestens (0,9 × (2 ⁶⁴ -1) × 19 + 0,1 × (2 ⁶⁴ -1) × 10) × (2 ⁶⁴ -1) ⁴ = 3,86613 × 10 ⁹⁷ Stellen. In den Kommentaren unten bestätigt @primo, dass die Länge von n 4,1433 x 10 ⁹⁷ beträgt . Also wird n selbst 10 zu dieser Potenz sein, oder 10 ^{10 97.61735} .

l = 98 Zeichen Code

Score = n / l ³ = 10 ^{10 97,61735} / 98 ³

Voraussetzung: Muss auf einem 64-Bit-Computer ausgeführt werden sizeof(long) == 8. Mac und Linux werden es schaffen.

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.

A=lambda a,b,*c:A(~-a,A(a,~-b,*c)if b else a,*c)if a else(A(b,*c)if c else-~b);A(*range(ord('~')))

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:

A(b)=b+1
A(0,b,...)=A(b,...)
A(a,0,...)=A(a-1,1,...)
A(a,b,...)=A(a-1,A(a,b-1,...),...)

Meine Funktion Aim obigen Code ist technisch nicht dieselbe, aber sie ist tatsächlich stärker. Die folgende Anweisung ersetzt die dritte Zeile der obigen Definition:

A(a,0,...)=A(a-1,a,...)

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

G(n) = g^n(4)
g(n) = 3 ↑^(n) 3

Wobei a ↑^(n)b die Aufwärtspfeilnotation von knuth ist.

Auch:

A(a,b) = 2 ↑^(a-2) (b+3) - 3
A(a,0) ≈ 2 ↑^(a-2) 3
g(n) ≈ A(n+2,0) // although it will be somewhat smaller due to using 2 instead of 3. Using a number larger than 0 should resolve this.
g(n) ≈ A(n+2,100) // this should be good enough for my purposes.

g(g(n)) ≈ A(A(n+2,100),100)

A(1,a+1,100) ≈ A(0,A(1,a,100),100) = A(A(1,a,100),100)

g^k(n) ≈ A(A(A(A(...(A(n+2,100)+2)...,100)+2,100)+2,100)+2,100) // where there are k instances of A(_,100)
A(1,a,100) ≈ A(A(A(A(...(A(100+2),100)...,100),100),100),100)

g^k(100) ≈ A(1,k,100)
g^k(4) < A(1,k,100) // in general
g^64(4) < A(1,64,100)

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 als A(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.

Perl - Score ≈ 10 ↑↑ 4.1

$_=$^Fx($]<<-$]),/(?<R>(((((((((((((((((((.(?&R))*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

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

$_=$^Fx($]<<-$]),/((((((((((((((((((((((.*.*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

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 aus 2s zusammensetzt (und das Ergebnis von printist immer 1), 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 wie 5.016002.

$_ist dann eine Zeichenfolge, die die 671088640- mal 2wiederholte 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 ₂ (n) = [ 2, 8, 28, 96, 328, 1120, 3824, 13056, ... ]

((.*.*)*)*
P ₃ (n) = [ 3, 18, 123, 900, 6693, 49926, 372615, 2781192, ... ]

(((.*.*)*)*)*
P ₄ (n) = [ 4, 56, 1044, 20272, 394940, 7696008, 149970676, 2922453344, ... ]

((((.*.*)*)*)*)*
P ₅ (n) = [ 5, 250, 16695, 1126580, 76039585, 5132387790, 346417023515, 23381856413800, ... ]

(((((.*.*)*)*)*)*)*
P ₆ (n) = [ 6, 1452, 445698, 137050584, 42142941390, 12958920156996, ... ]

((((((.*.*)*)*)*)*)*)*
P ₇ (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.

Javascript, 10 ↑↑↑↑ 210

100 Zeichen:

z=~~Math.E+'';o={get f(){for(i=z;i--;)z+=i}};o.f;for(i=z;i--;)for(j=z;j--;)for(k=z;k--;)o.f;alert(z)

Basierend auf der Beobachtung, dass maximales Iterieren fder optimale Weg ist, ersetzte ich die 13 Aufrufe fdurch 3 Ebenen verschachtelter Schleifen f, die jeweils zmal aufgerufen werden (wobei die fAnzahl zunimmt z).

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:

z=~~Math.E+'';__defineGetter__('f',function(){for(i=z;i--;)z+=i});f;f;f;f;f;f;f;f;f;f;f;f;f;alert(z)

Dies verbessert meine ursprüngliche Antwort auf drei Arten:

1. Durch die Festlegung zdes globalen Bereichs müssen wir nicht o.zjedes Mal neu eingeben .

2. Es ist möglich, einen Getter für den globalen Gültigkeitsbereich (Fenster) und den Typ fanstelle von zu definieren o.f.

3. Wenn Sie mehr Iterationen von haben, fist 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, um fhä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

1. 210 ∼ O (10 ² )
2. O (10 ^{10 2} ) ∼ O (10 ↑↑ 2)
3. O (10 ^{10 ↑↑ 2} ) = O (10 ↑↑ 3)
4. O (10 ^{10 ↑↑ 3} ) = O (10 ↑↑ 4)
5. O (10 ^{10 ↑↑ 4} ) = O (10 ↑↑ 5)
6. O (10 ^{10 ↑↑ 5} ) = O (10 ↑↑ 6)
7. O (10 ^{10 ↑↑ 6} ) = O (10 ↑↑ 7)
8. O (10 ^{10 ↑↑ 7} ) = O (10 ↑↑ 8)
9. O (10 ^{10 ↑↑ 8} ) = O (10 ↑↑ 9)
10. O (10 ^{10 ↑↑ 9} ) = O (10 ↑↑ 10)
11. O (10 ^{10 ↑↑ 10} ) = O (10 ↑↑ 11)
12. O (10 ^{10 ↑↑ 11} ) = O (10 ↑↑ 12)
13. O (10 ^{10 ↑↑ 12} ) = O (10 ↑↑ 13)

Score: ~ 10 ^{10 10 10 10 16} ≈ 10 ↑↑ 6,080669764

Javascript, in genau 100 Zeichen:

o={'z':(Math.E+'').replace('.',''),get f(){i=o.z;while(i--){o.z+=i}}};o.f;o.f;o.f;o.f;o.f;alert(o.z)

Jeder o.fruft 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,

• 2718281828459045
• 2718281828459044
• 2718281828459043
• ...
• 3
• 2
• 1
• 0

eine neue (gigantische) Zahl bilden,

• 271828182845904527182818284590442718281828459043 ... 9876543210.

Wie viele Ziffern enthält diese Nummer? Nun, es ist die Verkettung von

• 1718281828459046 16-stellige Nummern
• 900000000000000 15-stellige Nummern
• 90000000000000 14-stellige Nummern,
• 9000000000000 13-stellige Nummern
• ...
• 900 dreistellige Nummern
• 90 zweistellige Nummern
• 10 einstellige Nummern

In Mathematica

In[1]:= 1718281828459046*16+Sum[9*10^i*(i+1),{i,-1,14}]+1
Out[1]= 42381398144233626

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,

• 271828182845904527182818284590442718281828459043 ... 9876543210
• 271828182845904527182818284590442718281828459043 ... 9876543209
• 271828182845904527182818284590442718281828459043 ... 9876543208
• ...
• 3
• 2
• 1
• 0

Also, was ist meine neue Punktzahl, Mathematica?

In[2]:= 1.718281828459046*10^42381398144233624*42381398144233625 + Sum[9*10^i*(i + 1), {i, -1, 42381398144233623}] + 1

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

Out[2]= Overflow[]

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

• 1718281828459046 16-stellige Nummern
• 900000000000000 15-stellige Nummern
• 90000000000000 14-stellige Nummern,
• 9000000000000 13-stellige Nummern
• ...
• 900 dreistellige Nummern
• 90 zweistellige Nummern
• 10 einstellige Nummern

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 ¹⁵ ). 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, fnimmt 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 - fsollte daher eine Zahl in der Größenordnung von 15 (10 ¹⁵ ) ∼ 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:

1. 10 ¹⁶
2. 10 ^{10 16}
3. 10 ^{10 10 16}
4. 10 ^{10 10 10 16}
5. 10 ^{10 10 10 10 16}

LaTeX-Quellen

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\sum_{k=0}^{\mathcal{O}_Z-1}{(9\cdot10^k(k+1))}+1

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\frac{10-\mathcal{O}_Z10^{\mathcal{O}_Z}+(\mathcal{O}_Z-1)10^{\mathcal{O}_Z+1}}{9}+10^{\mathcal{O}_Z}

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+1

Z\mathcal{O}_Z+Z-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}+10^{\mathcal{O}_Z}-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}

APL, 10 ↑↑ 3.4

Hier ist mein überarbeiteter Versuch:

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

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 ⁴⁴ Ziffern gedruckt .

Daher ist die Punktzahl 10 ^{10 × 123456789 44} /100 ³ ≈ 10 ^{10 353} ≈ 10 ↑↑ 3,406161

Erläuterung

• ⎕D ist eine vordefinierte konstante Zeichenfolge gleich '0123456789'
• n←⍎⎕Ddefiniert 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}⍣nwerde 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⍣nDer vorherige Vorgang wird n- mal wiederholt , daher werden die 10 Ziffern n ^2- mal gedruckt
• {⍞←n}⍣n⍣n⍣nwerde es n ³ mal tun
• Ich könnte dort 44 hineinpassen ⍣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.}

Haskell, Punktzahl: (2 ^{2 2 65536} -3) / 1000000 ≈ 2 ↑↑ 7 ≈ 10 ↑↑ 4.6329710779

o=round$sin pi
i=succ o
q=i+i+i+i
m!n|m==o=n+i
 |n==o=(m-i)!i
 |True=(m-i)!(m!(n-i))
main=print$q!q

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

Python, 2 ↑↑ 11/830584 ≈ 10 ↑↑ 8.632971 (Knuth-Aufwärtspfeil-Notation)

print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))

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. Truewird 1in diesem Zusammenhang dazu gezwungen . Python hat Ganzzahlen beliebiger Länge.

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 gibt 126126126126...was ungefähr 1.26 e+377. Die Lösung besteht aus 7 Zeichen, also dividieren durch 7^3, für eine Punktzahl von ungefähr3.673e+374

Ruby, wahrscheinlich unendlich, 54 Zeichen

x='a'.ord
x+=x while x.times.map(&:rand).uniq[x/x]
p x

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.

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.

[[[[[[[[[,:o;'~'(]{o:?~%{(.{[(]{:^o='oo',$o+o=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:f~]f]f]f]f]f]f]f]f

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 _{ε 0}wä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 .)

Gleichstrom, 100 Zeichen

[lnA A-=ilbA A-=jlaSalbB A--SbLndB A--SnSnlhxlhx]sh[LaLnLb1+sbq]si[LbLnLasbq]sjFsaFsbFFFFFFsnlhxclbp

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 = 0und n >= 3, b = 0und wandelte die n = 1, b = 0Bedingung in um n >= 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:

[            # start "hyperoperation" macro
lnA A-=i     # if n == 0 call macro i
lbA A-=j     # if b == 0 call macro j
laSa         # push a onto a's stack
lbB A--Sb    # push b-1 onto b's stack
LndB A--SnSn # replace the top value on n with n-1, then push n onto n's stack
lhxlhx       # call macro h twice
]sh          # store this macro in h

[            # start "increment" macro (called when n=0, the operation beneath addition)
LaLnLb       # pop a, b, and n
F+sb         # replace the top value on b with b+15
q            # return
]si          # store this macro in i

[            # start "base case" macro (called when n>0 and b=0)
LbLnLa       # pop b, n, and a
sb           # replace the top value on b with a
q            # return
]sj          # store this macro in j

Fsa          # store F (15) in a
Fsb          # store F (15) in b
FFFFFFsn     # store FFFFFF "base 10" (150000+15000+1500+150+15=1666665) in n
lhx          # load and call macro h
lbp          # load and print b

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 ... = aanstelle des mathematisch korrekten a*0 = 0und a^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.

Keine Laufzeitbeschränkung mehr? OK dann.

Muss das Programm auf modernen Computern lauffähig sein?

Beide Lösungen verwenden eine 64-Bit-Kompilierung, dh longeine 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

long z;void f(long n){long i=z;while(--i){if(n)f(n+~z);printf("%lu",~z);}}main(){f(~z);}

88 Zeichen.

Um diese Formeln zu vereinfachen, benutze ich t = 2^64-1 = 18446744073709551615.

mainruft fmit einem Parameter von auf t, der bei tjedem Ausdruck des Werts die Schleifenzeiten durchläuft t, und ruft fmit einem Parameter von auf t-1.

Insgesamt Ziffern gedruckt: 20 * t.

Jeder dieser Aufrufe von fmit einem Parameter von t-1iteriert die tZeiten, gibt den Wert aus tund ruft f mit einem Parameter von auf t-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 = 8und hatte einen Hauptaufruf f(7)). Es traf die Druckanweisung 6725600 mal. Das 7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7klappt 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 ⁶⁴ -1) ^{2 64} berechnen soll . Diese Summe ist kleiner als (2 ⁶⁴ ) ^{2 64} , und ich benötige eine Zweierpotenz, um diese Berechnung durchzuführen. Daher berechne ich (2 ⁶⁴ ) ^{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 ⁶⁴ -1) ^{2 64} in 10 ⁿ konvertiert ?

20 * 2 ^ 64 ^ (2 ^ 64-1)
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^ (64 * 18446744073709551615)
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
Teilen Sie diesen Exponenten durch logarithmische Basis 2 von 10, um die Basis des Exponenten auf Potenzen von 10 zu setzen.
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

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

#define w(q) while(++q)
long a,b,c,d,e,f,g,x;main(){w(a)w(b)w(c)w(d)w(e)w(f)w(g)printf("%lu",~x);}

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= 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187500

Rundung der Programmlänge auf 100 Zeichen, Punktzahl = gedruckte Zahl / 1.000.000

Ergebnis = 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187494

R - 49 41 Zeichen Code, 4.03624169270483442 * 10 ^ 5928 ≈ 10 ↑↑ 2.576681348

set.seed(T)
cat(abs(.Random.seed),sep="")

druckt aus [reproduziert hier nur den Anfang]:

403624169270483442010614603558397222347416148937479386587122217348........

ECMAScript 6 - 10 ^ 3 ↑↑↑↑ 3/884736

(3 ↑↑↑↑ 3 ist G (1), wobei G (64) Grahams Zahl ist)

u=-~[v=+[]+[]]+[];v+=e=v+v+v;D=x=>x.substr(u);K=(n,b)=>b[u]?n?K(D(n),K(n,D(b))):b+b+b:e;u+K(v,e)

Ausgabe: 10 ^ 3 ↑↑↑↑ 3

Hinweise:

Gist 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 wurde . Der Kürze halber entfernt.

Kist die Knuth-Aufwärtspfeil-Funktion a ↑ ⁿ 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".

C

(Mit Entschuldigung an Darren Stone)

long n,o,p,q,r;main(){while(--n){while(--o){while(--p){while(--q){while(--r){putchar('z'-'A');}}}}}}

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

long n;main(){putchar('z'-'A');putchar('e');putchar('+');while(--n){putchar('z'-'A');}

... aber ich nehme an, dass eine beabsichtigte, aber nicht spezifizierte Regel war, dass die gesamte Ziffernfolge, aus der die Nummer besteht, gedruckt werden muss.

New Ruby: score ~ ​​f _{ω ^ω2 +1} (126 ² 2 ¹²⁶ )

wobei f _α (n) die schnell wachsende Hierarchie ist.

n=?~.ord;H=->a{b,*c=a;eval"b ?H[b==$.?c:[b==~$.?n:b-(b<=>$.)]*n+c]:p(n+=n);"*n};eval"H[~n];".*n*n<<n

Probieren Sie es online!

Das *nsind nur String- und Array-Multiplikationen, also sollten sie in Ordnung sein.

Ungolfed-Code:

n = 126
H =-> a {
    b, *c = a
    n.times{
        case b
        when nil
            puts(n += n)
        when 0
            H[c]
        when -1
            H[[n]*n+c]
        else
            H[[b.-b<=>0]*n+c]
        end
    }
}
(n*n<<n).times{H[~n]}

Dabei wird b.-b<=>0eine Ganzzahl zurückgegeben, die 1näher an 0als liegt b.

Erläuterung:

Es wird nzu Beginn jedes Aufrufs von gedruckt H.

H[[]]verdoppelt sich n( nZeiten), dh n = n<<n.

H[[0,a,b,c,...,z]]Anrufe H[[a,b,c,...,z]]( nZeiten).

H[[k+1,a,b,c,...,z]]ruft an H[[k]*n+[a,b,c,...,z]]( nmal), wo [k]*n = [k,k,...,k].

H[[-1,a,b,c,...,z]]Anrufe H[[n]*n+[a,b,c,...,z]]( nZeiten).

H[[-(k+1),a,b,c,...,z]]Anrufe H[[-k]*n+[a,b,c,...,z]]( nZeiten).

H[k] = H[[k]].

Mein Programm wird initialisiert n = 126und anschließend H[-n-1]126 ² 2 ¹²⁶ Mal ^aufgerufen .

Beispiele:

H[[0]]werde anrufen H[[]]was zutrifft n = n<<n( nmal).

H[[0,0]]werde anrufen H[[0]]( nmal).

H[[1]]werde anrufen H[[0]*n]( nmal).

H[[-1]]werde anrufen H[[n]*n]( nmal).

H[[-1,-1]]werde anrufen H[[n]*n+[-1]]( nmal).

H[[-3]]werde anrufen H[[-2]*n]( nmal).

Probieren Sie es online!

Siehe Revisionen für andere coole Dinge.

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

i=round$log pi
n?m|m<i=n+i|n<i=i?(m-i)|True=(n-i)?m?(m-i)
a n=n?n
b=a.a.a.a
main=print$b$b$b$b$b$i

Es führt die ackermann-Funktion 20-mal aus, beginnend mit eins, wobei die Sequenz die folgende ist

• 1,
• 3,
• 61,
• a (61,61),
• a (a (61,61), a (61,61)) --- wir nennen dies eine ₂ (61) oder eine ₄ (1) ---
• a ₃ (61)
• ...
• a ₁₈ (61) oder a ₂₀ (1). Ich denke, das ist ungefähr g ₁₈ (siehe unten).

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 ↑ ⁵⁹ 64 + 3 ersehen , was deutlich größer ist als g1 = 3 ↑ ⁴ 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 ):

• g _n = 3 ↑ ^{g _n-1} 3
• a _n ~ = 2 ↑ ^{a _n-1} (a _n-1 )

Wenn diese ungefähr äquivalent sind, dann ist a ₂₀ (1) ~ = g ₁₈ . Der Endterm in a _n (a _n-1 ) ist weit größer als 3, daher ist er möglicherweise höher als g ₁₈ . Ich werde sehen, ob ich herausfinden kann, ob das auch nur eine einzige Iteration beschleunigen und zurückmelden würde.

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:

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

Versammlung:

ORG 0x100

SECTION .TEXT
            mov bh, [b_ss]
            mov dx, ss
            mov [b_ss], dx
            mov [b_sp], sp
            mov ss, bx
            xor sp, sp
            mov bx, inthackdst
            inc bx
            mov ah, [inthacksrc]
            mov [bx], ah
            mov al, [nine]
            xor ah, ah
            inc ah
            inc ah
            inc ah
inthacksrc: adc ah, ah
            inc ah
            add ah, ah
            xor cx, cx
fillstack:  push cx
nine:       cmp sp, cx
            jnz fillstack
regloop:    xor dx, dx
dxloop:     xor cx, cx
cxloop:     xor bx, bx
inthackdst: int '?'
            inc cx
            jnz cxloop
            inc dx
            jnz dxloop
            pop cx
            inc cx
            jnz restack
popmore:    cmp sp, dx
            jz end
            pop cx
            inc cx
            jz popmore
restack:    push cx
            xor cx, cx
            cmp sp, dx
            jnz restack
            jmp regloop
end:        mov sp, [b_sp]
            mov ax, [b_ss]
            mov ss, ax
            ret

b_ss:       dw 'SX'
b_sp:       db 'X'

C

Die Dateigröße beträgt 45 Bytes.

Das Programm ist:

main(){long d='~~~~~~~~';while(--d)printf("%ld",d);}

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.

GNU Bash, 10 ^ 40964096² / 80 ^ 3 ≈ 10 ↑↑ 2.072820169

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C count=$C$C|tr \\$((C-C)) $SHLVL'

C = 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

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C$C$C$C count=$C$C$C$C$C|tr \\$((C-C)) $SHLVL'

C, 10 ^ 10 ^ 2485766 ≈ 10 ↑↑ 3.805871804

unsigned a['~'<<'\v'],l='~'<<'\v',i,z;main(){while(*a<~z)for(i=l;printf("%u",~z),i--&&!++a[i];);}

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^8257536Zeiten und drucken jedes Mal 10 Ziffern.

Hier ist ein Beispielcode, der das Prinzip in einem begrenzten Datenbereich zeigt:

#include <stdio.h>
unsigned int a[3],l=3,i,f;

int
main(int argc, char *argc){
        while (*a<4) {
        for (i = l; i-- && (a[i] = (a[i] + 1) % 5) == 0;);
            for (f = 0; f < l; f++)
                printf("%lu ", a[f]);
            printf("\n");
        }
}

Das Ergebnis ist ungefähr 10 ^ 10 ^ 2485766 geteilt durch eine Million, was immer noch ungefähr 10 ^ 10 ^ 2485766 entspricht.

Powershell (2.53e107976 / 72³ = 6.78e107970 ≈ 10 ↑↑ 1.701853371)

Dies dauert weit mehr als 5 Sekunden.

-join(-split(gci \ -r -EA:SilentlyContinue|select Length))-replace"[^\d]"

Es ruft die Bytelänge jeder Datei auf Ihrem aktuellen Laufwerk ab und verkettet sie. Regex entfernt alle nichtstelligen Zeichen.

Python 3, score = ack (126, 126) / 100 ^ 3

g=len('"');i=ord('~');f=lambda m,n:(f(m-g,f(m,n-g))if n else f(m-g,g))if m else n+g
print(f(i,i))

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.

JavaScript 98 Zeichen

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(m.E<<k<<k<<k<<m.E);i+=j)a+=k;alert(a)

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:

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(k<<k<<k<<k<<k<<k<<k);i+=j)a+=k;alert(a)

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)

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<k;i+=j)a+=k;alert(a)

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

Python 3: 98 Zeichen, ≈ 10 ↑↑ 256

Verwenden einer Variablenargumentfunktion:

E=lambda n,*C:E(*([~-n][:n]+[int("%d%d"%(k,k))for k in C]))if C else n;print(E(*range(ord('~'))))

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:

E(1,1) = 1111
E(0,1,1) = E(11,11) = (approx) 10^8191
E(1,1,1) = E(1111,1111) = (approx) 10^(10^335)
E(2,1,1) = E(11111111,11111111) = (approx) 10^(10^3344779)

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:

E(0,1,2,3,4,5, ... ,121,122,123,124,125)

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)

E(2**27211,2**27211,2**27212,2**27212,2**27212,2**27212,2**27213,2**27213,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636)

Ergebnisschätzung:

Wenn wir uns dem zunehmenden Schritt annähern lambda k: 10 * k**2, kann die Funktion als beschrieben werden

E(n, C₁, C₂, ... Cᵥ) ≈ E(10^(n²/2) ⋅ C₁²ⁿ, 10^(n²/2) ⋅ C₂²ⁿ, ... 10^(n²/2) ⋅ Cᵥ²ⁿ)
                     ≈ E(10^((10^(n²/2) ⋅ C₁²ⁿ)²/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )
                     ≈ E(10^((10^n² ⋅ C₁⁴ⁿ)/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )

Die 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**2wie die andere Schätzung.

E(0, b) = 10 * b**2
E(1, b) = 10 * (10 * b**2)**2 = 10 * 100 * b**4 = 10**3 * b**4
E(2, b) = 10 * (10**3 * b**4)**2 = 10 * (10**6 * b**8) = 10**7 * b**8
E(a, b) = 10**(2**(a+1)-1) * b**(2**(a+1))

Nach der vorherigen Schätzung wäre es:

E(a, b) = 10**(a**2/a) * b**(2*a)

Welches ist deutlich kleiner als der tatsächliche Wert, da es a**2anstelle 2**afür die 10 und a*2anstelle 2**afür die b verwendet.

C (Punktzahl ≈ 10 ^ 20 000 000 000 ≈ 10 ↑↑ 3,005558275)

• ~ 20 GB Ausgang
• 41 Zeichen (41 ^ 3 bedeutet nichts)

main(){for(;rand();printf("%d",rand()));}

Trotz rand()der Ausgabe ist deterministisch, da es keine Seed-Funktion gibt.