Il tuo obiettivo è stampare (sull'output standard) il maggior numero possibile, usando solo dieci caratteri di codice.

• È possibile utilizzare qualsiasi funzionalità della propria lingua, ad eccezione delle funzioni di esponenziazione integrate.
  • Allo stesso modo, non è possibile utilizzare la notazione scientifica per inserire un numero. (Quindi no 9e+99.)
• Il programma deve stampare il numero senza alcun input da parte dell'utente. Allo stesso modo, nessuna lettura da altri file o dal Web e così via.
• Il tuo programma deve calcolare un singolo numero e stamparlo. Non è possibile stampare una stringa, né è possibile stampare la stessa cifra migliaia di volte.
• È possibile escludere dal limite di 10 caratteri qualsiasi codice necessario per stampare qualsiasi cosa. Ad esempio, in Python 2 che utilizza la print xsintassi, è possibile utilizzare fino a 16 caratteri per il programma.
• Il programma deve effettivamente riuscire nell'output. Se impiega più di un'ora per funzionare sul computer più veloce del mondo, non è valido.
• L'output può essere in qualsiasi formato (in modo da poter stampare 999, 5e+100ecc)
• L'infinito è un concetto astratto , non un numero. Quindi non è un output valido.

Wolfram Language

ack(9!,9!)

ack (9!, 9!) =

L'output è in notazione freccia.

Perl,> 1.96835797883262e + 18

time*time

Potrebbe non essere la risposta più grande ... oggi! Ma aspetta abbastanza millenni e lo sarà!

Per rispondere ad alcuni dei commenti, per "abbastanza millenni", in realtà intendo n ¹⁰⁰ anni.

Ad essere onesti, se la grande morte per congelamento / calore dell'universo è il modo in cui l'universo finirà (si stima che si verifichi ~ 10 ¹⁰⁰ anni), il valore "finale" sarebbe ~ 10 ²¹⁴ , che è certamente molto inferiore ad alcuni dei altre risposte (tuttavia, "fluttuazioni quantistiche casuali o tunnel quantistici possono produrre un altro Big Bang in 10 ^{10 56} anni"). Se adottiamo un approccio più ottimista (ad esempio un modello ciclico o multiverso), allora il tempo passerà all'infinito, e quindi un giorno in un universo, su un'architettura a bit alto, la risposta supererebbe alcuni degli altri.

D'altra parte, come sottolineato, timeè in effetti limitato dalla dimensione di intero / lungo, quindi in realtà qualcosa del genere ~0produrrebbe sempre un numero maggiore di time(cioè il massimo timesupportato dall'architettura).

Questa non è stata la risposta più seria, ma spero che vi sia piaciuto!

Wolfram ≅ 2.003529930 × 10 ¹⁹⁷²⁸

Sì, è una lingua! Guida il back-end del famoso sito Wolfram Alpha. È l'unica lingua che ho trovato in cui la funzione Ackermann è integrata e abbreviata con meno di 6 caratteri.

In otto caratteri:

$ ack(4,2)

200352993...719156733

Oppure ≅ 2.003529930 × 10 ¹⁹⁷²⁸

ack(4,3), ack(5,2)ecc. sono molto più grandi, ma troppo grandi. ack(4,2)è probabilmente il numero Ackermann più grande di quello che può essere completamente calcolato in meno di un'ora.

I numeri più grandi vengono visualizzati in forma simbolica, ad esempio:

$ ack(4,3)

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

Le regole dicono che è consentito qualsiasi formato di output, quindi potrebbe essere valido. Questo è maggiore di 10 ^{10 19727} , che è più grande di tutte le altre voci qui ad eccezione del fattoriale ripetuto.

Però,

$ ack(9,9)

2↑⁷12 - 3

è più grande del fattoriale ripetuto. Il numero più grande che posso ottenere in dieci caratteri è:

$ ack(99,99)

2↑⁹⁷102 - 3

Questo è follemente enorme, l'Universo non è abbastanza grande da rappresentare una porzione significativa delle sue cifre, anche se hai preso registri ripetuti del numero.

Shell Python2, 3.010.301 cifre

9<<9999999

Calcolo della lunghezza: Python aggiungerà una "L" a questi numeri lunghi, quindi riporta 1 carattere in più rispetto al risultato che ha cifre.

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

Prime e ultime 20 cifre:

40724177878623601356... ...96980669011241992192

CJam, 2 × 10 ^268.435.457

A28{_*}*K*

Questo calcola b , definito come segue:

• 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

sfondo

Questo segue la stessa idea della risposta di Claudiu , ma non si basa su di essa. Ho avuto un'idea simile che ho pubblicato pochi minuti dopo aver pubblicato la sua , ma l'ho scartata dal momento che non si avvicinava affatto al limite di tempo.

Tuttavia, il suggerimento di aditsu di passare a Java 8 e la mia idea di usare potenze di 10 hanno permesso a CJam di calcolare numeri oltre la portata di GolfScript, il che sembra essere dovuto ad alcuni bug / limitazioni di Bignum di Ruby.

Come funziona

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

Richiede meno di cinque minuti sulla mia macchina, quindi c'è ancora spazio per miglioramenti.

Questo calcola un ₂₀ , definito come segue:

• a ₀ = 20

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

Come funziona

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

Modifica: la mia nuova risposta è:

9<<(7<<33)

Vecchia risposta, per i posteri:

9<<(1<<35)

Dieci personaggi esattamente.

Sto stampando il numero in esadecimale e

È possibile escludere dal limite di 10 caratteri qualsiasi codice necessario per stampare qualsiasi cosa. Ad esempio, in Python 2 che utilizza la sintassi print x, è possibile utilizzare fino a 16 caratteri per il programma.

Pertanto, il mio codice attuale è:

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

Prova che viene eseguito nel tempo specificato e genera un numero della dimensione specificata:

time python bignum.py > bignumoutput.py

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

Il mio numero> 10 ^ (15032385538 * log (16))> 10 ^ 18100795813

3 cifre esadecimali in meno rispetto alla stampa del wc sopra a causa dell'iniziale 0x9.

Python 3 è necessario perché in Python 2 7<<33sarebbe lungo e <<non impiegherà molto tempo come input.

Non posso usare 9 << (1 << 36) invece perché:

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

Quindi, questo è il numero più grande possibile del modulo a<<(b<<cd)stampabile sul mio computer.

Con ogni probabilità, la macchina più veloce del mondo ha più memoria di me, quindi la mia risposta alternativa è:

9<<(9<<99)

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

Tuttavia, la mia risposta attuale è la più grande che qualcuno abbia inviato, quindi probabilmente è abbastanza buona. Inoltre, tutto ciò presuppone che sia consentito lo spostamento dei bit. Sembra essere, dalle altre risposte che lo utilizzano.

Qualsiasi lingua con nomi di costante abbastanza brevi, circa 18 cifre.

99/sin(PI)

Vorrei pubblicare questo come una risposta PHP ma purtroppo lo M_PIrende un po 'troppo lungo! Ma PHP produce 8.0839634798317E + 17 per questo. Fondamentalmente, abusa della mancanza di assoluta precisione in PI: p

Haskell

Senza trucchi:

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

Probabilmente senza calcolare nulla:

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

Adattare la risposta di Niet :

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

Powershell - 1.12947668480335E + 42

99PB*9E9PB

Moltiplica 99 Pebibyte per 9.000.000.000 di Pebibyte.

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

Sì, è molto. 10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425)))))))per non essere molto preciso.

!!!!!!!!9x

K / Kona : 8.977649e261 1.774896e308

*/1.6+!170

• !170 crea un vettore di numeri da 0 a 169
• 1.6+ aggiunge uno a ciascun elemento del vettore e converte in reali (l'intervallo è compreso tra 1,6 e 170,6)
• */ moltiplica ogni elemento dell'array insieme

Se Kona supportasse la precisione quad, potrei fare */9.+!999e aggirare 1e2584. Purtroppo, non lo è e sono limitato alla doppia precisione.

vecchio metodo

*/9.*9+!99

• !99 crea un vettore di numeri da 0 a 98
• 9+ aggiunge 9 a ciascun elemento del vettore (ora varia da 9 a 107)
• 9.* moltiplica ogni elemento per 9,0 (convertendolo implicitamente in reali, quindi da 81,0 a 963,0)
• */ moltiplica ogni elemento del vettore insieme

HTML, 9999999999

9999999999

.. azzeccato.

Python - Varia, fino a 13916486568675240 (finora)

Non del tutto serio, ma ho pensato che sarebbe stato abbastanza divertente.

print id(len)*99

Tra tutte le cose che ho provato, mi è lenstato sempre più facile ottenere grandi ID.

Ha prodotto 13916486568675240 (17 cifre) sul mio computer e 13842722750490216 (anche 17 cifre) su questo sito . Suppongo che sia possibile che ti dia un minimo di 0, ma potrebbe anche andare più in alto.

Golfscript, 1e + 33.554.432

10{.*}25*

Calcola 10 ^ (2 ^ 25), senza usare esponenti, viene eseguito in 96 secondi:

$ 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

Può calcolare fino a 9 ^ (2 ^ 9999), se solo con abbastanza tempo, ma incrementare l'esponente interno di uno fa impiegare ~ il triplo del tempo, quindi il limite di un'ora verrà raggiunto abbastanza presto.

Spiegazione :

Utilizzando una versione precedente con la stessa idea:

8{.*}25*

Abbattendo:

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

Lo stack all'inizio di ogni blocco è costituito da un numero, il numero corrente. Questo inizia come 8. Poi:

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

Quindi lo stack, passo dopo passo, si presenta così:

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

... ecc. Scritto in notazione matematica, la progressione è:

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 (o 10 ^{8.565.705.514} )

999*13511!

L'output è

269146071053904674084357808139[49888 digits]000000000000000000000000000000

Non sono sicuro che sia abbastanza adatto alle specifiche (in particolare il formato di output uno), ma posso colpire anche più grandi:

bfloat(99999999!)

L'output è

9.9046265792229937372808210723818b8565705513

Sono circa 10 ^{8.565.705.514,} che sono significativamente più grandi della maggior parte delle risposte migliori e sono stati calcolati in circa 2 secondi. La bfloatfunzione offre una precisione arbitraria .

Haskell, 4950

Oh amico, non è molto! 10 caratteri iniziano dopo il simbolo del dollaro.

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

Mathematica, 2.174188391646043 * 10 ^ 20686623745

$MaxNumber

Dieci personaggi esattamente.

Guscio in pitone, 649539 999890001

Batte Haskell, non proprio una risposta seria.

99999*9999

Wolfram Alpha (un sito Web conta come lingua)?

9! ! ! ! !

uscite

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

grazie a Cory per la punta che gli spazi funzionano così come i genitori.

Befunge-93 (1.853.020.188.851.841)

Sono contento che nessuno abbia ancora fatto Befunge (è la mia nicchia), ma dannazione non riesco a trovare alcun trucco intelligente per aumentare il numero.

9:*:*:*:*.

Quindi sono le 9 ^ 16.

:*

Moltiplica sostanzialmente il valore nella parte superiore dello stack con se stesso. Quindi, il valore nella parte superiore dello stack va:

9
81
6561
43046721
1853020188851841

e

.

Emette il valore finale. Sarei interessato a vedere se qualcuno ha idee migliori.

Preferirei pubblicare questo come un commento sopra, ma a quanto pare non posso dal momento che sono un noob.

Pitone:

9<<(2<<29)

Andrei con un bit shift più grande, ma Python sembra volere che l'operando giusto di un shift sia un numero intero non lungo. Penso che questo si avvicini al massimo teorico:

9<<(7<<27)

L'unico problema con questi è che potrebbero non soddisfare la regola 5.

Matlab (1.7977e + 308)

Matlab memorizza il valore del più grande numero a virgola mobile (doppia precisione) in una variabile chiamata realmax. Richiamandolo nella finestra di comando (o dalla riga di comando) viene stampato il suo valore:

>> realmax

ans =

  1.7977e+308

Python, ca. 1.26e1388

9<<(9<<9L)

dà:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L

Almeno Python 3.5.0 (64 bit), più di 10 ^ 242944768872896860

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

In un mondo ideale, questo sarebbe 9<<(1<<63)-1, ma non ci sono abbastanza byte per quello. Questo numero è così grande che richiede quasi 1 EiB di memoria per mantenerlo, che è un po 'più di quello che ho sul mio computer. Fortunatamente, è sufficiente utilizzare circa lo 0,2% dello spazio di archiviazione del mondo come swap per mantenerlo. Il valore in binario è 1001seguito da zeri 8070450532247928832.

Se Python esce per macchine a 128 bit, il massimo sarebbe 9<<(9<<99), che richiede meno di 1 MiYiB di memoria. Questo va bene, perché avresti abbastanza spazio indirizzabile per memorizzare l'interprete Python e il sistema operativo.

Cubix , 9.670457478596419e + 147 (non competitivo)

****"///**

Non competitiva perché Cubix è più recente di questa sfida. Puoi testarlo online qui , ma nota che in realtà non stampa il numero; dovrete mettere in pausa il programma dopo aver *eseguito gli ultimi due secondi per vedere il valore nello stack.

Come funziona

Cubix è un esolang bidimensionale in cui il codice è racchiuso in un cubo. Questo codice è esattamente equivalente al seguente cubo netto, dove .è una no-op:

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

Quindi viene eseguito il codice, con il puntatore dell'istruzione (IP) che inizia nell'angolo in alto a sinistra della faccia più a sinistra, rivolto verso destra. "attiva la modalità stringa, dove tutti i caratteri incontrati fino alla successiva "spingono i loro codici caratteri nello stack. L'IP avvolge tutto il codice, spingendo tre /s (47), due *s (42) e due .s (46) nello stack, prima di uscire nuovamente dalla modalità stringa.

Ecco dove diventa interessante. Il primo mirror /riflette l'IP quindi è rivolto verso l'alto; quindi ruota attorno al cubo, colpendo questi caratteri:

           
    * *
  /     *      
  .     .      
    . .

I tre *s moltiplicano i primi due oggetti in pila. Ora, a differenza della maggior parte dei linguaggi basati su stack in cui gli operatori aritmetici pubblicano i propri argomenti, Cubix lascia i valori precedenti nello stack. Ciò significa che questo calcola 46*46 = 2116, 46*2116 = 97336, 2116*97336 = 205962976.

Quando l'IP raggiunge di /nuovo, viene girato a destra. Quindi colpisce il mirror successivo e segue questo percorso:

    *  
    *  
    /         .
    .         .
    .  
    .  

I due asterischi moltiplicano ancora una volta i primi due elementi. Quindi il mirror indirizza nuovamente l'IP, e il terzo mirror ripete il processo ancora una volta:

      *
      *
      /     .  
      .     .  
      .
      .

Infine, l'IP lascia la sezione mirror in direzione est. I due asterischi finali si moltiplicano altre due volte, lasciando in pila un risultato di 9.670457478596419e + 147. Questo potrebbe essere stampato con O, ma non esiste un modo semplice per farlo poiché praticamente ogni punto del cubo è già utilizzato.

Scala, 2 ⁶³ -1

Povera, povera Scala. Sono necessari almeno 8 caratteri per ottenere un BigIntvalore, che non lascia abbastanza spazio per renderlo davvero grande.

Ma con solo 7 caratteri di codice (contato), possiamo stampare il positivo più grande possibile Long:

print(-1L>>>1)

Brainf ** k 256 - 2147483647

>+[<+>+]<.

_{Se si ignora il fatto che la maggior parte dei compilatori e interpreti emettono dati in quanto è ASCII equivalente (essere leali, è quello che è;))} , questo restituirà il valore massimo del tipo di dati dell'interprete / compilatore.

Su alcuni sistemi questo è solo 256, sebbene su alcuni (il mio per esempio), questo è il valore massimo di un numero intero a 32 bit, ovvero 2 147 483 647.

Modificare:

-.

Stamperà la stessa cosa in molti meno personaggi

Perl, non in competizione

Sto usando questo per evidenziare un piccolo angolo di perl.

Perl non può davvero competere su questo perché non ha i bignum incorporati (ovviamente potresti caricare una libreria bignum).

Ma ciò che tutti sanno non è del tutto vero. Una funzione di base in realtà può gestire grandi numeri.

Il packformato wpuò effettivamente convertire qualsiasi numero naturale di dimensioni tra base 10e base 128. L'intero di base 128 è tuttavia rappresentato come byte stringa. La stringa di xxxxxxxyyyyyyyzzzzzzzbit diventa i byte: 1xxxxxxx 1yyyyyyy 0zzzzzzz(ogni byte inizia con 1 tranne l'ultimo). E puoi convertire una tale stringa in base 10 con unpack. Quindi puoi scrivere codice come:

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

che dà:

17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

Puoi sostituirlo 4**4con valori più grandi fino a quando ritieni che impieghi troppo tempo o usi troppa memoria.

Sfortunatamente questo è troppo lungo per il limite di questa sfida, e puoi sostenere che il risultato di base 10 viene convertito in una stringa prima che diventi il ​​risultato, quindi l'espressione non produce realmente un numero. Ma internamente perl fa davvero l'aritmetica necessaria per convertire l'input in base 10 che ho sempre considerato piuttosto accurato.

TI-36 (non 84, 36), 10 byte, ca. 9.999985426E99

Anche i vecchi calcolatori possono essere programmati in misura;)

69!58.4376

Questo è molto vicino alla portata massima che un calcolatore TI può visualizzare:-1E100<x<1E100

Perl 6 , 456.574 cifre

[*] 1..ↈ

Nessun TIO perché ci vogliono 2 minuti per l'esecuzione.