Ihr Ziel ist es, mit nur zehn Zeichen Code die größtmögliche Anzahl (auf die Standardausgabe) zu drucken.

• Sie können alle Funktionen Ihrer Sprache außer den integrierten Exponentiationsfunktionen verwenden.
  • Ebenso können Sie keine wissenschaftliche Notation verwenden, um eine Zahl einzugeben. (Also nein 9e+99.)
• Das Programm muss die Nummer ohne Benutzereingabe ausdrucken. Ebenso kein Lesen aus anderen Dateien oder aus dem Web und so weiter.
• Ihr Programm muss eine einzelne Zahl berechnen und ausdrucken. Sie können weder eine Zeichenfolge drucken, noch können Sie die gleiche Ziffer tausende Male drucken.
• Sie können jeden Code, der zum Drucken eines Objekts erforderlich ist, von der Beschränkung auf 10 Zeichen ausschließen. In Python 2, das die print xSyntax verwendet, können Sie beispielsweise bis zu 16 Zeichen für Ihr Programm verwenden.
• Das Programm muss in der Ausgabe tatsächlich erfolgreich sein. Wenn die Ausführung auf dem schnellsten Computer der Welt länger als eine Stunde dauert, ist sie ungültig.
• Die Ausgabe kann in jedem Format gesendet werden (so können Sie drucken 999, 5e+100etc.)
• Unendlichkeit ist ein abstrakter Begriff , keine Zahl. Es ist also keine gültige Ausgabe.

Wolfram-Sprache

ack(9!,9!)

ack (9!, 9!) =

Die Ausgabe erfolgt in Pfeilnotation.

Perl,> 1,96835797883262e + 18

time*time

Könnte nicht die größte Antwort sein ... heute! Aber warte genug Jahrtausende und es wird sein!

Um auf einige der Kommentare mit "genug Jahrtausende" einzugehen, meine ich in der Tat n ^Hunderte von Jahren.

Um fair zu sein, wenn der große Frost / Hitzetod des Universums das Ende des Universums ist (geschätzte Dauer: ~ 10 ¹⁰⁰ Jahre), würde der "endgültige" Wert ~ 10 ^{214 betragen} , was mit Sicherheit viel weniger ist als bei einigen anderen andere Antworten (obwohl "zufällige Quantenfluktuationen oder Quantentunneln einen weiteren Urknall in 10 ^{10 56} Jahren hervorrufen können "). Wenn wir optimistischer vorgehen (z. B. ein zyklisches oder ein Multiversum-Modell), wird die Zeit unendlich lang, und daher würde die Antwort eines Tages in einem Universum auf einer High-Bit-Architektur einige der anderen übertreffen.

Andererseits ist, wie bereits erwähnt, timetatsächlich die Größe von Integer / Long begrenzt, so dass in der Realität so etwas wie ~0immer eine größere Anzahl als time(dh die timevon der Architektur unterstützte maximale Anzahl ) produzieren würde.

Dies war nicht die ernsthafteste Antwort, aber ich hoffe es hat euch gefallen!

Wolfram ≅ 2,003529930 × 10 ¹⁹⁷²⁸

Ja, es ist eine Sprache! Es steuert das Back-End der beliebten Wolfram Alpha-Site. Es ist die einzige Sprache, die ich gefunden habe, in der die Ackermann-Funktion integriert und auf weniger als 6 Zeichen abgekürzt ist.

In acht Zeichen:

$ ack(4,2)

200352993...719156733

Oder 2,003529930 × 10 ¹⁹⁷²⁸

ack(4,3), ack(5,2)Usw. sind viel größer, aber zu groß. ack(4,2)ist wahrscheinlich die größte Ackermann-Zahl, die in weniger als einer Stunde vollständig berechnet werden kann.

Größere Zahlen werden symbolisch dargestellt, zB:

$ ack(4,3)

2↑²6 - 3 // using Knuth's up-arrow notation

Die Regeln besagen, dass jedes Ausgabeformat zulässig ist, dies kann also gültig sein. Dies ist größer als 10 ^{10 19727} , was mit Ausnahme der wiederholten Fakultät größer als alle anderen Einträge hier ist.

Jedoch,

$ ack(9,9)

2↑⁷12 - 3

ist größer als die wiederholte Fakultät. Die größte Zahl, die ich in zehn Zeichen bekommen kann, ist:

$ ack(99,99)

2↑⁹⁷102 - 3

Das ist wahnsinnig groß. Das Universum ist nicht groß genug, um einen signifikanten Teil seiner Ziffern darzustellen, selbst wenn Sie die Zahl wiederholt protokolliert haben.

Python2-Shell mit 3.010.301 Ziffern

9<<9999999

Berechnung der Länge: Python fügt diesen langen Zahlen ein "L" hinzu, sodass 1 Zeichen mehr als das Ergebnis Ziffern enthält.

>>> len(repr( 9<<9999999 ))
3010302

Erste und letzte 20 Ziffern:

40724177878623601356... ...96980669011241992192

CJam, 2 × 10 ^268,435,457

A28{_*}*K*

Dies berechnet b , wie folgt definiert:

• a ₀ = 10

• a _n = a _{n - 1} ²

• b = 20 × a ₂₈

$ time cjam <(echo 'A28{_*}*K*') | wc -c
Real    2573.28
User    2638.07
Sys     9.46
268435458

Hintergrund

Dies folgt der gleichen Idee wie Claudius Antwort , aber es basiert nicht darauf. Ich hatte eine ähnliche Idee, die ich nur wenige Minuten nachdem er seine veröffentlicht hatte , veröffentlicht hatte , aber ich habe sie verworfen, da sie nicht annähernd zeitlich begrenzt war.

Der Vorschlag von Aditsu , auf Java 8 zu aktualisieren, und meine Idee , Potenzen von 10 zu verwenden, ermöglichten es CJam, Zahlen zu berechnen, die außerhalb der Reichweite von GolfScript liegen. Dies scheint auf einige Fehler / Einschränkungen von Ruby's Bignum zurückzuführen zu sein.

Wie es funktioniert

A    " Push 10.                                                          ";
28{  " Do the following 28 times:                                        ";
  _* " Duplicate the integer on the stack and multiply it with its copy. ";
}*   "                                                                   ";
K*   " Multiply the result by 20.                                        ";

CJam, 8,1 × 10 ^1,826,751

KK,{)*_*}/

Dauert auf meinem Computer weniger als fünf Minuten, sodass noch Verbesserungspotenzial besteht.

Dies berechnet eine ₂₀ , die wie folgt definiert ist:

• a ₀ = 20

• a _n = (n × a _{n - 1} ) ²

Wie es funktioniert

KK,   " Push 20 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ]. ";
{     " For each integer in the array:                                 ";
  )*  " Increment it and compute the its product with the accumulator. ";
  _*  " Multiply the result with itself.                               ";
}/

Python 3, 9 * 2 ^ (7 * 2 ^ 33)> 10 ^ 18,100,795,813

9 * 2 ^ (2 ^ 35)> 10 ^ 10,343,311,894

Bearbeiten: Meine neue Antwort lautet:

9<<(7<<33)

Alte Antwort für die Nachwelt:

9<<(1<<35)

Genau zehn Zeichen.

Ich drucke die Nummer in hex und

Sie können jeden Code, der zum Drucken eines Objekts erforderlich ist, von der Beschränkung auf 10 Zeichen ausschließen. In Python 2, das die print x -Syntax verwendet, können Sie beispielsweise bis zu 16 Zeichen für Ihr Programm verwenden.

Daher lautet mein aktueller Code:

print(hex(9<<(7<<33)))

Beweisen Sie, dass es in der angegebenen Zeit ausgeführt wird und eine Nummer der angegebenen Größe generiert:

time python bignum.py > bignumoutput.py

real    10m6.606s
user    1m19.183s
sys    0m59.171s
wc -c bignumoutput.py 
15032385541 bignumoutput.py

Meine Nummer> 10 ^ (15032385538 * log (16))> 10 ^ 18100795813

3 Hexadezimalziffern weniger als der obige WC-Ausdruck wegen der Initiale 0x9.

Python 3 ist notwendig, da es in Python 2 7<<33eine lange <<dauern würde und keine langen Eingaben erfordert.

Ich kann stattdessen nicht 9 << (1 << 36) verwenden, weil:

Traceback (most recent call last):
  File "bignum.py", line 1, in <module>
    print(hex(9<<(1<<36)))
MemoryError

Dies ist also die größtmögliche Anzahl des Formulars a<<(b<<cd) auf meinem Computer gedruckt werden können.

Höchstwahrscheinlich verfügt die schnellste Maschine der Welt über mehr Speicher als ich. Meine alternative Antwort lautet daher:

9<<(9<<99)

9 * 2 ^ (9 * 2 ^ 99)> 10 ^ (1.7172038461 * 10 ^ 30)

Meine derzeitige Antwort ist jedoch die größte, die je eingereicht wurde. Sie ist also wahrscheinlich gut genug. Dies alles unter der Annahme, dass eine Bitverschiebung zulässig ist. Es scheint, aus den anderen Antworten zu sein, die es verwenden.

Jede Sprache mit ausreichend kurzen konstanten Namen, ca. 18 Stellen.

99/sin(PI)

Ich würde dies als PHP-Antwort posten, aber leider M_PImacht dies nur ein wenig zu lang! PHP liefert dafür aber 8.0839634798317E + 17. Grundsätzlich wird der Mangel an absoluter Präzision in PI: p ausgenutzt

Haskell

Ohne Tricks:

main = print -- Necessary to print anything
    $9999*9999 -- 999890001

Wohl ohne etwas zu berechnen:

main = print
    $floor$1/0 -- 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216

Anpassung von Niets Antwort :

main = print
    $99/sin pi -- 8.083963479831708e17

Powershell - 1.12947668480335E + 42

99PB*9E9PB

Multipliziert 99 Pebibyte mal 9.000.000.000 Pebibyte.

J ( ((((((((9)!)!)!)!)!)!)!)!)

Ja, das ist viel. 10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425)))))))nicht sehr genau zu sein.

!!!!!!!!9x

K / Kona : 8.977649e261 1.774896e308

*/1.6+!170

• !170 Erstellt einen Vektor mit Zahlen von 0 bis 169
• 1.6+ addiert eins zu jedem Element des Vektors und konvertiert in reelle Werte (Bereich ist 1,6 bis 170,6)
• */ multipliziert jedes Element des Arrays

Wenn Kona Quad-Präzision unterstützen würde, könnte ich */9.+!9991e2584 erreichen. Leider nicht und ich bin auf doppelte Präzision beschränkt.

alte Methode

*/9.*9+!99

• !99 Erstellt einen Vektor mit Zahlen von 0 bis 98
• 9+ fügt 9 zu jedem Element des Vektors hinzu (jetzt reicht 9 bis 107)
• 9.* multipliziert jedes Element mit 9.0 (implizit konvertiert in Real, also 81.0 bis 963.0)
• */ multipliziert jedes Element des Vektors

HTML, 9999999999

9999999999

.. geschafft.

Python - Variiert bis zu 13916486568675240 (bisher)

Nicht ganz ernst, aber ich dachte, es würde ein bisschen Spaß machen.

print id(len)*99

Von all den Dingen, die ich ausprobierte, lenbekam ich am konsequentesten große Ausweise.

Auf meinem Computer wurden 13916486568675240 (17 Stellen) und auf dieser Site 13842722750490216 (ebenfalls 17 Stellen) ausgegeben . Ich nehme an, es ist möglich, dass dies so niedrig wie 0 ist, aber es könnte auch höher gehen.

Golfscript, 1e + 33.554.432

10{.*}25*

Berechnet 10 ^ (2 ^ 25) ohne Verwendung von Exponenten 96 Sekunden:

$ time echo "10{.*}25*" | ruby golfscript.rb  > BIG10

real    1m36.733s
user    1m28.101s
sys     0m6.632s
$ wc -c BIG10
 33554434 BIG10
$ head -c 80 BIG10
10000000000000000000000000000000000000000000000000000000000000000000000000000000
$ tail -c 80 BIG10
0000000000000000000000000000000000000000000000000000000000000000000000000000000

Es kann bis zu berechnen 9 ^ (2 ^ 9999) , wenn nur genügend Zeit zur Verfügung steht, aber das Inkrementieren des inneren Exponenten um eins nimmt das ~ Dreifache der Zeit in Anspruch, sodass das 1-Stunden-Limit ziemlich bald erreicht wird.

Erklärung :

Verwenden einer früheren Version mit derselben Idee:

8{.*}25*

Brechen sie ab:

8         # push 8 to the stack
{...}25*  # run the given block 25 times

Der Stapel am Anfang jedes Blocks besteht aus einer Nummer, der aktuellen Nummer. Dies beginnt mit 8. Dann:

.         # duplicate the top of the stack, stack is now | 8 | 8 |
*         # multiply top two numbers, stack is now       | 64 |

So sieht der Stack Schritt für Schritt aus:

8
8 8
64
64 64
4096
4096 4096
16777216
16777216 16777216

... usw. Geschrieben in mathematischer Notation ist der Fortschritt:

n=0, 8                     = 8^1  = 8^(2^0)
n=1, 8*8                   = 8^2  = 8^(2^1)
n=2, (8^2)*(8^2) = (8^2)^2 = 8^4  = 8^(2^2)
n=3,               (8^4)^2 = 8^8  = 8^(2^3)
n=4,               (8^8)^2 = 8^16 = 8^(2^4)

wxMaxima ~ 3x10 ^49.948 (oder 10 ^{8.565.705.514} )

999*13511!

Ausgabe ist

269146071053904674084357808139[49888 digits]000000000000000000000000000000

Ich bin mir nicht sicher, ob es den Spezifikationen (insbesondere dem Ausgabeformat 1) entspricht, aber ich kann noch größere Treffer erzielen:

bfloat(99999999!)

Ausgabe ist

9.9046265792229937372808210723818b8565705513

Das sind ungefähr 10 ^{8.565.705.514,} was deutlich mehr ist als die meisten Top-Antworten und in ungefähr 2 Sekunden berechnet wurde. Die bfloatFunktion gibt eine beliebige Genauigkeit .

Haskell, 4950

Oh Mann, das ist nicht viel! 10 Zeichen beginnen nach dem Dollarzeichen.

main=putStr.show$sum[1..99]

Mathematica, 2.174188391646043 * 10 ^ 20686623745

$MaxNumber

Genau zehn Zeichen.

Python-Shell, 649539 999890001

Beats Haskell, keine ernsthafte Antwort.

99999*9999

Wolfram Alpha (zählt eine Website als Sprache)?

9! ! ! ! !

Ausgänge

10^(10^(10^(10^(10^(6.27...))))

Danke an Cory für den Tipp, dass Räume genauso gut funktionieren wie Parens.

Befunge-93 (1.853.020.188.851.841)

Ich bin froh, dass noch niemand Befunge gemacht hat (das ist meine Nische), aber verdammt, ich kann keinen cleveren Trick finden, um die Zahl zu erhöhen.

9:*:*:*:*.

Es ist also 9 ^ 16.

:*

Grundsätzlich multipliziert sich der Wert am oberen Rand des Stapels mit sich selbst. Der Wert oben auf dem Stapel lautet also:

9
81
6561
43046721
1853020188851841

und

.

Gibt den Endwert aus. Es würde mich interessieren, ob jemand bessere Ideen hat.

Ich würde dies lieber als Kommentar oben posten, aber anscheinend kann ich nicht, da ich ein Noob bin.

Python:

9<<(2<<29)

Ich würde mit einer größeren Bitverschiebung arbeiten, aber Python scheint zu wollen, dass der richtige Operand einer Verschiebung eine nicht lange Ganzzahl ist. Ich denke, das kommt dem theoretischen Maximum näher:

9<<(7<<27)

Das einzige Problem bei diesen ist, dass sie möglicherweise Regel 5 nicht erfüllen.

Matlab (1.7977e + 308)

Matlab speichert den Wert der größten Gleitkommazahl (doppelte Genauigkeit) in einer Variablen namens realmax. Das Aufrufen im Befehlsfenster (oder in der Befehlszeile) gibt den Wert aus:

>> realmax

ans =

  1.7977e+308

Python, ca. 1,26e1388

9<<(9<<9L)

Gibt:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577053590262761777844800736563356262737634036313038859977295626367160619139675145747597185726573351363864334560386886632464140309991451407124759291146012572595725491755156575770535902627617778448007365633562627

Mindestens Python 3.5.0 (64-Bit), mehr als 10 ^ 242944768872896860

print("{:x}".format( 9<<(7<<60) ))

In einer idealen Welt wäre das so 9<<(1<<63)-1, aber es gibt nicht genug Bytes dafür. Diese Zahl ist so groß, dass sie fast 1 EiB Speicher benötigt, was ein bisschen mehr ist, als ich auf meinem Computer habe. Zum Glück müssen Sie nur etwa 0,2% des weltweiten Speicherplatzes als Swap verwenden, um ihn zu speichern. Dem binären Wert 1001folgen 8070450532247928832 Nullen.

Wenn Python für 128-Bit-Computer 9<<(9<<99)verfügbar ist , ist dies das Maximum , das weniger als 1 MiYiB Speicher benötigt. Dies ist gut, da Sie noch genügend adressierbaren Speicherplatz haben, um den Python-Interpreter und das Betriebssystem zu speichern.

Cubix , 9.670457478596419e + 147 (nicht konkurrierend)

****"///**

Nicht konkurrierend, da Cubix neuer als diese Herausforderung ist. Sie können es hier online testen. Beachten Sie jedoch, dass die Nummer nicht gedruckt wird. Sie müssen das Programm nach den letzten beiden anhalten* Sekunden ausgeführt wurden, um den Wert auf dem Stapel zu sehen.

Wie es funktioniert

Cubix ist ein zweidimensionaler Esolang, bei dem der Code um einen Würfel gewickelt wird. Dieser Code entspricht genau dem folgenden Würfelnetz, in dem .es sich um ein No-Op handelt:

    * *
    * *
" / / / * * . .
. . . . . . . .
    . .
    . .

Dann wird der Code ausgeführt, wobei der Anweisungszeiger (IP) in der oberen linken Ecke der äußersten linken Seite beginnt und nach rechts zeigt. "Aktiviert den Zeichenkettenmodus, in dem alle Zeichen, die bis zum nächsten Mal vorkommen ", ihre Zeichencodes auf den Stapel schreiben. Die IP umschließt den Code vollständig und drückt drei /s (47), zwei* s (42) und zwei. Sekunden (46) auf den Stapel, bevor der Zeichenfolgenmodus wieder beendet wird.

Hier wird es interessant. Der erste Spiegel /reflektiert die IP und zeigt nach oben. es dreht sich dann um den Würfel und trifft diese Zeichen:

           
    * *
  /     *      
  .     .      
    . .

Die drei *s multiplizieren die beiden obersten Gegenstände auf dem Stapel. Im Gegensatz zu den meisten stapelbasierten Sprachen, in denen arithmetische Operatoren ihre Argumente einfügen, belässt Cubix die vorherigen Werte im Stapel. Das heißt also, dies berechnet 46*46 = 2116, 46*2116 = 97336, 2116*97336 = 205962976.

Wenn die IP die /wieder erreicht, wird sie nach rechts gedreht. Es trifft dann auf den nächsten Spiegel und folgt diesem Pfad:

    *  
    *  
    /         .
    .         .
    .  
    .  

Die beiden Sternchen multiplizieren die beiden obersten Elemente noch einmal. Dann leitet der Spiegel die IP wieder nach rechts und der dritte Spiegel wiederholt den Vorgang noch einmal:

      *
      *
      /     .  
      .     .  
      .
      .

Schließlich verlässt das IP den Spiegelabschnitt in Richtung Osten. Die beiden letzten Sternchen multiplizieren sich noch zweimal, sodass 9.670457478596419e + 147 auf dem Stapel verbleiben. Dies könnte mit gedruckt werden O, aber es gibt keine einfache Möglichkeit, dies zu tun, da praktisch jeder Punkt auf dem Würfel bereits verwendet wird.

Scala, 2 ⁶³ & ndash; 1

Arme, arme Scala. Benötigt mindestens 8 Zeichen, um einen BigIntWert zu erhalten, der nicht genügend Platz lässt, um ihn tatsächlich groß zu machen.

Mit nur 7 Zeichen (gezähltem) Code können wir jedoch das größtmögliche Positiv drucken Long:

print(-1L>>>1)

Brainf ** k 256 - 2147483647

>+[<+>+]<.

_{Wenn Sie die Tatsache ignorieren, dass die meisten Compiler und Interpreter Daten als ASCII-Äquivalent ausgeben (seien Sie leanient, es ist, was es ist;))} , wird der maximale Wert des Datentyps des Interpreters / Compilers zurückgegeben.

Auf einigen Systemen sind dies nur 256, auf einigen (z. B. meinem) ist dies der Maximalwert einer 32-Bit-Ganzzahl, dh 2 147 483 647.

Bearbeiten:

-.

Gibt dasselbe in viel weniger Zeichen aus

Perl, nicht konkurrierend

Ich benutze dies, um eine kleine bekannte Ecke von Perl hervorzuheben.

Perl kann hier nicht wirklich mithalten, da es keine eingebauten Bignums hat (natürlich können Sie eine Bignum-Bibliothek laden).

Aber was jeder weiß, ist nicht ganz wahr. Eine Kernfunktion kann tatsächlich mit großen Zahlen umgehen.

Das packFormat wkann tatsächlich eine beliebige natürliche Zahl zwischen Basis 10und Basis konvertieren 128. Die Ganzzahl der Basis 128 wird jedoch als Zeichenfolgenbytes dargestellt. Die Bitfolge wird xxxxxxxyyyyyyyzzzzzzzzu den Bytes: 1xxxxxxx 1yyyyyyy 0zzzzzzz(Jedes Byte beginnt mit 1, mit Ausnahme des letzten). Und Sie können eine solche Zeichenfolge mit Unpack auf Basis 10 konvertieren. So können Sie Code wie folgt schreiben:

unpack w,~A x 4**4 .A

was gibt:

17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

Sie können die 4**4Werte durch größere Werte ersetzen , bis Sie das Gefühl haben, dass dies zu lange dauert oder zu viel Speicher benötigt.

Leider ist dies viel zu lang für das Limit dieser Herausforderung, und Sie können argumentieren, dass das Ergebnis der Basis 10 in eine Zeichenfolge konvertiert wird, bevor es zum Ergebnis wird, sodass der Ausdruck nicht wirklich eine Zahl ergibt. Aber intern erledigt Perl wirklich die nötige Arithmetik, um die Eingabe in Basis 10 umzuwandeln, was ich immer für ziemlich ordentlich hielt.

TI-36 (nicht 84, 36), 10 Bytes, ca. 9.999985426E99

Ältere Rechner können ebenfalls in gewissem Umfang programmiert werden;)

69!58.4376

Dies liegt sehr nahe an der maximalen Reichweite, die ein TI-Rechner anzeigen kann:-1E100<x<1E100

Perl 6 , 456.574 Stellen

[*] 1..ↈ

Kein TIO, da die Ausführung 2 Minuten dauert.