Größte druckbare Anzahl


113

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 26 ) / 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 20 (1) / 99 3 [1]
  9. Fraxtil , dc, ≈ 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15/100 3 [3]
  10. Magenta , Python, ≈ ack (126, 126) / 100 3 ≈ 10 ↑ 124 129
  11. Kendall Frey , ECMAScript 6, ≈ 10 3 ↑ 4 3 /100 3 [1]
  12. Ilmari Karonen , GolfScript, ≈ 10 ↑ 3 10 377 /18 3 [1]
  13. BlackCap , Haskell, ≈ 10 ↑↑ 65503/100 3
  14. rekursiv , Python, ≈ 2 ↑↑ 11/95 3 ≈ 10 ↑↑ 8.63297 [1] [3]
  15. nm , Haskell, ≈ 2 ↑↑ 7/100 3 ≈ 10 ↑↑ 4,63297 [1]
  16. David Yaw , C, ≈ 10 10 4 × 10 22 /83 3 ≈ 10 ↑↑ 4,11821 [2]
  17. PRIMO , Perl, 10 ≈ (12750684161!) 5 × 2 27 /100 3 ≈ 10 ↑↑ 4,11369
  18. Art , C, ≈ 10 10 2 × 10 6 /98 3 ≈ 10 ↑↑ 3,80587
  19. Robert Sørlie , x86, ≈ 10 2 2 19 +32 / 100 3 ≈ 10 ↑↑ 3.71585
  20. Tobia , APL, ≈ 10 10 353 /100 3 ≈ 10 ↑↑ 3,40616
  21. Darren Stone , C, 10 10 97.61735 / 98 3 ≈ 10 ↑↑ 3.29875
  22. ecksemmess , C, ≈ 10 2 320 /100 3 ≈ 10 ↑↑ 3,29749
  23. Adam Speight , vb.net, ≈ 10 5000 × (2 64 ) 4 /100 3 ≈ 10 ↑↑ 3,28039
  24. Joshua , bash, ≈ 10 10 15 /86 3 ≈ 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))


16
Hat jemand schon explizit "base 10" gesagt?
Keshlam

1
Zählt die große Zahl, wenn es heißt 12e10(12 * 10 ^ 10) als 12*10^10?
Hichris123

4
Ich denke , eine bessere Einschränkung statt verbieten *, / und ^, habe gewesen zu erlauben nur lineare Operationen, zB +, -, ++, -, + =, - =, usw. Ansonsten Coder Vorteil nehmen von Knuths Pfeil nach oben / Ackermann-Bibliothek funktioniert, wenn sie in der Sprache ihrer Wahl zur Verfügung gestellt wird, was wie Betrug aussieht.
Andrew Cheong

14
Ich warte immer noch darauf, dass jemand eine Fußnote verdient [4].
Brian Minton

1
Angenommen, wenn mein Programm gedruckt wird 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 als 50r7zählen 507?
Simply Beautiful Art

Antworten:


20

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


Wenn ich mich nicht irre, kann die Zahl, die Ihr Programm berechnet (nennen Sie es n), wie folgt geschrieben werden: n = f ^ 9 (g (3)), wobei f (x) = g ^ (4x) (x) und g ( x) ist die Lebensdauer des Wurms [x]. Wenn wir annehmen, dass g in der schnell wachsenden Hierarchie ungefähr gleich f_eps_0 ist, dann zeigen meine "Back-of-Envelope" -Berechnungen, dass f_ (eps_0 + 2) (9) <n <f_ (eps_0 + 2) (10) ). Natürlich ist es der aktuelle Gewinner - bei weitem.
Res

@res, ich denke das unterschätzt es ziemlich. .{foo}*Karten xzu foo^x (x). Wenn wir nehmen h_0 (x) = g^4 (x)und h_{i+1} (x) = h_i^x (x)dann ist der berechnete Wert h_9 (g(3)). Ihr f(x) = g^(4x) (x) = h_0^x (x) = h_1 (x).
Peter Taylor

(Dies bezieht sich auf Ihr ursprüngliches Programm - ich habe gerade gesehen, dass Sie einige Änderungen vorgenommen haben.) Ohhh ... Ich habe falsch verstanden, wie das *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).
Res

@res, also j_i ~ f_{eps_0 + i}; Mach das k_i ~ f_{eps_0 + i omega + i^2}?
Peter Taylor

Angesichts dessen, was Sie geschrieben haben, verstehe ich 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 dann k_i >> f_{ε_0 + ω}^i (i) = f_{ε_0 + ω + 1} (i).
Res

91

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.


19
Reines Genie!
WallyWest

7
Ich denke, Sie sollten die Lösungslänge, in der ich ungefähr 321 erhalte, als Punktzahl Your printed number will be divided for the number of bytes you used for your solution^3.
würfeln

1
77 Upvotes, und doch ... Ich stelle fest, dass die Punktzahl 321 ist ...
Simply Beautiful Art

3
@SimplyBeautifulArt, es ist nicht die Partitur, sondern die Reise. :-D
Hand-E-Food

4
Anscheinend eine, die manch einen zum Lachen brachte. Wenn wir das nur in die Bestenliste aufnehmen könnten ... jemand muss sich den "irreparablen Schaden" verdienen;)
Simply Beautiful Art

87

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


9
"...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.
Kevin Fegan

12
@ KevinFegan: Das ist wahr - die Zahl ist unglaublich repetitiv, es wäre also einfach zu komprimieren. Aber dann speichern wir nicht mehr die Zahl selbst, sondern eine abstrakte Formel, aus der die Zahl theoretisch berechnet werden kann. In der Tat ist eine der kompaktesten Formeln dieser Art wahrscheinlich das obige GolfScript-Programm, das sie erzeugt. Wenn wir einen Schritt weiter zum nächsten Programm gehen, wird es unmöglich, die Ziffern einzeln zu "drucken", bevor sie verworfen werden. Es gibt einfach keinen bekannten Weg, um so viele Schritte der klassischen Berechnung im Universum durchzuführen.
Ilmari Karonen

@ IlmariKaronens GolfScript gab dem Googol gerade einen Wedgie!
WallyWest

5
Wie wäre es, wenn Sie das wirklich bis zum Äußersten treiben, um zu sehen, wie groß genau Sie es in GolfScript innerhalb von 100 Zeichen schaffen können? So wie es aussieht, ist Ihr Ergebnis geringer als die Zahl von Graham (die meine Haskell-Lösung "annähert"), aber wie Sie sagen, kann GolfScript wahrscheinlich noch weiter gehen.
hörte am

3
@leftaroundabout: Ich habe es geschafft, einen Conway-Bewerter für die Pfeilnotation in 80 Zeichen GolfScript zu schreiben, obwohl er nicht alle Anforderungen dieser Herausforderung erfüllt (er verwendet numerische Konstanten und arithmetische Operatoren). Es könnte wahrscheinlich verbessert werden, aber ich dachte, ich könnte das als eine neue Herausforderung darstellen.
Ilmari Karonen

42

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


9
Keine Regeln verbogen:;) * Kann nicht verwendet werden 0123456789 [check] * Verwenden Sie eine beliebige Sprache, in der Ziffern gültige Zeichen sind; [check] * Sie können mathematic / physic / etc verwenden. Konstanten <10. [check, used 2] * Rekursion ist erlaubt, aber die generierte Zahl muss endlich sein; [check, no recursion] *, /, ^ kann nicht verwendet werden; [check] Ihr Programm kann mehr als eine Nummer ausgeben; [check] Sie können Strings verketten; [check] Dein Code wird so wie er ist ausgeführt. [check] Maximale Codelänge: 100 Bytes; [check]
Muss mit

Rasiere 2 Charaktere ab, indem "."/\./g
du

1
@gengkev Leider werden bei Verwendung von .replace (".", "") nur die ersten entfernt. Charakter; Ich muss das globale Ersetzen verwenden, um ALLES zu ersetzen. Zeichen aus der Zeichenfolge ...
WallyWest

Sie können dies 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 + 28
AMK

1
@Cory Zum einen werde ich eine Konstante nicht wiederholen, sonst würde jeder sie verwenden ... Zweitens habe ich wirklich kein zweites Argument ...
WallyWest

28

C, Score = 10 10 97,61735 / 98 3 ≈ 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 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 = 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 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.


2
In C 'z'ist der konstante Wert 122. Richtig?
Primo

1
Ich denke, 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 Bit
phuclv

3
Es sollte keine Rolle spielen . Ein vorzeichenbehafteter Ganzzahlüberlauf ist in C ein undefiniertes Verhalten, daher ist es unmöglich vorherzusagen, was passieren wird, wenn Ihr Code ausgeführt wird. Dies könnte die Endlichkeitsanforderung verletzen.
Dennis

1
Ich denke, dass die Analyse ein bisschen abweicht. Die Verkettung von 0..2^64-1ist genau 357823770363079921190 Ziffern lang. Wiederholte (2^64-1)^4Zeiten sind 4.1433x10 ^ 97. Nehmen wir 10 zu dieser Potenz ist power 10^10^97.6173510 ↑↑ 3.29875. Ich denke, Sie behaupten eine Zehnerpotenz, die Sie nicht haben (beachten Sie, wo 3.866×10^97wurde 3.866^10^97.
Primo

2
Hallo @primo. Vielen Dank, dass Sie sich die Zeit genommen haben, dies zu überprüfen. Bin dankbar. Ich verstehe, was du sagst. Mein letzter Exponent ist falsch. Es sollte 2.0statt 97. 10^10^10^2.00= 10^10^97.6. Ich werde das jetzt in meiner Partitur widerspiegeln.
Darren Stone

19

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.


4
Sieht großartig aus; anscheinend ist dein "modifizierter Ackermann" genau ein Conway-Kettenbewerter .
hörte am

1
@leftaroundabout Nicht ganz, aber ich denke, dass es ungefähr die gleiche rekursive Stärke hat. Außerdem: Nullen sind in Ketten nicht gültig. Daher möchten Sie die Null aus Ihrer Conway-Kette in der Punkteliste löschen.
Cel Skeggs

1
Warum hast du getan range(ord('~'))? Hätten Sie nicht range(125)weniger Bytes benötigen können, um eine höhere Anzahl von Bytes einzupressen range(A(9,9,9))?
Esolanging Fruit

1
@ Challenger5: Regel 1 lautet "Sie können keine Ziffern in Ihrem Code verwenden (0123456789)"
Cel Skeggs

@ CelSkeggs: Oh, das habe ich vergessen.
Esolanging Fruit

18

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


1
Dies ist also nur eine gültige Lösung, solange die Versionsnummer niedriger als 10 bleibt.
Herr Lister

3
@ MrLister Ja. Zum Glück keine größere Version höher als 6 vorhanden ist , und auch das ist nicht zu voll ‚bereit‘ betrachtet, obwohl ursprünglich im Jahr 2000 angekündigt worden
primo

@primo Dir ist klar, dass du diese Antwort überarbeiten musst, sobald Perl eine Versionsnummer> 10 hat, oder? ;)
WallyWest

3
@ Eliseod'Annunzio Wenn ich an diesem Tag noch am Leben bin - wenn überhaupt - verspreche ich, dass ich zurückkomme und das Problem behebe.
Primo

2
Eine laufende Lösung, die 10 ↑↑ 4 übertrifft. Das ist beeindruckend. Bravo!
Tobia

16

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

        Bildbeschreibung hier eingeben

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

        Bildbeschreibung hier eingeben

was sich, wenn wir 9 ≈ 10 nehmen, noch weiter auf reduziert

        Bildbeschreibung hier eingeben

und schließlich, indem wir Terme erweitern und sie durch Verringern der Größenordnung ordnen, erhalten wir

        Bildbeschreibung hier eingeben

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 -

        Bildbeschreibung hier eingeben

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)

        Bildbeschreibung hier eingeben

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

  1. 10 16
  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}

Meine Berechnung Ihrer Punktzahl basiert auf der Beobachtung, dass fdie Zahl zin etwa aus eigener Kraft gewonnen wird. Das ist so etwas wie ↑↑↑. Natürlich ist die Punktzahl nicht so 2↑↑↑2 , wie 2↑↑↑5+1es scheint. Würden Sie zustimmen, sollte ich das in die Rangliste aufnehmen?
hörte am

@leftaroundabout - Vielen Dank, dass Sie sich das noch einmal angesehen haben. Ich fühle mich mit der Aufwärtspfeilnotation nicht wohl genug, um zu sagen, ob Ihr Vorschlag richtig klingt oder nicht, aber ich habe die Größenordnung meiner Punktzahl berechnet (siehe Bearbeiten), wenn Sie die Bestenliste damit aktualisieren möchten.
Andrew Cheong

Ausgezeichnet! Ich bin auch mit Aufwärtspfeilen überhaupt nicht fest. Sie haben also "nur" einen Turm der Macht; Ich befürchte, dass Sie zwei Plätze tiefer in der Rangliste liegen. Ein großes Lob für die richtige Analyse des Ergebnisses; Meine Schätzungen weisen wahrscheinlich noch weitere Mängel auf, aber ich hatte das Gefühl, dass zumindest jemand versuchen sollte, die Antworten in Ordnung zu bringen.
hörte am

1
Ihre Punktzahl ist falsch. Wenn Sie eine Schleife mit starten, führen i=o.z;while(i--)...Sie die Schleifenzeiten nicht aus o.z, da eine Schleife auf einer Ganzzahlvariablen basiert und o.zabhä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, sondern ibeginnt jedes Mal mit dem größten darstellbaren ganzzahligen Wert, z. B. 2 ^ 63, und nicht mit dem aktuellen Wert von o.z.
Tobia

2
@ acheong87 Entferne dich nicht, du musst nur deine Punktzahl neu berechnen und die Schleifenvariablen auf 2 ^ 63 oder so begrenzen. PS: Lassen Sie Ihre analytische Bewertung hier, es ist sehr lehrreich!
Tobia

14

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 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←⍎⎕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 3 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.


Ihre gedruckte Nummer wird durch die Anzahl der Bytes geteilt, die Sie für Ihre Lösung verwendet haben ^ 3. , Sie teilen sich gerade durch 100.
ToastyMallows

2
@ ToastyMallows - sieht aus wie 100 cubed(100 ^ 3) für mich.
Kevin Fegan

1
Ich weiß, aber es sind Bytes, keine Zeichen.
ToastyMallows

1
@ ToastyMallows Lesen Sie die Endnoten zur Antwort.
Einfach schöne Kunst

Wechsel {⍞←⎕D}zu ⍞←denen spart drei Bytes , die Sie eine weitere hinzufügen können ⍣nund machen ⊢n←⍎⎕Din ⌽⍕n←⍎⎕Dfür eine 80-fache Steigerung. Wenn Sie das Laufen mit erlauben, ⎕PP←17verwenden Sie ×⍨stattdessen ⌽⍕fast die doppelte Anzahl der gedruckten Stellen.
Adám

12

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


o=length[]!qAm Ende bekommst du ein Extra und sparst dir ein Byte dazu.
Khuldraeseth na'Barya

9

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.


Ihr Code läuft nicht. Nur print True<<(True<<(True<<(True<<True<<True))), und das gibt eine 19k-Zeichenfolge aus.
Gabe

Was sind die Mindestsystemanforderungen?
Danubian Sailor

8
Könnten Sie es nicht kürzer machen, indem Sie definieren t=Trueund danach verwenden t?
Bob

1
Besser noch, machen Sie einfach eine Schleife, die diese Verschachtelungen für Sie erledigt.
Simply Beautiful Art

Dies scheitert für mich:$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
Brian Minton

8

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


7

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.


3
Dies hängt vom Zahlengenerator ab, der in den meisten Sprachen wahrscheinlich nicht das 97-fache der gleichen Zahl erzeugen kann
Ratschenfreak

1
Das ist ein guter Punkt. Ich gehe also nicht nur davon aus, dass die Rechenleistung stetig schneller zunimmt, sondern ich muss auch von einer perfekten Zufallsquelle und einer Ruby-Implementierung ausgehen, die sie verwendet.
Histokrat

7

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


'',:o;'oo',:t;weist nur die Werte 0zu ound 2zu t; 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öschen tin erster Linie , weil man schreiben kann , expr:t;{...}:f;[[[t]f]f]fwie [[[expr:t]{...}:f~]f]fSpeicher weitere 3 Zeichen.
Peter Taylor

Immer noch kein Grund zum Knallen o: Ich bin mir ziemlich sicher, [0 126]fdass einer größer sein wird, als [126]fSie 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'~'=]
Peter Taylor,

Oh, und die [sind unnötig, da Sie nichts anderes auf dem Stapel haben.
Peter Taylor

Ha ... diese Antworten scrollen, und dann sehe ich das ... und dann bemerke ich die akzeptierte Antwort ... hm ......
Simply Beautiful Art

@SimplyBeautifulArt Ich bin nicht sicher, was Sie meinen, aber die akzeptierte Antwort berechnet eine sehr viel größere Zahl als diese (vorausgesetzt, beide sind wie behauptet).
Res

7

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.


Ich habe keine Ahnung, was dieser Code macht ... kann nur davon ausgehen, dass er korrekt ist. Vielleicht könnten Sie ein wenig erklären?
aufgehört, sich am

Ich werde den Code Stück für Stück erklären, wenn ich später am Abend Zeit habe.
Bis zum

Nun, ich habe mich auf diese Erklärung geeinigt, aber ich habe sie jetzt hinzugefügt. Hoffe, es klärt die Dinge auf.
Bis zum

dc-1.06.95-2 wird sofort beendet, nachdem nichts gedruckt wurde.
Primo

1
Ich würde nicht erwarten, dass es auf einer vorhandenen Maschine funktioniert, wenn man bedenkt, wie groß der Wert ist, den es zu generieren versucht. Ich habe die gleiche Version von DC und es segfaults nach ein paar Sekunden. Ich gehe davon aus, dass hier "theoretisch korrekte" Antworten zulässig sind, da es keine Kriterien für den Ressourcenverbrauch gibt.
Bis zum

6

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

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


Vielleicht. %udruckte 32-Bit-Zahlen sogar mit einer 64-Bit-Kompilierung, so dass ich es mir zur llGewohnheit machte, in einem 32-Bit-Compiler zu schreiben.
David Yaw

Ich denke %lluwäre für long longund %luwäre richtig für long.
Tomlogic

Fest. Force of Habit: %uist immer 32-Bit, %lluist immer 64-Bit, ob als 32 oder 64-Bit kompiliert. Für die Lösung hier ist jedoch longeine 64-Bit-Version erforderlich. Sie haben also Recht, dies %luist ausreichend.
David Yaw

Es ist nicht garantiert, dass Ihre Variablen auf dem Stapel auf 0 initialisiert werden. Setzen Sie sie im zweiten Programm einfach außerhalb einer Funktion. In der ersten müssen Sie initialisieren i.
Kunst

Außerdem ist ein langer Überlauf ein undefiniertes Verhalten, und viele moderne Compiler optimieren ihn nur, wenn sie ihn erkennen. Sie möchten wahrscheinlich lange ohne Vorzeichen verwenden.
Kunst

5

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

2
Ich glaube nicht, dass Sie die Nummer in die Post aufnehmen müssen. Auch auf dem Handy nimmt es viel Platz ein.
totalhuman

@totallyhuman Ich stimme zu, vielleicht die ersten 100 Ziffern, max
tuskiomi

@totallyhuman ok danke getan :)
lebatsnok

catist insofern eine seltsame Funktion, als das erste Argument ist .... Also geht alles vor dem ersten genannten Argument auf ...(und wird catsepcat(abs(.Random.seed),,"")
bearbeitet

5

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 ↑ 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".


Maximum code length is 100 bytes;Ansonsten ist dies nahezu unschlagbar
Cruncher

@ Cruncher Aaah, das habe ich verpasst
Kendall Frey

Ahh, ich hasse dich jetzt. Jedes Mal, wenn ich versuche, die Größe von Grahams Nummer zu ergründen, tut mir der Kopf weh.
Cruncher

Zählt Grahams Zahl nicht auch als Konstante> 10?
Serakfalcon

1
Jetzt soll festgestellt werden, ob meine die von Ilmari schlägt.
Kendall Frey

5

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.


1
#DEFINE C while (- langes n, o, p, q, r, s, t; Haupt () {Cn) {Co) {Cp) {Cq) {Cr {Cs {Ct) {Putchar ('z' -'A ');}}}}}}}
RobAu

@RobAu Du bist ein Genie! Mach daraus eine Antwort. Ich bin sicher, es wäre der Gewinner. Ich denke, Sie haben ein paar vergessen ), aber das ist in Ordnung, weil Sie im Moment nur 96 Zeichen haben.
Andrew Larsson

Für alle , die bekommen den Sarkasmus nicht: siehe codegolf.stackexchange.com/a/18060/7021 für eine noch bessere Lösung;)
Robau

5

New Ruby: score ~ ​​f ω ω2 +1 (126 2 2 126 )

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 2 126 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.



Es sind tatsächlich 103 Bytes, Sie hatten eine nachgestellte Newline, glaube ich.
13.

@Riker Ich glaube du hast von hier kopiert und eingefügt. Beachten Sie, dass in der zweiten Zeile ein nicht druckbares Zeichen stehen sollte, also 104 Byte.
Simply Beautiful Art

@SimplyBeautifulArt ah, okay. Ich dachte, ich hätte den Charakter kopiert. Es tut uns leid.
13.

@Riker Nah, es ist nicht mal da, weil ich durch Stackexchange nicht überall unsichtbare Charaktere verstecken kann.
Simply Beautiful Art

4

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 2 (61) oder eine 4 (1) ---
  • a 3 (61)
  • ...
  • a 18 (61) oder a 20 (1). Ich denke, das ist ungefähr g 18 (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 ↑ 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 ):

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


Ihre Analyse ist korrekt und g <sub> 18 </ sub> ist eine gute Annäherung.
Simply Beautiful Art

length"a"Speichert ein paar Bytes und ermöglicht Ihnen einen anderen.a
Khuldraeseth na'Barya

4

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'

Offensichtlich hast du das nie gemacht. Es überschreibt seinen Code und stürzt ab.
Joshua

4

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.


4

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'

SHLVL ist die Ebene der Bash als Subbash:bash -c 'bash -c "echo \$SHLVL"'
F. Hauri

stat --printfarbeite nicht Versuchen Siestat -c %s
F. Hauri

@ F.Hauri: --printf funktioniert bei mir aber auch -c so, dass sich ein paar Bytes rasiert haben. Vielen Dank.
Joshua

4

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.


Mit Abstand die beste C-Implementierung. Warum 5 Variablen verwenden, wenn Sie ein Array von 258048 verwenden können ?
Primo

4

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.


Regel 1 besagt, dass keine Ziffern zulässig sind 0.
Kyle Kanos

Verdammt, ich auch. Da geht meine Charakterzählung.
Hand-E-Food

Sie können verwenden -ea(+''), um die Größe zu reduzieren ('' konvertiert in eine Zahl 0, die der Enum-Wert von ist SilentlyContinue). Sie können \Dfür den Ersatz Regex verwenden, der der gleiche ist wie [^\d]. Und Sie können einfach verwenden, %{$_.Length}anstatt select Lengthdie Spaltenüberschriften loszuwerden. Und dann können Sie das -splitund -replaceauch 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 +'').
Joey

4

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.


Sie können Ihre Zahl durch Ändern erhöhen f(m-g,g)zu f(m-g,m).
Einfach schöne Kunst

oder f(m-g,i). Außerdem verwenden Sie am Ende der ersten Zeile eine Zahl. Ich glaube, Sie wollten verwenden n+g, worauf ich hinweisen werde, n+nwird größer sein.
Einfach schöne Kunst

Sie können ein paar Bytes sparen, indem Sie len ('"') für True
Brian Minton

Verwenden Sie ord ('^?') (Wobei ^? Das DEL-Zeichen ist, ASCII 127) für eine größere Zahl. BEARBEITEN macht nichts, das ist nicht "Druckbar".
Brian Minton

@BrianMinton Wer sagt, dass es druckbar sein muss?
Simply Beautiful Art

4

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


3

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.


Ich habe Ihr Ergebnis geschätzt, zögern Sie nicht.
hat am

Ich muss mit diesem Ergebnis nicht einverstanden sein. Einen Moment, während ich meine Überlegungen abtippe.
Cel Skeggs

Na, bitte. Wie ich in dem Update sagte, scheint Ihre Schätzung bedeutend kleiner als der tatsächliche Wert zu sein.
Cel Skeggs

Fair genug, aber auf jeden Fall brauchen wir eine rekursiv-induktive / sofortige Schätzung, nicht nur einen einzigen Schritt, um diese Antwort in die Bewertungsliste aufzunehmen. Ich bin mir sicher, dass Ihre Punktzahl besser ist als die von rekursiv , aber auch ziemlich sicher nicht besser als die von Ilmari Karonen (die ohnehin sehr erweiterbar ist und derzeit nur 18 Zeichen enthält) Scoring-Zweck.
hörte am

Genau. Ich werde sehen, ob ich mehr daran arbeiten und zumindest eine genauere Untergrenze für das Ergebnis finden kann.
Cel Skeggs

3

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.


Wenn Sie Pech haben, stoppt Ihr Programm nach einer Iteration und der Aufruf rand()als Abbruchbedingung macht es nicht deterministisch. Darüber hinaus sollte das Aufrufen rand()jeder Iteration es schrecklich langsam machen. Verwenden Sie stattdessen etwas wie in LONG_MAXdefiniert limits.h.
klingt.net

Ok, ich nehme den non deterministicRücken, weil es keinen Samen gibt, wie du geschrieben hast.
klingt.net

1
Wie wäre es ~' 'statt mit rand()gedruckt %u? Zwei Bytes weniger Quelle und ein höherer Wert.
MSalters
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.