Numero più grande in dieci byte di codice


77

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.


21
Cosa intendi esattamente con "calcola". Inoltre, If it takes longer than an hour to run on any computer in the world, it's invalid.non è obiettivo. Potrei (teoricamente) fabbricare un computer che impiega un'ora per cambiare uno stato T
user80551

4
Il bit-shift conta come operatore di esponenziazione poiché è equivalente a * 2^x?
Claudiu,

14
Il fatto che il limite di tempo dipenda dalle prestazioni del computer più veloce del mondo ci rende impossibile determinare l'insieme di risposte valide ... Non mi piace molto
David Z

6
Le funzioni di esponenziazione non sono consentite, ma la funzione ackermann è consentita? Sembra davvero arbitrario. Non è chiaro perché una manipolazione simbolica sia considerata "calcolando" il numero.
WolframH

Risposte:


26

Wolfram Language

ack(9!,9!)

ack (9!, 9!) =inserisci qui la descrizione dell'immagine

L'output è in notazione freccia.


3
@KyleKanos È diverso perché il codice / programma non chiama il web. Altri esempi typescriptlang.org/Playground tryfsharp.org/Learn/getting-started
Adam Speight

35
La lingua Wolfram è disponibile per l'uso di un Raspberry Pi e non richiede l'accesso al web. Quindi non è in violazione di quella regola.
Adam Speight,

6
Penso che sia una risposta molto valida. Stupido ragionamento per essere sull'isola e non avere accesso a Internet. Il requisito 'No web' è solo per impedire la stampa di output da una risorsa già disponibile. Tutte le risposte sono valide purché "eseguano" un pezzo di codice per calcolare l'output. È in arrivo Visual Studio più recente che esegue il codice sul cloud di Azure, quindi si desidera limitare C #? O non sei idoneo se hai un Chromebook?
microbian

26
ack(99!,9)è molto, molto più grande.
jimmy23013,

11
Una delle altre risposte dice che ack (4,2) è il più grande che può calcolare in un'ora, quindi sarei sorpreso se ciò accadesse ...
Jerry Jeremiah

120

Perl,> 1.96835797883262e + 18

time*time

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


Modificare:

Per rispondere ad alcuni dei commenti, per "abbastanza millenni", in realtà intendo n 100 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 100 anni), il valore "finale" sarebbe ~ 10 214 , 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!


23
Votato perché mi piace l'eventualità
Tim

5
Non andrà a timefinire e restituirà un piccolo numero ad un certo punto? Dipende dal fatto che sia a 32 o 64 bit perl immagino
Claudiu,

3
1000 anni ~ 3e10 secondi, quindi continuerai a rimanere in bilico intorno a 1e21 come output. Forse se hai aspettato 1e50 anni, potresti iniziare a competere con le altre risposte?
Kyle Kanos,

8
Pronunciate "time times time"? :-) (ciao Timwi!)
Pierre Arlaud,

1
L'ora in cui il calore della morte dell'universo rappresenta l'ora legale? Potresti guadagnare qualche secondo in più di esistenza.
Alpha,

65

Wolfram ≅ 2.003529930 × 10 19728

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 19728

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.


85
Non male, ma non corrisponde alla mia ack(4,2)+1soluzione.
user19057,

13
ack (4,2) +2, I WIN

1
Penso che tu abbia vinto.
Anonimo Pi,

20
@Kyle, Yimin Ci sono molte dichiarazioni fuorvianti in questo post e i commenti sotto di essa. Questa non è la lingua di Wolfram e non viene usata come backend di W | A. È semplicemente un input di "linguaggio naturale" in Wolfram | Alpha. Nella lingua Wolfram l' ack(4,2)input non è valido. L'input del linguaggio naturale di W | A non dovrebbe nemmeno essere considerato un linguaggio di programmazione. Non è Turing completo e non puoi scrivere nemmeno programmi base come l'algoritmo di Euclide. Per questo motivo non credo che questa sia una risposta valida più di quanto non lo sarebbe una query di Google.
Szabolcs,

4
Il Wolfram Language è il linguaggio di programmazione utilizzato in Mathematica, documentato qui . Wolfram | Alpha prende il linguaggio naturale come input, non il Wolfram Language.
Szabolcs,

30

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

2
Dannazione! Questo è emerso mentre stavo scrivendo la stessa risposta
James_pic,

2
Questo è davvero giusto 9 * 2**9999999, quindi si potrebbe sostenere che usa l'espiazione.
Dennis,

2
Aspetta, ***built-in*** exponentiation functionsnon sono ammessi, quindi potrebbe scivolare sotto le regole. +1
user80551

1
Modo matematico per calcolare la lunghezza:floor(log10(9 * 2**9999999))+1
Giustino,

8
9 << (9 << 99) è molto più grande, se termina.
Keith Randall,

29

CJam, 2 × 10 268.435.457

A28{_*}*K*

Questo calcola b , definito come segue:

  • a 0 = 10

  • a n = a n - 1 2

  • b = 20 × a 28

$ 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 20 , definito come segue:

  • a 0 = 20

  • a n = (n × a n - 1 ) 2

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.                               ";
}/

21
Haha, è Kirby? :)
aditsu,

Potresti descrivere cosa sta facendo questo?
Kyle Kanos,

2
Cordiali saluti, ho eseguito alcuni test per verificare le prestazioni di BigInteger - ho calcolato 100000! e convertito in stringa. Risultati: calcolo java 6: 21 sec, 44 sec toString; java 7: calcolo di 14 sec, 42 sec a String; java 8: calcolo di 5 secondi, 1 secondo a String!
aditsu,

1
@aditsu: l'aggiornamento di Java ha ridotto l'autonomia da 5 minuti a 2 secondi!
Dennis,

20

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.


Finora questa sembra di gran lunga la risposta più grande. Dopo tutto, è un numero di 10.000.000.000 di cifre.
nneonneo,

1
@nneonneo: credo che la mia soluzione sia più ampia :)
Zaid,

La risposta alternate richiede juuuuust meno di 1 MiYiB di memoria, e richiede 100 bit di memoria indirizzabile (quindi non funzionerà fino ad almeno 128 bit Python). (Fonte: la mia risposta simile )
wizzwizz4,

19

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


1
Non riesci a fare l'abbronzatura (PI / 2)?
user80551

1
@ user80551 Potrebbe, ma ho appena notato che avrei potuto usare l'ultimo carattere rimasto nel limite per aumentare il mio risultato di 99 volte.
Niet the Dark Absol,

Troppo lungo in Common Lisp: (/ 99(sin pi))(14 caratteri). Errore nella TI-83: 99/sin(π(8 caratteri) causa la divisione per zero. Funziona in LibreOffice Calc : =99/SIN(PI((10 caratteri, senza contare =) calcola 808423047055000000. LibreOffice inserisce automaticamente gli ultimi due ))in =99/SIN(PI()).
kernigh,

Dipende dalla precisione della lingua. In PHP 14 le cifre decimali sono un valore comune.
Kenorb,

@kernigh Non importa in questo caso, ma sarebbe di 99/sin(πcinque byte o otto? So che TI-BASIC memorizza un mucchio di comandi come singoli byte; è sin(uno di loro?
wchargin,

16

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

Il terzo punto indica "Il tuo programma deve calcolare ..."
user80551

8
floor(infinity)è un numero finito? Che diamine Haskell?
nneonneo,

3
1/0! = Infinito, non è definito.
RubberDuck,

1
Ne sei sicuro, @ ckuhn203? In entrambi i GHC 7.6.3 e 7.8.2, ottengo isInfinite $ 1 / 0 -- True. Per quanto ne so, IEEE 754 definisce 1 / 0 l'infinito.
Taylor Fausak,

2
Oh, intendi matematicamente. Sono completamente d'accordo. Ma per quanto riguarda la programmazione con IEEE floating point (e Haskell in particolare) è interessato, 1 / 0 == Infinity.
Taylor Fausak,

15

Powershell - 1.12947668480335E + 42

99PB*9E9PB

Moltiplica 99 Pebibyte per 9.000.000.000 di Pebibyte.


7
98901 sq petabytes? È una sorta di metodo per misurare la densità dei bit di superficie dei (futuri dischi ad alta capacità)?
user80551

Oh bello. Ormai non sapevo che i pebibyte fossero possibili. Ho sempre pensato che si fermasse ai tebibyte.
Joey,

@Joey Ora se MS si affrettasse e aggiungesse yobibyte, la risposta potrebbe essere ancora migliore.
Rynant,

1
Potrei aggiungerlo a Pash se aiuta ... ;-)
Joey,

1+ "1" * 309 restituisce 1.1111e308 anche se suppongo che ciò rompa lo spirito, se non la parola della regola sulla stampa dei caratteri. Viene trasmesso in doppio per l'output.
Tomkandy,

14

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

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

!!!!!!!!9x

5
Ho trovato un compilatore , ma dopo 20 minuti !!9xnon ho stampato nulla sullo schermo. Sinceramente dubito che !!!!!!!!9xsarà mai calcolato.
Kyle Kanos,

16
"Se impiega più di un'ora per funzionare sul computer più veloce del mondo, non è valido." Non sono sicuro che questo sarebbe valido dal momento che non funziona entro un'ora
Claudiu,

11
Ci sono voluti 70 minuti, ma alla !!9xfine sono stati stampati sullo schermo. Sono impressionato dal fatto che abbia effettivamente calcolato il valore, ma fallisce completamente del proiettile 5.
Kyle Kanos,

6
@Quincunx: Probabilmente vero, tuttavia la condizione per una risposta valida è che il programma deve avere esito positivo; questa risposta non soddisfa completamente questo criterio. Purtroppo, i votanti hanno trascurato tutti i commenti sottolineandolo e lo hanno ancora votato sulle risposte di CJam & Golfscript che sono follemente enormi e calcolano in tempi ragionevoli.
Kyle Kanos,

3
Sottovalutato perché non stampa la risposta.
Isaacg,

14

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


11

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.


Ottima idea ma purtroppo non fa calculatenulla.
user80551

3
Credo che la *99parte invochi un calcolo.
commando

Oh sì, / ora mi sento stupido.
user80551

1
Se usi qualcosa di più breve - diciamo id(id)o id(0j), puoi moltiplicare per999
gnibbler il

1
Tra quelli con nomi più piccoli in docs.python.org/2/library/functions.html , varsfornisce costantemente il valore più alto (ma 4 caratteri) seguito da sum. Utilizzare print(sorted([(id(x),x)for x in[id,len,max,min,str,int,ord,chr,sum,map,abs,all,any,bin,bool,eval,oct,vars,iter,list,set,repr,round,zip,type,pow,dict,dir,hex]])[::-1])per verificare.
user80551

10

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)

Qual è il problema con i due davanti al 2564 nella tua uscita?
Kyle Kanos,

@KyleKanos: Non è il mio output, è l'output di wc. Modificherò per renderlo più chiaro
Claudiu,

potresti usare wc -cper rendere più chiaro l'output
daniero,

Bello! Ho avuto la stessa idea qualche minuto fa, ma funziona molto più lentamente con CJam (il che è sorprendente, dal momento che è più veloce di GolfScript in generale).
Dennis,

1
Miglioramento minore: 10{.*}25consegna 33.554.434 cifre e termina in 90 secondi sulla mia macchina. Non so perché, ma 10{.*}26*non stampa nulla.
Dennis,

7

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 .


6

Haskell, 4950

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

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

Perché non solo print? Inoltre, 9/0.000001è maggiore di sum[1..99].
Taylor Fausak,

5
A quel ritmo, potremmo considerare 9 999 999 999 come un limite inferiore ai risultati.
Appassionato il

@TaylorFausak Ovviamente questa risposta non deve essere presa sul serio!
Flonk,

6

Mathematica, 2.174188391646043 * 10 ^ 20686623745

$MaxNumber

Dieci personaggi esattamente.


7
Tecnicamente sta calcolando qualcosa e sta emettendo tutte le cifre e non solo una notazione scientifica?

@Yimin: l'output può essere in qualsiasi formato (in modo da poter stampare 999, 5e + 100, ecc.)
edc65

Il valore non è impostato in fase di compilazione, ma dipende dalla macchina specifica su cui viene eseguito il comando. Penso che conta.
Michael Stern,

5

Guscio in pitone, 649539 999890001

Batte Haskell, non proprio una risposta seria.

99999*9999

6
9999999999 è più grande, no?
MadTux,

5
@MadTux C'è una restrizione ambigua alla calculaterisposta.
user80551

1
Se questa risposta è corretta, allora anche la mia 9**9**9**9è corretta, in quanto è un operatore aritmetico (non una funzione integrata).
Kenorb,

3
@kenorb È incorporato in esponenziale non consentito.
user80551

5

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.


Sono abbastanza sicuro che questo sia il numero più grande nel thread dal mio post, ma Wolfram soffoca nel confrontarlo con altri numeri, anche se ((99!)!)! > 4non ritorna mai.
gggg,

Questo va contro la regola che dice che non puoi ottenerlo dal Web.
Kyle Kanos,

1
Troppi W | A!
Anonimo Pi,

5
Non sono d'accordo sul fatto che ciò infrange le regole. Non "lo legge dal web" che è contro le regole, in realtà "calcola un singolo numero e lo stampa" che è ciò che dovrebbe. Il fatto che l'unica interfaccia disponibile sia un sito Web non significa che non possa essere considerato un linguaggio di programmazione.
gggg,

1
È una risposta completamente valida.
microbian

4

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.



4

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.


3

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

Dal momento che l'OP ha chiesto di restituire un valore calcolato , è necessario inserire realmax+1. L'ho provato per divertimento e sorpresa che restituisce esattamente lo stesso numero di te (poi ho riso quando mi sono reso conto ... eps(realmax)=1.99584030953472e+292).
Hoki,

3

Python, ca. 1.26e1388

9<<(9<<9L)

dà:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L


3

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.


"Solo lo 0,2% dello spazio di archiviazione del mondo"
Benjamin Urquhart,

1
@BenjaminUrquhart Se pensi che sia buono, perché non votare?
wizzwizz4,

C'è il tuo doppio voto;)
Benjamin Urquhart,

3

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.


2

Scala, 2 63 -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)

2

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


La seconda risposta verrà stampata -1sugli interpreti che usano valori firmati per il nastro
Benjamin Urquhart,

2

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.


2

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

inserisci qui la descrizione dell'immagine


2

Perl 6 , 456.574 cifre

[*] 1..ↈ

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

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.