Twoim celem jest wydrukowanie (na standardowe wyjście) jak największej liczby przy użyciu zaledwie dziesięciu znaków kodu.

• Możesz używać dowolnych funkcji swojego języka, z wyjątkiem wbudowanych funkcji potęgowania.
  • Podobnie nie możesz używać notacji naukowej do wprowadzania liczb. (Tak więc nie 9e+99.)
• Program musi wydrukować numer bez żadnego wkładu użytkownika. Podobnie, brak odczytu z innych plików lub z Internetu i tak dalej.
• Twój program musi obliczyć jeden numer i wydrukować go. Nie można wydrukować łańcucha ani wydrukować tej samej cyfry tysiące razy.
• Możesz wyłączyć z limitu 10 znaków kod niezbędny do wydrukowania czegokolwiek. Na przykład w Pythonie 2, który korzysta ze print xskładni, możesz użyć do 16 znaków w swoim programie.
• Program musi faktycznie odnieść sukces w wyniku. Jeśli uruchomienie na najszybszym komputerze na świecie trwa dłużej niż godzinę, jest nieważne.
• Wyjście może być w dowolnym formacie (dzięki czemu można drukować 999, 5e+100itp)
• Nieskończoność jest pojęciem abstrakcyjnym , a nie liczbą. Więc to nie jest poprawny wynik.

Język Wolfram

ack(9!,9!)

ack (9!, 9!) =

Dane wyjściowe są zapisywane strzałkami.

Perl,> 1,96835797883262e + 18

time*time

To może nie być największa odpowiedź ... dziś! Ale poczekaj wystarczająco tysiąclecia i będzie!

Aby odnieść się do niektórych komentarzy, przez „wystarczająco tysiąclecia”, mam na myśli n ¹⁰⁰ lat.

Szczerze mówiąc, jeśli duża śmierć wszechświata z powodu zamarzania / upałów jest tym, w jaki sposób skończy się wszechświat (szacuje się, że nastąpi ~ 10 ¹⁰⁰ lat), „ostateczna” wartość wynosiłaby ~ 10 ²¹⁴ , co z pewnością jest znacznie mniejsze niż niektóre z inne odpowiedzi (choć „losowe fluktuacje kwantowe lub tunelowanie kwantowe mogą spowodować kolejny Wielki Wybuch za 10 ^{10 56} lat”). Jeśli przyjmiemy bardziej optymistyczne podejście (np. Model cykliczny lub wieloświatowy), to czas będzie płynął nieskończenie, a więc pewnego dnia w jakimś wszechświecie, w jakiejś architekturze o wysokiej liczbie bitów, odpowiedź przekroczyłaby niektóre inne.

Z drugiej strony, jak wskazano, timejest rzeczywiście ograniczony rozmiarem liczby całkowitej / długiej, więc w rzeczywistości coś takiego ~0zawsze dawałoby większą liczbę niż time(tj. Maksimum timeobsługiwane przez architekturę).

To nie była najpoważniejsza odpowiedź, ale mam nadzieję, że wam się podobało!

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

Tak, to jest język! Prowadzi back-end popularnej strony Wolfram Alpha. To jedyny język, w którym znalazłem, w którym funkcja Ackermanna jest wbudowana i skrócona do mniej niż 6 znaków.

W ośmiu znakach:

$ ack(4,2)

200352993...719156733

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

ack(4,3), ack(5,2)Itd. Są znacznie większe, ale zbyt duża. ack(4,2)jest prawdopodobnie największą liczbą Ackermanna, niż można ją całkowicie obliczyć w niecałą godzinę.

Większe liczby są renderowane w formie symbolicznej, np .:

$ ack(4,3)

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

Reguły mówią, że każdy format wyjściowy jest dozwolony, więc może być poprawny. Jest to więcej niż 10 ^{10 19727} , co jest większe niż jakikolwiek inny ^zapis tutaj, z wyjątkiem powtarzanego silnia.

Jednak,

$ ack(9,9)

2↑⁷12 - 3

jest większy niż powtarzana silnia. Największa liczba, jaką mogę uzyskać w dziesięciu znakach, to:

$ ack(99,99)

2↑⁹⁷102 - 3

To jest niesamowicie ogromne, Wszechświat nie jest wystarczająco duży, aby reprezentować znaczną część jego cyfr, nawet jeśli wziąłeś powtarzające się dzienniki liczby.

Powłoka Python2, 3010301 cyfr

9<<9999999

Obliczanie długości: Python doda „L” do tych długich liczb, więc zgłasza 1 znak więcej niż wynik ma cyfry.

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

Pierwsza i ostatnia 20 cyfr:

40724177878623601356... ...96980669011241992192

CJam, 2 × 10 ^268,435,457

A28{_*}*K*

Oblicza to b , zdefiniowane następująco:

• ₀ = 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

tło

Jest to zgodne z tym samym pomysłem, co odpowiedź Claudiu , ale nie jest na nim oparte. Miałem podobny pomysł, który zamieściłem zaledwie kilka minut po tym, jak opublikował swój , ale odrzuciłem go, ponieważ nie zbliżył się do terminu.

Jednak sugestia aditsu, aby uaktualnić do Javy 8 i mój pomysł użycia mocy 10 pozwoliły CJamowi obliczyć liczby poza zasięgiem GolfScript, co wydaje się być spowodowane pewnymi błędami / ograniczeniami Bignum Ruby.

Jak to działa

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,{)*_*}/

Zajmuje mniej niż pięć minut na moim komputerze, więc wciąż jest miejsce na ulepszenia.

Oblicza to ₂₀ , zdefiniowane w następujący sposób:

• ₀ = 20

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

Jak to działa

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

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

Edycja: Moja nowa odpowiedź to:

9<<(7<<33)

Stara odpowiedź dla potomnych:

9<<(1<<35)

Dokładnie dziesięć znaków.

Drukuję liczbę szesnastkową i

Możesz wyłączyć z limitu 10 znaków kod niezbędny do wydrukowania czegokolwiek. Na przykład w Pythonie 2, który używa składni print x, możesz użyć do 16 znaków w swoim programie.

Dlatego mój rzeczywisty kod to:

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

Dowód, że działa w określonym czasie i generuje liczbę o określonym rozmiarze:

time python bignum.py > bignumoutput.py

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

Mój numer> 10 ^ (15032385538 * log (16))> 10 ^ 18100795813

3 mniej cyfr szesnastkowych niż powyższy wydruk wc z powodu początkowej 0x9.

Python 3 jest konieczny, ponieważ w Pythonie 2 7<<33byłby długi i <<nie zajmuje długo jako danych wejściowych.

Nie mogę zamiast tego użyć 9 << (1 << 36), ponieważ:

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

Jest to zatem największa możliwa liczba formularzy a<<(b<<cd)do wydrukowania na moim komputerze.

Najprawdopodobniej najszybsza maszyna na świecie ma więcej pamięci niż ja, więc moją alternatywną odpowiedzią jest:

9<<(9<<99)

9 * 2 ^ (9 * 2 ^ 99)> 10 ^ (1,7172038461 * 10 ^ 30)

Jednak moja obecna odpowiedź jest jak dotąd największa, więc prawdopodobnie jest wystarczająco dobra. To wszystko zakłada, że ​​przesunięcie bitów jest dopuszczalne. Wygląda na to, że z innych odpowiedzi, które go wykorzystały.

Dowolny język z wystarczająco krótkimi stałymi nazwami, około 18 cyfr.

99/sin(PI)

Opublikowałbym to jako odpowiedź PHP, ale niestety M_PIsprawia, że ​​jest to trochę za długo! Ale PHP daje za to 8.0839634798317E + 17. Zasadniczo narusza brak absolutnej precyzji w PI: s

Haskell

Bez żadnych sztuczek:

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

Prawdopodobnie bez obliczania czegokolwiek:

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

Dostosowując odpowiedź Nieta :

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

PowerShell - 1.12947668480335E + 42

99PB*9E9PB

Mnoży 99 Pebibajtów razy 9 000 000 000 Pebibajtów.

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

Tak, to dużo. 10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425)))))))nie być bardzo dokładnym.

!!!!!!!!9x

K / Kona : 8,977649e261 1,774896e308

*/1.6+!170

• !170 tworzy wektor liczb od 0 do 169
• 1.6+ dodaje po jednym do każdego elementu wektora i konwertuje na liczby rzeczywiste (zakres wynosi od 1,6 do 170,6)
• */ mnoży każdy element tablicy razem

Gdyby Kona obsługiwał quad precyzję, mógłbym to zrobić */9.+!999i uzyskać około 1e2584. Niestety tak nie jest i jestem ograniczony do podwójnej precyzji.

stara metoda

*/9.*9+!99

• !99 tworzy wektor liczb od 0 do 98
• 9+ dodaje 9 do każdego elementu wektora (obecnie zakresy od 9 do 107)
• 9.* mnoży każdy element przez 9,0 (domyślnie konwertuje na liczby rzeczywiste, więc od 81,0 do 963,0)
• */ mnoży każdy element wektora razem

HTML, 9999999999

9999999999

.. przybity.

Python - zmienia się, do 13916486568675240 (do tej pory)

Nie do końca poważnie, ale pomyślałem, że to będzie fajna zabawa.

print id(len)*99

Ze wszystkich rzeczy, których próbowałem, lennajbardziej konsekwentnie dostawałem duże dowody tożsamości.

Uzyskano 13916486568675240 (17 cyfr) na moim komputerze i 13842722750490216 (także 17 cyfr) na tej stronie . Przypuszczam, że jest to możliwe, aby dać ci tak niskie, jak 0, ale może również wzrosnąć.

Golfscript, 1e + 33,554,432

10{.*}25*

Obliczenia 10 ^ (2 ^ 25)bez użycia wykładników działają w 96 sekund:

$ 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

Może obliczyć, nawet 9 ^ (2 ^ 9999)jeśli ma wystarczającą ilość czasu, ale zwiększenie wewnętrznego wykładnika o jeden powoduje potrojenie czasu, więc limit jednej godziny zostanie wkrótce osiągnięty.

Objaśnienie :

Używanie poprzedniej wersji z tym samym pomysłem:

8{.*}25*

Podział:

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

Stos na początku każdego bloku składa się z jednej liczby, bieżącej liczby. Zaczyna się to jako 8. Następnie:

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

Tak więc stos, krok po kroku, wygląda następująco:

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

... itd. Postęp zapisany w notacji matematycznej jest następujący:

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} (lub 10 ^{8,565,705,514} )

999*13511!

Dane wyjściowe to

269146071053904674084357808139[49888 digits]000000000000000000000000000000

Nie jestem pewien, czy to całkiem pasuje do specyfikacji (szczególnie jeden format wyjściowy), ale mogę trafić jeszcze większy:

bfloat(99999999!)

Dane wyjściowe to

9.9046265792229937372808210723818b8565705513

To mniej więcej 10 8 ^{655 705 514,} co jest znacznie większe niż większość najlepszych odpowiedzi i zostało obliczone w około 2 sekundy. bfloatFunkcja daje dowolną dokładnością .

Haskell, 4950

Ooo stary, to niewiele. 10 znaków zaczyna się po znaku dolara.

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

Mathematica, 2.174188391646043 * 10 ^ 20686623745

$MaxNumber

Dokładnie dziesięć znaków.

Powłoka Python, 649539 999890001

Pokonuje Haskella, niezbyt poważna odpowiedź.

99999*9999

Wolfram Alpha (czy witryna liczy się jako język)?

9! ! ! ! !

wyjścia

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

dzięki Cory za wskazówkę, że spacje działają tak samo jak pareny.

Befunge-93 (1 853 020,188,851,841)

Cieszę się, że nikt jeszcze nie zrobił Befunge (to moja nisza), ale do cholery nie mogę znaleźć sprytnej sztuczki, aby zwiększyć liczbę.

9:*:*:*:*.

To jest 9 ^ 16.

:*

Zasadniczo mnoży wartość na górze stosu z samym sobą. Tak więc wartość na górze stosu wynosi:

9
81
6561
43046721
1853020188851841

i

.

Zwraca wartość końcową. Byłbym zainteresowany, aby zobaczyć, czy ktoś ma jakieś lepsze pomysły.

Wolę opublikować to jako komentarz powyżej, ale najwyraźniej nie mogę, ponieważ jestem noobem.

Pyton:

9<<(2<<29)

Wybrałbym większą zmianę bitów, ale Python wydaje się, że właściwym operandem zmiany jest niecałkowita liczba całkowita. Myślę, że zbliża się to do teoretycznego maksimum:

9<<(7<<27)

Jedynym problemem jest to, że mogą one nie spełniać reguły 5.

Matlab (1.7977e + 308)

Matlab przechowuje wartość największej (podwójnej precyzji) liczby zmiennoprzecinkowej w zmiennej o nazwie realmax. Wywołanie go w oknie poleceń (lub w wierszu poleceń) powoduje wydrukowanie jego wartości:

>> realmax

ans =

  1.7977e+308

Python, ca. 1,26e1388

9<<(9<<9L)

Daje:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L376340363130388599772956263671606191396751457475971857265733513638643345603868866324641403099914514071247592911460125725957254917551565757705659026276177784000073656332189036373 503 690 637 6373 505 36 90 6 6 6 6 6 6 6 6 7 6 7 6 7 6 7 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 6 7 6 7 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 izin z tego górzyste miejsce na półki sklepowe dla osób z całego świata.376340363130388599772956263671606191396751457475971857265733513638643345603868866324641403099914514071247592911460125725957254917551565757705659026276177784000073656332189036373 503 690 637 6373 505 36 90 6 6 6 6 6 6 6 6 7 6 7 6 7 6 7 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 6 7 6 7 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 izin z tego górzyste miejsce na półki sklepowe dla osób z całego świata.

Co najmniej Python 3.5.0 (64-bitowy), więcej niż 10 ^ 242944768872896860

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

W idealnym świecie byłoby to 9<<(1<<63)-1, ale nie ma na to wystarczającej ilości bajtów. Liczba ta jest tak duża, że ​​do jej przechowywania potrzeba prawie 1 EiB pamięci, czyli nieco więcej niż na komputerze. Na szczęście potrzebujesz tylko około 0,2% światowej przestrzeni dyskowej na zamianę. Po wartości binarnej 1001następują zera 8070450532247928832.

Jeśli Python wyjdzie na maszyny 128-bitowe, maksymalna będzie 9<<(9<<99), która wymaga mniej niż 1 MiYiB pamięci. Jest to dobre, ponieważ masz wystarczająco dużo miejsca adresowalnego do przechowywania interpretera Pythona i systemu operacyjnego.

Cubix , 9.670457478596419e + 147 (niekonkurencyjny)

****"///**

Nie konkuruje, ponieważ Cubix jest nowszy niż to wyzwanie. Możesz go przetestować online tutaj , ale pamiętaj, że tak naprawdę nie drukuje numeru; będziesz musiał zatrzymać program po uruchomieniu dwóch ostatnich *s, aby zobaczyć wartość na stosie.

Jak to działa

Cubix to dwuwymiarowy esolang, w którym kod jest owinięty wokół sześcianu. Ten kod jest dokładnie równoważny z następującą siatką kostki, gdzie .nie ma operacji :

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

Następnie uruchamiany jest kod ze wskaźnikiem instrukcji (IP) rozpoczynającym się w lewym górnym rogu skrajnie lewej strony, skierowanym w prawo. "włącza tryb łańcuchowy, w którym wszystkie znaki zostały napotkane, aż do następnego "wypchnięcia kodów znaków na stos. Adres IP owija się wokół kodu, wypychając trzy /s (47), dwa *s (42) i dwa .s (46) na stos, zanim ponownie opuści tryb ciągów.

Oto, gdzie robi się ciekawie. Pierwsze lustro /odbija adres IP, więc jest skierowane do góry; następnie obraca się wokół sześcianu, uderzając w następujące znaki:

           
    * *
  /     *      
  .     .      
    . .

Te trzy *s mnożą dwa górne elementy na stosie. Teraz, w przeciwieństwie do większości języków opartych na stosie, w których operatory arytmetyczne wstawiają argumenty, Cubix pozostawia poprzednie wartości na stosie. Oznacza to, że to się oblicza 46*46 = 2116, 46*2116 = 97336, 2116*97336 = 205962976.

Kiedy adres IP osiągnie /ponownie, jest skręcony w prawo. Następnie uderza w następne lustro i podąża następującą ścieżką:

    *  
    *  
    /         .
    .         .
    .  
    .  

Dwie gwiazdki ponownie pomnożą dwa górne elementy. Następnie lustro ponownie kieruje adres IP, a trzecie lustro powtarza proces jeszcze raz:

      *
      *
      /     .  
      .     .  
      .
      .

Wreszcie, IP opuszcza sekcję lustrzaną kierując się na wschód. Dwie ostatecznie gwiazdki mnożą się jeszcze dwa razy, pozostawiając wynik 9.670457478596419e + 147 na stosie. Można to wydrukować O, ale nie jest to łatwy sposób, ponieważ praktycznie każde miejsce na kostce jest już zajęte.

Scala, 2 ⁶³ -1

Biedna, biedna Scala. Aby uzyskać BigIntwartość, potrzeba co najmniej 8 znaków , co nie pozostawia wystarczającej ilości miejsca, aby ją zwiększyć.

Ale tylko 7 znaków (policzonego) kodu możemy wydrukować jak największy pozytyw Long:

print(-1L>>>1)

Brainf ** k 256 - 2147483647

>+[<+>+]<.

_{Jeśli zignorujesz fakt, że większość kompilatorów i interpreterów wyprowadza dane, ponieważ są one równoważne ascii (bądź leanient, tak właśnie jest;))} , zwróci to maksymalną wartość typu danych interpretera / kompilatora.

W niektórych systemach jest to tylko 256, choć w niektórych (na przykład mój), jest to maksymalna wartość 32-bitowej liczby całkowitej, tj. 2 147 483 647.

Edytować:

-.

Wydrukuje to samo o wiele mniej znaków

Perl, niekonkurujący

Używam tego, aby podświetlić trochę znanego kąta perla.

Perl tak naprawdę nie może konkurować z tym, ponieważ nie ma wbudowanych bignum (oczywiście można załadować bibliotekę bignum).

Ale to, co wszyscy wiedzą, nie jest do końca prawdą. Jedna podstawowa funkcja faktycznie obsługuje duże liczby.

packFormat wmoże rzeczywiście przekształcić dowolny rozmiar liczbę naturalną między bazą 10i podstawą 128. Podstawowa liczba całkowita 128 jest jednak reprezentowana jako bajty łańcuchowe. Łańcuch xxxxxxxyyyyyyyzzzzzzzbitów staje się bajtami: 1xxxxxxx 1yyyyyyy 0zzzzzzz(każdy bajt zaczyna się od 1 oprócz ostatniego). I możesz przekonwertować taki ciąg na bazę 10 z rozpakowaniem. Możesz więc napisać kod taki jak:

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

co daje:

17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

Możesz zastąpić 4**4je większymi wartościami, aż poczujesz, że to trwa zbyt długo lub zużywa zbyt dużo pamięci.

Niestety jest to zdecydowanie za długo na limit tego wyzwania i można argumentować, że wynik 10 jest konwertowany na ciąg znaków, zanim stanie się wynikiem, więc wyrażenie tak naprawdę nie generuje liczby. Ale wewnętrznie perl naprawdę wykonuje arytmetykę, aby przekonwertować dane wejściowe na bazę 10, co zawsze uważałem za dość porządne.

TI-36 (nie 84, 36), 10 bajtów, ok. 9,999985426E99

Starsze kalkulatory można również programować w pewnym zakresie;)

69!58.4376

Jest to bardzo zbliżone do maksymalnego zakresu, jaki może wyświetlić kalkulator TI:-1E100<x<1E100

Perl 6 , 456 574 cyfr

[*] 1..ↈ

Brak TIO, ponieważ uruchomienie zajmuje 2 minuty.