Il tuo obiettivo è scrivere un programma che stampa un numero. Maggiore è il numero, più punti otterrai. Ma fa attenzione! La lunghezza del codice è sia limitata che pesantemente ponderata nella funzione di punteggio. Il numero stampato verrà diviso per il cubo del numero di byte utilizzati per la soluzione .

Quindi, supponiamo che tu abbia stampato 10000000e che il tuo codice sia 100lungo byte. Il tuo punteggio finale sarà 10000000 / 100^3 = 10.

Ci sono altre regole da seguire, al fine di rendere questa sfida un po 'più difficile.

• Non puoi usare le cifre nel tuo codice (0123456789);
• È possibile utilizzare matematico / fisico / etc. costanti, ma solo se sono inferiori a 10. (ad es. puoi usare Pi ~ = 3.14 ma non puoi usare la costante di Avogadro = 6e23)
• La ricorsione è consentita ma il numero generato deve essere finito (quindi infinito non viene accettato come soluzione. Il programma deve terminare correttamente, presupponendo tempo e memoria illimitati e generare l'output richiesto);
• Non è possibile utilizzare le operazioni *(moltiplicare), /(dividere), ^(potenza) né in altro modo per indicarle (ad esempio 2 div 2non è consentito);
• Il tuo programma può generare più di un numero, se necessario per farlo . Solo il più alto conterà per il punteggio;
• Tuttavia, puoi concatenare le stringhe: ciò significa che qualsiasi sequenza di cifre adiacenti verrà considerata come un singolo numero;
• Il tuo codice verrà eseguito così com'è. Ciò significa che l'utente finale non può modificare alcuna riga di codice, né può inserire un numero o altro;
• La lunghezza massima del codice è di 100 byte.

Classifica

1. Steven H. , Pyth ≈ f _{φ (1,0,0) +7} (256 ²⁶ ) / 1000000 ^[1]
2. Arte semplicemente bella , rubino ≈ f _{φ 121 (ω)} (126) ^[1]
3. Peter Taylor , GolfScript ≈ f _{ε 0 + ω + 1} (17) / 1000 ^[1]
4. res , GolfScript ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126)))))))) ^[1]
5. Arte semplicemente meravigliosa , Ruby ≈ f _{ω ^ω2 +1} (1983)
6. eaglgenes101 , Julia ≈ f _ω3 (127)
7. col6y , Python 3, ≈ (127 → 126 → ... → 2 → 1) / 99 ^{3 [1] [3]}
8. Toeofdoom , Haskell, ≈ a ₂₀ (1) / 99 ^{3 [1]}
9. Fraxtil , dc, ≈ 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15/100 ^{3 [3]}
10. Magenta , Python, ≈ ack (126.126) / 100 ³ ≈ 10 ↑ ¹²⁴ 129
11. Kendall Frey , ECMAScript 6, ≈ 10 ^{3 ↑ 4 3} /100 ^{3 [1]}
12. Ilmari Karonen , GolfScript, ≈ 10 ↑ ³ 10 ³⁷⁷ /18 ^{3 [1]}
13. BlackCap , Haskell, ≈ 10 ↑↑ 65503/100 ³
14. ricorsivo , Python, ≈ 2↑↑ 11/95 ³ ≈ 10 ↑↑ 8.63297 ^{[1] [3]}
15. nm , Haskell, ≈ 2↑↑ 7/100 ³ ≈ 10 ↑↑ 4.63297 ^[1]
16. David Yaw , C, ≈ 10 ^{10 4 × 10 22} /83 ³ ≈ 10 ↑↑ 4,11,821 mila ^[2]
17. Primo , Perl, ≈ 10 ^{(12.750.684,161 mila!) 5 × 2 27} /100 ³ ≈ 10 ↑↑ 4,11,369 mila
18. Arte , C, ≈ 10 ^{10 2 × 10 6} /98 ³ ≈ 10 ↑↑ 3,80,587 mila
19. Robert Sørlie , x86, ≈ 10 ^{2 2 19 +32} / 100 ³ ≈ 10 ↑↑ 3.71585
20. Tobia , APL, ≈ 10 ^{10 353} /100 ³ ≈ 10 ↑↑ 3,40,616 mila
21. Darren Stone , C, ≈ 10 ^{10 97.61735} / 98 ³ ≈ 10 ↑↑ 3.29875
22. ecksemmess , C, ≈ 10 ^{2 320} /100 ³ ≈ 10 ↑↑ 3,29,749 mila
23. Adam Speight , vb.net, ≈ 10 ^{5000 × (2 64 ) 4} /100 ³ ≈ 10 ↑↑ 3,28,039 mila
24. Joshua , bash, ≈ 10 ^{10 15} /86 ³ ≈ 10 ↑↑ 3,07,282 mila

_{Le note}

1. ^{Se ogni elettrone nell'universo fosse un qubit, e ogni sua sovrapposizione potrebbe essere proficuamente utilizzata per memorizzare informazioni (che, fintanto che non è necessario conoscere ciò che è memorizzato è teoricamente possibile), questo programma richiede più memoria di quanto potrebbe forse esiste, e quindi non può essere eseguito - ora o in qualsiasi momento concepibile in futuro. Se l'autore intendeva stampare contemporaneamente un valore maggiore di ≈3 ↑↑ 3,28, si applica questa condizione.}
2. ^{Questo programma richiede più memoria di quella attualmente esistente, ma non così tanto da non poter teoricamente essere archiviato su un numero scarso di qubit, e quindi un giorno potrebbe esistere un computer in grado di eseguire questo programma.}
3. ^{Tutti gli interpreti attualmente disponibili generano un errore di runtime, altrimenti il ​​programma non viene eseguito come previsto dall'autore.}
4. ^{L'esecuzione di questo programma causerà danni irreparabili al sistema.}

Modifica @primo : ho aggiornato una parte del tabellone usando una notazione, si spera, più facile da confrontare, con decimali per indicare la distanza logaritmica alla potenza successiva successiva. Ad esempio 10 ↑↑ 2,5 = 10 ^{10 √10} . Ho anche cambiato alcuni punteggi se credevo che l'analisi degli utenti fosse difettosa, sentiti libero di contestare uno di questi.

Spiegazione di questa notazione:

Se 0 ≤ b < 1allora .a↑↑b = ab

Se b ≥ 1allora .a↑↑b = aa↑↑(b-1)

Se b < 0allora .a↑↑b = loga(a↑↑(b+1))

GolfScript; segna almeno f _{ε_0 + ω + 1} (17) / 1000

Seguendo il suggerimento della res di usare la Lifetime di una risposta worm per questa domanda, presento due programmi che migliorano notevolmente la sua derivazione della soluzione di Howard.

Condividono un prefisso comune, modulo il nome della funzione:

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g

calcola g(g(1)) = g(5)dove g(x) = worm_lifetime(x, [x])cresce all'incirca come f _{ε 0} (che res note è "la funzione nella gerarchia in rapida crescita che cresce all'incirca allo stesso ritmo della funzione di Goodstein").

Il leggermente più facile (!) Da analizzare è

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{.{.{.{.{.{.{.{.{.{g}*}*}*}*}*}*}*}*}*}*

.{foo}*mappe xa foo^x x.

,:z){[]+z\{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{g}*

così dà g^(g(5)) ( g(5) ); gli ulteriori 8 livelli di iterazione sono simili al concatenamento di frecce. Per esprimere in termini semplici: se h_0 = ge h_{i+1} (x) = h_i^x (x)poi calcoliamo h_10 (g(5)).

Penso che questo secondo programma abbia quasi certamente un punteggio molto migliore. Questa volta l'etichetta assegnata alla funzione gè una nuova riga (sic).

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:
~
{.['.{
}*'n/]*zip n*~}:^~^^^^^^^^^^^^^^^^

Questa volta ne uso meglio ^come funzione diversa.

.['.{
}*'n/]*zip n*~

prende xla pila e lascia xseguito da una stringa contenente xcopie .{seguite da gseguite da xcopie di }*; quindi valuta la stringa. Dato che avevo un posto migliore per masterizzare i personaggi di riserva, iniziamo con j_0 = g; se j_{i+1} (x) = j_i^x (x)poi la prima valutazione dei ^calcoli j_{g(5)} (g(5))(che sono abbastanza sicuro già batte il programma precedente). Eseguo quindi ^altre 16 volte; quindi se k_0 = g(5)e k_{i+1} = j_{k_i} (k_i)poi calcola k_17. Sono grato (di nuovo) a res per aver stimato che k_i>> f _{ε_0 + ω + 1} (i).

Windows 2000 - Windows 8 (3907172 / 23³ = 321)

NOTA: NON FARE QUESTO!

Salvare quanto segue in un file batch ed eseguirlo come amministratore.

CD|Format D:/FS:FAT/V/Q

Uscita quando eseguito su un'unità da 4 TB con il primo numero stampato in grassetto.

Inserire un nuovo disco per l'unità D:
e premere INVIO quando è pronto ... Il tipo di file system è NTFS.
Il nuovo file system è FAT.
Formattazione rapida 3907172M
Il volume è troppo grande per FAT16 / 12.

GolfScript, punteggio: modo troppo

OK, quanto è grande un numero che possiamo stampare in alcuni caratteri di GolfScript?

Cominciamo con il seguente codice ( grazie, Ben! ), Che stampa 126:

'~'(

Quindi, ripetiamolo 126 volte, dandoci un numero pari a circa 1,26126 × 10 ³⁷⁷ :

'~'(.`*

(Questa è la ripetizione di stringa, non la moltiplicazione, quindi dovrebbe essere OK secondo le regole.)

Ora, ripetiamo quel numero di 378 cifre un po 'più di 10 ³⁷⁷ volte:

'~'(.`*.~*

In realtà non vedrai mai finire questo programma, dal momento che tenta di calcolare un numero con circa 10 ³⁸⁰ ≈ 2 ¹¹⁴⁰ cifre. Nessun computer mai costruito potrebbe contenere un numero così grande, né un tale computer potrebbe mai essere costruito usando la fisica nota; il numero di atomi nell'universo osservabile è stimato a circa 10 ⁸⁰ , quindi, anche se potessimo in qualche modo utilizzare tutta la materia dell'universo per memorizzare questo numero enorme, saremmo ancora in qualche modo avere a stipare circa 10 ³⁸⁰ /10 ⁸⁰ = 10 ³⁰⁰ cifre in ogni atomo!

Ma supponiamo che abbiamo un interprete GolfScript di Dio, in grado di eseguire un tale calcolo e che non siamo ancora soddisfatti. OK, facciamolo di nuovo!

'~'(.`*.~*.~*

L'output di questo programma, se potesse essere completato, avrebbe circa 10 ^{10 383} cifre e quindi sarebbe pari a circa 10 ^{10 10 383} .

Ma aspetta! Quel programma sta diventando ripetitivo ... perché non lo trasformiamo in un ciclo?

'~'(.`*.{.~*}*

Qui, il corpo del loop viene eseguito circa 10 ³⁷⁷ volte, dandoci un output teorico composto da circa 10 ^{10⋰ 10 377} cifre o giù di lì, dove la torre di potenze iterate di 10 è lunga circa 10 ³⁷⁷ passi. (In realtà, questo è un grave sottovalutazione, poiché sto trascurando il fatto che il numero che viene ripetuto aumenta anche ogni volta, ma relativamente parlando è un problema minore.)

Ma non abbiamo ancora finito. Aggiungiamo un altro loop!

'~'(.`*.{.{.~*}*}*

Per scrivere correttamente un'approssimazione di tali numeri è necessaria una notazione matematica esoterica. Ad esempio, nella notazione freccia in alto di Knuth , il numero (teoricamente) prodotto dal programma sopra dovrebbe essere di circa 10 ↑ ³ 10 ³⁷⁷ , dare o prendere alcuni (o 10 ³⁷⁷ ) poteri di dieci, supponendo che io abbia fatto bene la matematica.

Numeri come questo vanno ben oltre "incredibilmente enormi", e nel regno di "inconcepibile". Come in, non solo è impossibile contare o scrivere tali numeri (abbiamo oltrepassato quel punto già al terzo esempio sopra), ma letteralmente non hanno alcun uso o esistenza concepibile al di fuori della matematica astratta. Possiamo dimostrare, dagli assiomi della matematica , che tali numeri esistono, proprio come possiamo dimostrare dalle specifiche GolfScript che il programma sopra li calcolerebbe, se i limiti della realtà e dello spazio di archiviazione disponibile non intervenissero), ma non c'è letteralmente nulla in l'universo fisico che potremmo usarli per contare o misurare in qualsiasi senso.

Tuttavia, i matematici a volte usano numeri ancora più grandi . (Teoricamente) calcolare numeri così grandi richiede un po 'più di lavoro - invece di annidare più loop uno per uno, dobbiamo usare la ricorsione per telescopare la profondità dei loop nidificati. Tuttavia, in linea di principio, dovrebbe essere possibile scrivere un breve programma GolfScript (ben al di sotto di 100 byte, mi aspetterei) per (teoricamente) calcolare qualsiasi numero esprimibile, diciamo, nella notazione a freccia concatenata di Conway ; i dettagli sono lasciati come un esercizio. ;-)

JavaScript 44 caratteri

Questo può sembrare un po 'economico:

alert((Math.PI+''+Math.E).replace(/\./g,""))

Punteggio = 31415926535897932718281828459045/44 ^ 3 ≈ 3.688007904758867e + 26 ≈ 10 ↑↑ 2.1536134004

C, punteggio = 10 ^{10 97.61735} / 98 ³ ≈ 10 ↑↑ 2.29874984

unsigned long a,b,c,d,e;main(){while(++a)while(++b)while(++c)while(++d)while(++e)printf("%lu",a);}

Apprezzo l'aiuto nel punteggio. Eventuali approfondimenti o correzioni sono apprezzati. Ecco il mio metodo:

n = concatenazione di ogni numero da 1 a 2 ⁶⁴ -1, ripetuto (2 ⁶⁴ -1) ⁴ volte . Innanzitutto, ecco come sto stimando (basso) il numero cumulativo di cifre da 1 a 2 ⁶⁴ -1 (la "sottosequenza"): il numero finale nella sequenza di sottosequenza è 2 ⁶⁴ -1 = 18446744073709551615con 20 cifre. Pertanto, oltre il 90% dei numeri nella sottosequenza (quelli che iniziano con 1.. 9) hanno 19 cifre. Supponiamo che il restante 10% in media 10 cifre. Sarà molto più di questo, ma questa è una stima bassa per la matematica facile e nessun imbroglio. Quella sottosequenza viene ripetuta (2 ⁶⁴ -1) ⁴ volte, quindi la lunghezzadi n sarà almeno (0,9 × (2 ⁶⁴ -1) × 19 + 0,1 × (2 ⁶⁴ -1) × 10) × (2 ⁶⁴ -1) ⁴ = 3.86613 × 10 ⁹⁷ cifre. Nei commenti seguenti, @primo conferma che la lunghezza di n è 4.1433x10 ⁹⁷ . Quindi n stesso sarà 10 a quel potere, o 10 ^{10 97.61735} .

l = 98 caratteri di codice

punteggio = n / l ³ = 10 ^{10 97.61735} / 98 ³

Requisito: deve essere eseguito su un computer a 64 bit dove sizeof(long) == 8. Mac e Linux lo faranno.

Python 3 - 99 caratteri - (molto probabilmente) significativamente più grande del numero di Graham

Ho escogitato una funzione in più rapido aumento basata su un'estensione della funzione Ackermann.

A=lambda a,b,*c:A(~-a,A(a,~-b,*c)if b else a,*c)if a else(A(b,*c)if c else-~b);A(*range(ord('~')))

http://fora.xkcd.com/viewtopic.php?f=17&t=31598 mi ha ispirato, ma non è necessario guardare lì per capire il mio numero.

Ecco la versione modificata della funzione ackermann che userò nella mia analisi:

A(b)=b+1
A(0,b,...)=A(b,...)
A(a,0,...)=A(a-1,1,...)
A(a,b,...)=A(a-1,A(a,b-1,...),...)

La mia funzione Anel codice sopra non è tecnicamente la stessa, ma in realtà è più forte, con la seguente istruzione per sostituire la terza riga della definizione sopra:

A(a,0,...)=A(a-1,a,...)

(a deve essere almeno 1, quindi deve essere più forte)

Ma per i miei scopi supporrò che sia lo stesso di quello più semplice, perché l'analisi è già parzialmente eseguita per la funzione di Ackermann, e quindi per questa funzione quando ha due argomenti.

La mia funzione è garantita per smettere di ricorrere alla fine perché o sempre: rimuove un argomento, decrementa il primo argomento o mantiene lo stesso primo argomento e diminuisce il secondo argomento.

Analisi delle dimensioni

Il numero di Graham, AFAIK, può essere rappresentato G(64)usando:

G(n) = g^n(4)
g(n) = 3 ↑^(n) 3

Dove a ↑^(n)b è la notazione a freccia in su di knuth.

Anche:

A(a,b) = 2 ↑^(a-2) (b+3) - 3
A(a,0) ≈ 2 ↑^(a-2) 3
g(n) ≈ A(n+2,0) // although it will be somewhat smaller due to using 2 instead of 3. Using a number larger than 0 should resolve this.
g(n) ≈ A(n+2,100) // this should be good enough for my purposes.

g(g(n)) ≈ A(A(n+2,100),100)

A(1,a+1,100) ≈ A(0,A(1,a,100),100) = A(A(1,a,100),100)

g^k(n) ≈ A(A(A(A(...(A(n+2,100)+2)...,100)+2,100)+2,100)+2,100) // where there are k instances of A(_,100)
A(1,a,100) ≈ A(A(A(A(...(A(100+2),100)...,100),100),100),100)

g^k(100) ≈ A(1,k,100)
g^k(4) < A(1,k,100) // in general
g^64(4) < A(1,64,100)

Il numero espresso nel programma sopra è A(0,1,2,3,4,...,123,124,125).

Poiché g^64(4)è il numero di Graham, e supponendo che la mia matematica sia corretta, allora è inferiore a A(1,64,100), il mio numero è significativamente più grande del numero di Graham.

Per favore, segnala eventuali errori nella mia matematica, anche se se non ce ne sono, questo dovrebbe essere il numero più grande calcolato finora per rispondere a questa domanda.

Perl - punteggio ≈ 10 ↑↑ 4.1

$_=$^Fx($]<<-$]),/(?<R>(((((((((((((((((((.(?&R))*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Ancora una volta abusando del motore regex di perl per macinare una quantità inimmaginabile di combinazioni, questa volta usando una discesa ricorsiva.

Nella maggior parte interiore dell'espressione, abbiamo una nuda .per prevenire la ricorsione infinita, e quindi limitando i livelli di ricorsione alla lunghezza della stringa.

Quello che finiremo con questo è:

/((((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*/
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                    .                                      \
                       .
                       .

... ripetuto 671088640 volte, per un totale di 12750684161 nidificazioni - il che rende abbastanza vergognoso il mio precedente tentativo di 23 nidificazioni. Sorprendentemente, perl non si soffoca nemmeno su questo (ancora una volta, l'utilizzo della memoria rimane stabile a circa 1,3 GB), anche se ci vorrà un po 'di tempo prima che venga rilasciata la prima dichiarazione di stampa.

Dalla mia precedente analisi di seguito, si può concludere che il numero di cifre in uscita sarà nell'ordine di (! 12750684161) ^671088640 , dove ! K è il Fattore di sinistra di k (vedi A003422 ). Possiamo approssimare questo come (k-1)! , che è strettamente più piccolo, ma sullo stesso ordine di grandezza.

E se chiediamo a wolframalpha :

... che a malapena cambia il mio punteggio. Ho pensato che sarebbe stato almeno 10 ↑↑ 5 . Immagino che la differenza tra 10 ↑↑ 4 e 10 ↑↑ 4.1 sia molto più grande di quanto pensi.

Perl - segna ≈ 10 ↑↑ 4

$_=$^Fx($]<<-$]),/((((((((((((((((((((((.*.*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Abusare del motore perge regex per fare un po 'di combinatoria per noi. Il codeblock incorporato
(??{print})inserirà il suo risultato direttamente nel regex. Dato che $_è composto interamente da 2s (e il risultato di printè sempre 1), questo non può mai eguagliare e invia il perl che gira attraverso tutte le possibili combinazioni, di cui ce ne sono parecchie.

Costanti utilizzate

• $^F- la massima gestione dei file di sistema, in genere 2.
• $]- il numero di versione perl, simile a 5.016002.

$_è quindi una stringa contenente la cifra 2ripetuta 671088640 volte. L'utilizzo della memoria è costante a circa 1,3 GB, l'output inizia immediatamente.

Analisi

Definiamo P _k (n) come il numero di volte in cui viene eseguita l'istruzione print, dove k è il numero di annidamenti e n è la lunghezza della stringa più uno (solo perché non ho voglia di scrivere n + 1 ovunque).

(.*.*)*
P ₂ (n) = [ 2, 8, 28, 96, 328, 1120, 3824, 13056, ... ]

((.*.*)*)*
P ₃ (n) = [ 3, 18, 123, 900, 6693, 49926, 372615, 2781192, ... ]

(((.*.*)*)*)*
P ₄ (n) = [ 4, 56, 1044, 20272, 394940, 7696008, 149970676, 2922453344, ... ]

((((.*.*)*)*)*)*
P ₅ (n) = [ 5, 250, 16695, 1126580, 76039585, 5132387790, 346417023515, 23381856413800, ... ]

(((((.*.*)*)*)*)*)*
P ₆ (n) = [ 6, 1452, 445698, 137050584, 42142941390, 12958920156996, ... ]

((((((.*.*)*)*)*)*)*)*
P ₇ (n) = [ 7, 10094, 17634981, 30817120348, 53852913389555, ... ]

ecc. In generale, la formula può essere generalizzata come segue:

dove

Cioè, il Factorial sinistro di k , ovvero la somma di tutti i fattoriali inferiore a k (vedere A003422 ).

Non sono stato in grado di determinare forme chiuse per D _k ed E _k , ma questo non importa troppo, se lo osserviamo

e

Con 23 annidamenti, questo ci dà un punteggio approssimativo di:

Questo dovrebbe essere quasi esatto, in realtà.

Ma per mettere questo in una notazione che è un po 'più facile da visualizzare, possiamo approssimare la base dell'esponente interno:

e poi l'esponente stesso:

e poi chiedi a wolframalpha :

che puoi anche chiamare 10 ↑↑ 4 e aver finito.

Javascript, 10 ↑↑↑↑ 210

100 caratteri:

z=~~Math.E+'';o={get f(){for(i=z;i--;)z+=i}};o.f;for(i=z;i--;)for(j=z;j--;)for(k=z;k--;)o.f;alert(z)

Sulla base dell'osservazione che l'iterazione massima fè il modo ottimale di procedere, ho sostituito le 13 chiamate a fcon 3 livelli di loop annidati che chiamano f, zvolte ciascuno (mentre fcontinua ad aumentare z).

Ho stimato il punteggio analiticamente su un pezzo di carta: lo scrivo se qualcuno è interessato a vederlo.

Punteggio migliorato: 10 ↑↑ 13

Javascript, in esattamente 100 caratteri, di nuovo:

z=~~Math.E+'';__defineGetter__('f',function(){for(i=z;i--;)z+=i});f;f;f;f;f;f;f;f;f;f;f;f;f;alert(z)

Ciò migliora la mia risposta originale in tre modi:

1. La definizione zdell'ambito globale ci evita di dover digitare o.zogni volta.

2. È possibile definire un getter sull'ambito globale (finestra) e digitare finvece di o.f.

3. Avere più iterazioni fvale più di iniziare con un numero maggiore, quindi invece di (Math.E+'').replace('.','')(= 2718281828459045, 27 caratteri), è meglio usare ~~Math.E+''(= 2, 11 caratteri) e usare i caratteri recuperati per chiamare fmolte più volte.

Poiché, come ulteriormente analizzato di seguito, ogni iterazione produce, da un numero nell'ordine di magnitudine M , un numero maggiore nell'ordine di magnitudine 10 ^M , questo codice produce dopo ogni iterazione

1. 210 ∼ O (10 ² )
2. O (10 ^{10 2} ) ∼ O (10 ↑↑ 2)
3. O (10 ^{10 ↑↑ 2} ) = O (10 ↑↑ 3)
4. O (10 ^{10 ↑↑ 3} ) = O (10 ↑↑ 4)
5. O (10 ^{10 ↑↑ 4} ) = O (10 ↑↑ 5)
6. O (10 ^{10 ↑↑ 5} ) = O (10 ↑↑ 6)
7. O (10 ^{10 ↑↑ 6} ) = O (10 ↑↑ 7)
8. O (10 ^{10 ↑↑ 7} ) = O (10 ↑↑ 8)
9. O (10 ^{10 ↑↑ 8} ) = O (10 ↑↑ 9)
10. O (10 ^{10 ↑↑ 9} ) = O (10 ↑↑ 10)
11. O (10 ^{10 ↑↑ 10} ) = O (10 ↑↑ 11)
12. O (10 ^{10 ↑↑ 11} ) = O (10 ↑↑ 12)
13. O (10 ^{10 ↑↑ 12} ) = O (10 ↑↑ 13)

Punteggio: ∼10 ^{10 10 10 10 16} ≈ 10 ↑↑ 6.080669764

Javascript, in esattamente 100 caratteri:

o={'z':(Math.E+'').replace('.',''),get f(){i=o.z;while(i--){o.z+=i}}};o.f;o.f;o.f;o.f;o.f;alert(o.z)

Ciascuno o.finvoca il ciclo while, per un totale di 5 loop. Dopo solo la prima iterazione, il punteggio è già superiore a 10 ^{42381398144233621} . Con la seconda iterazione, Mathematica non è stata in grado di calcolare anche il numero di cifre nel risultato.

Ecco una procedura dettagliata del codice:

Dentro

Inizia con 2718281828459045 rimuovendo il punto decimale da Math.E.

Iterazione 1

Concatena la sequenza decrescente di numeri,

• 2718281828459045
• 2718281828459044
• 2718281828459043
• ...
• 3
• 2
• 1
• 0

per formare un nuovo numero (gigantesco),

• 271828182845904527182818284590442718281828459043 ... 9876543210.

Quante cifre ci sono in questo numero? Bene, è la concatenazione di

• 1718281828459046 numeri di 16 cifre
• 900000000000000 numeri a 15 cifre
• 90000000000000 numeri a 14 cifre,
• 9000000000000 numeri di 13 cifre
• ...
• 900 numeri a 3 cifre
• 90 numeri a 2 cifre
• 10 numeri a 1 cifra

In Mathematica,

In[1]:= 1718281828459046*16+Sum[9*10^i*(i+1),{i,-1,14}]+1
Out[1]= 42381398144233626

In altre parole, è 2.72⋅10 ^{42381398144233625} .

Facendo il mio punteggio, dopo solo la prima iterazione, 2.72⋅10 ^{42381398144233619} .

Iterazione 2

Ma questo è solo l'inizio. Ora, ripeti i passaggi, iniziando con il numero gigantesco ! Cioè concatena la sequenza decrescente di numeri,

• 271828182845904527182818284590442718281828459043 ... 9876543210
• 271828182845904527182818284590442718281828459043 ... 9.876.543,209 mila
• 271828182845904527182818284590442718281828459043 ... 9.876.543,208 mila
• ...
• 3
• 2
• 1
• 0

Allora, qual è il mio nuovo punteggio, Mathematica?

In[2]:= 1.718281828459046*10^42381398144233624*42381398144233625 + Sum[9*10^i*(i + 1), {i, -1, 42381398144233623}] + 1

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

Out[2]= Overflow[]

Iterazione 3

Ripetere.

Iterazione 4

Ripetere.

Iterazione 5

Ripetere.

Punteggio analitico

Nella prima iterazione, abbiamo calcolato il numero di cifre nella concatenazione della sequenza decrescente a partire da 2718281828459045, contando il numero di cifre in

• 1718281828459046 numeri di 16 cifre
• 900000000000000 numeri a 15 cifre
• 90000000000000 numeri a 14 cifre,
• 9000000000000 numeri di 13 cifre
• ...
• 900 numeri a 3 cifre
• 90 numeri a 2 cifre
• 10 numeri a 1 cifra

Questa somma può essere rappresentata dalla formula,

dove Z indica il numero iniziale ( ad es. 2718281828459045) e O _Z indica il suo ordine di grandezza ( ad es. 15, poiché Z ∼ 10 ¹⁵ ). Utilizzando equivalenze per somme finite , quanto sopra può essere espresso esplicitamente come

che, se prendiamo 9 ≈ 10, si riduce ulteriormente a

e, infine, espandendo i termini e ordinandoli in ordine decrescente di grandezza, otteniamo

Ora, poiché siamo interessati solo all'ordine di grandezza del risultato, sostituiamo Z con "un numero nell'ordine di grandezza di O _Z ", cioè 10 ^{O _Z} -

Infine, il 2 ° e il 3 ° termine si annullano e gli ultimi due termini possono essere eliminati (la loro dimensione è banale), lasciandoci con

da cui vince il primo mandato.

Riaffermato, fprende un numero nell'ordine di grandezza di M e produce un numero approssimativamente nell'ordine di grandezza di M (10 ^M ).

La prima iterazione può essere facilmente verificata a mano. 2718281828459045 è un numero nell'ordine di grandezza di 15, pertanto fdovrebbe produrre un numero nell'ordine di grandezza di 15 (10 ¹⁵ ) ∼ 10 ¹⁶ . In effetti, il numero prodotto è, da prima, 2,72-10 ^{42381398144233625,} cioè 10 ^{42381398144233625} ∼ 10 ^{10 16} .

Notando che M non è un fattore significativo in M (10 ^M ), l'ordine di grandezza del risultato di ciascuna iterazione, quindi, segue un semplice modello di tetrazione:

1. 10 ¹⁶
2. 10 ^{10 16}
3. 10 ^{10 10 16}
4. 10 ^{10 10 10 16}
5. 10 ^{10 10 10 10 16}

Fonti LaTeX

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\sum_{k=0}^{\mathcal{O}_Z-1}{(9\cdot10^k(k+1))}+1

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\frac{10-\mathcal{O}_Z10^{\mathcal{O}_Z}+(\mathcal{O}_Z-1)10^{\mathcal{O}_Z+1}}{9}+10^{\mathcal{O}_Z}

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+1

Z\mathcal{O}_Z+Z-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}+10^{\mathcal{O}_Z}-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}

APL, 10 ↑↑ 3.4

Ecco il mio tentativo rivisto:

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

100 char / byte *, in esecuzione sull'hardware corrente (utilizza una quantità trascurabile di memoria e normali variabili int a 32 bit) anche se richiederà molto tempo per il completamento.

Puoi effettivamente eseguirlo su un interprete APL e inizierà a stampare cifre. Se consentito per completare, avrà stampato un numero con 10 × 123456789 ⁴⁴ cifre.

Quindi il punteggio è 10 ^{10 × 123456789 44} /100 ³ ≈ 10 ^{10 353} ≈ 10 ↑↑ 3,406,161 mila

Spiegazione

• ⎕D è una stringa costante predefinita uguale a '0123456789'
• n←⍎⎕Ddefinisce n come il numero rappresentato da quella stringa: 123456789 (che è <2 ³¹ e quindi può essere usato come variabile di controllo del ciclo)
• {⍞←⎕D} stamperà le 10 cifre sull'output standard, senza una nuova riga
• {⍞←⎕D}⍣nlo farà n volte ( ⍣è il "power operator": non è né *, /, né ^, perché non è un'operazione matematica, è una specie di loop)
• {⍞←n}⍣n⍣nripeterà l'operazione precedente n volte, quindi stampa le 10 cifre n ² volte
• {⍞←n}⍣n⍣n⍣nlo farà n ³ volte
• Potrei inserirne 44 ⍣n, quindi stampa n ⁴⁴ volte la stringa '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: APL può essere scritto nel proprio set di caratteri a byte singolo (legacy) che associa i simboli APL ai valori superiori di 128 byte. Pertanto, ai fini del calcolo del punteggio, un programma di N caratteri che utilizza solo caratteri ASCII e simboli APL può essere considerato lungo N byte.}

Punteggio Haskell: (2 ^{2 2 65536-3} ) / 1000000 ≈ 2 ↑↑ 7 ≈ 10 ↑↑ 4.6329710779

o=round$sin pi
i=succ o
q=i+i+i+i
m!n|m==o=n+i
 |n==o=(m-i)!i
 |True=(m-i)!(m!(n-i))
main=print$q!q

Questo programma contiene esattamente 100 byte di puro codice Haskell. Stamperà il quarto numero di Ackermann, consumando infine tutta l'energia, la materia e il tempo disponibili dell'Universo e oltre nel processo ( superando quindi leggermente il limite morbido di 5 secondi).

Python, 2 ↑↑ 11/830584 ≈ 10 ↑↑ 8.632971 (notazione con freccia in alto)

print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))

Probabilmente nessun computer ha memoria sufficiente per eseguire correttamente questo, ma non è proprio colpa del programma. Con i requisiti minimi di sistema soddisfatti, funziona.

Sì, questo sta spostando i bit su valori booleani. Trueviene costretto 1in questo contesto. Python ha numeri interi di lunghezza arbitraria.

GolfScript 3.673e + 374

'~'(.`*

Penso che *sia consentito poiché indica la ripetizione di stringhe, non la moltiplicazione.

Spiegazione: '~'(lascerà 126 (il valore ASCII di "~") nello stack. Quindi copia il numero, convertilo in una stringa ed esegui la ripetizione della stringa 126 volte. Questo dà 126126126126...che è approssimativamente 1.26 e+377. La soluzione è di 7 caratteri, quindi dividi per 7^3, per un punteggio di circa3.673e+374

Rubino, probabilisticamente infinito, 54 caratteri

x='a'.ord
x+=x while x.times.map(&:rand).uniq[x/x]
p x

x è inizializzato su 97. Quindi ripetiamo la seguente procedura: Genera x numeri casuali tra 0 e 1. Se sono tutti uguali, quindi termina e stampa x. Altrimenti, raddoppia x e ripeti. Poiché i numeri casuali di Ruby hanno 17 cifre di precisione, le probabilità di terminare in qualsiasi fase sono 1 in (10e17) ^ x. La probabilità di terminare entro n passaggi è quindi la somma di x = 1 a n di (1 / 10e17) ^ (2 ^ n), che converge in 1 / 10e34. Ciò significa che per qualsiasi numero, non importa quanto sia grande, è estremamente improbabile che questo programma generi un numero inferiore.

Ora, naturalmente, la domanda filosofica è se un programma che ha meno di una possibilità su 1 ^ 10 ^ 34 di terminare con il passaggio n per qualsiasi n possa mai terminare. Se assumiamo non solo tempo e potenza infiniti, ma che al programma sia data la possibilità di funzionare a velocità crescente a una velocità che supera la velocità con cui diminuisce la probabilità di terminare, possiamo, credo, in effetti fare la probabilità di terminando entro il tempo t arbitrariamente vicino a 1.

GolfScript, ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126))))))))

Questo è spudoratamente adattato da un'altra risposta di @Howard e incorpora suggerimenti di @Peter Taylor.

[[[[[[[[[,:o;'~'(]{o:?~%{(.{[(]{:^o='oo',$o+o=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:f~]f]f]f]f]f]f]f]f

La mia comprensione di GolfScript è limitata, ma credo che gli *e gli ^operatori sopra lo siano non gli operatori aritmetici vietati dall'OP.

(Lo eliminerò felicemente se @Howard vuole presentare la sua versione, che sarebbe senza dubbio superiore a questa comunque.)

Questo programma calcola un numero approssimativamente di f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} ( f) ₀ (126))))) ))) - una ripetizione di nove volte di f _{ε 0} - dove f _{ε 0} è la funzione nella gerarchia in rapida crescita che cresce all'incirca allo stesso ritmo della funzione di Goodstein. (f _{ε 0}cresce così velocemente che i tassi di crescita della funzione n (k) di Friedman e delle frecce concatenate di k-fold di Conway sono praticamente insignificanti anche rispetto a un solo f non iterato f _{ε 0.} )

dc, 100 caratteri

[lnA A-=ilbA A-=jlaSalbB A--SbLndB A--SnSnlhxlhx]sh[LaLnLb1+sbq]si[LbLnLasbq]sjFsaFsbFFFFFFsnlhxclbp

Dato abbastanza tempo e memoria, questo calcolerà un numero intorno a 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15. Inizialmente avevo implementato la funzione di iperoperazione , ma per questa sfida avevo richiesto troppi caratteri, quindi ho rimosso le condizioni n = 2, b = 0e n >= 3, b = 0, trasformando la n = 1, b = 0condizione inn >= 1, b = 0 .

Gli unici operatori aritmetici utilizzati qui sono l'addizione e la sottrazione.

EDIT: come promesso nei commenti, ecco una ripartizione di ciò che fa questo codice:

[            # start "hyperoperation" macro
lnA A-=i     # if n == 0 call macro i
lbA A-=j     # if b == 0 call macro j
laSa         # push a onto a's stack
lbB A--Sb    # push b-1 onto b's stack
LndB A--SnSn # replace the top value on n with n-1, then push n onto n's stack
lhxlhx       # call macro h twice
]sh          # store this macro in h

[            # start "increment" macro (called when n=0, the operation beneath addition)
LaLnLb       # pop a, b, and n
F+sb         # replace the top value on b with b+15
q            # return
]si          # store this macro in i

[            # start "base case" macro (called when n>0 and b=0)
LbLnLa       # pop b, n, and a
sb           # replace the top value on b with a
q            # return
]sj          # store this macro in j

Fsa          # store F (15) in a
Fsb          # store F (15) in b
FFFFFFsn     # store FFFFFF "base 10" (150000+15000+1500+150+15=1666665) in n
lhx          # load and call macro h
lbp          # load and print b

Come notato, questo si discosta dalla funzione di iperoperazione in quanto i casi di base per la moltiplicazione e superiore vengono sostituiti con il caso di base per l'aggiunta. Questo codice si comporta come se a*0 = a^0 = a↑0 = a↑↑0 ... = a, invece di matematicamente corretto a*0 = 0ea^0 = a↑0 = a↑↑0 ... = 1 . Di conseguenza, calcola valori leggermente superiori a quelli che dovrebbero essere, ma non è un grosso problema poiché puntiamo a numeri più grandi. :)

EDIT: Ho appena notato che una cifra è scivolata nel codice per caso, nella macro che esegue incrementi per n=0. L'ho rimosso sostituendolo con 'F' (15), che ha l'effetto collaterale di ridimensionare ogni operazione di incremento di 15. Non sono sicuro di quanto influisca sul risultato finale, ma probabilmente è molto più grande ora.

Non hai più limiti di runtime? Va bene allora.

Il programma deve essere eseguibile su computer moderni?

Entrambe le soluzioni utilizzano una compilazione a 64 bit, quindi si longtratta di un numero intero a 64 bit.

C: maggiore di 10 ^{(2 64 -1) 2 64} , che è esso stesso maggiore di 10 ^{10 355393490465494856447} ≈ 10 ↑↑ 4.11820744

long z;void f(long n){long i=z;while(--i){if(n)f(n+~z);printf("%lu",~z);}}main(){f(~z);}

88 caratteri.

Per semplificare queste formule, userò t = 2^64-1 = 18446744073709551615.

mainchiamerà fcon un parametro di t, che ripeterà i ttempi, ogni volta stampando il valore te chiamando fcon un parametro di t-1.

Cifre totali stampate: 20 * t .

Ognuna di queste chiamate a fcon un parametro di t-1ripeterà i ttempi, stampando il valore te chiamando f con un parametro dit-2 .

Cifre totali stampate: 20 * (t + t*t)

Ho provato questo programma usando l'equivalente di numeri interi a 3 bit (ho impostato i = 8e ho avuto la chiamata principale f(7)). Colpì la dichiarazione di stampa 6725600 volte. Questo funziona7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7 quindi, credo che questo sia il conteggio finale per l'intero programma:

Cifre totali stampate: 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

Non sono sicuro di come calcolare (2 ⁶⁴ -1) ^{2 64} . Tale somma è inferiore a (2 ⁶⁴ ) ^{2 64} e ho bisogno di una potenza di due per fare questo calcolo. Pertanto, calcolerò (2 ⁶⁴ ) ^{2 64 -1} . È più piccolo del risultato reale, ma poiché è una potenza di due, posso convertirlo in una potenza di 10 per il confronto con altri risultati.

Qualcuno sa come eseguire quella somma, o come convertire (2 ⁶⁴ -1) ^{2 64} a 10 ⁿ ?

20 * 2 ^ 64 ^ (2 ^ 64-1)
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^ (64 * 18446744073709551615)
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
dividere quell'esponente per log base 2 di 10 per cambiare la base dell'esponente in potenze di 10.
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

Ma ricorda, questo è il numero di cifre stampate. Il valore dell'intero è 10 elevato a tale potenza, quindi 10 ^ 10 ^ 355393490465494856447

Questo programma avrà una profondità di stack di 2 ^ 64. Sono 2 ^ 72 byte di memoria solo per memorizzare i contatori di loop. Sono 4 miliardi di terabyte di contatori di loop. Per non parlare delle altre cose che sarebbero andate in pila per 2 ^ 64 livelli di ricorsione.

Modifica: corretta una coppia di errori di battitura e utilizzato un valore più preciso per log2 (10).

Modifica 2: Aspetta un secondo, ho un ciclo di cui printf è fuori. Risolviamolo. Inizializzazione aggiunta i.

Modifica 3: Dang it, ho rovinato la matematica con la modifica precedente. Fisso.

Questo funzionerà su computer moderni, anche se non finirà presto.

C: 10 ^ 10 ^ 136 ≈ 10 ↑↑ 3.329100567

#define w(q) while(++q)
long a,b,c,d,e,f,g,x;main(){w(a)w(b)w(c)w(d)w(e)w(f)w(g)printf("%lu",~x);}

98 personaggi.

Questo stamperà l'inverso bit a bit di zero, 2 ^ 64-1, una volta per ogni iterazione. 2 ^ 64-1 è un numero di 20 cifre.

Numero di cifre = 20 * (2^64-1)^7= 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187500

Arrotondando la lunghezza del programma a 100 caratteri, Punteggio = numero stampato / 1.000.000

Punteggio = 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187494

R - 49 41 caratteri di codice, 4.03624169270483442 * 10 ^ 5928 ≈ 10 ↑↑ 2.576681348

set.seed(T)
cat(abs(.Random.seed),sep="")

stamperà [riproducendo qui solo l'inizio]:

403624169270483442010614603558397222347416148937479386587122217348........

ECMAScript 6 - 10 ^ 3 ↑↑↑↑ 3/884736

(3 ↑↑↑↑ 3 è G (1) dove G (64) è il numero di Graham)

u=-~[v=+[]+[]]+[];v+=e=v+v+v;D=x=>x.substr(u);K=(n,b)=>b[u]?n?K(D(n),K(n,D(b))):b+b+b:e;u+K(v,e)

Uscita: 10 ^ 3 ↑↑↑↑ 3

suggerimenti:

Gè la funzione in cui G (64) è il numero di Graham. L'input è un numero intero. L'output è una stringa unaria scritta con 0. Rimossa per brevità.

Kè la funzione freccia in alto Knuth a ↑ ⁿ b dove a è implicitamente 3. L'input è n, una stringa unaria e b, una stringa unaria. L'output è una stringa unaria.

u è "1".

v è "0000" o G (0)

e è "000".

C

(Con scuse a Darren Stone)

long n,o,p,q,r;main(){while(--n){while(--o){while(--p){while(--q){while(--r){putchar('z'-'A');}}}}}}

n = 2 ^ 64 cifre (9 ...)

l = 100 caratteri di codice

punteggio ≈ 1e + 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936570 ≈ 10 ↑↑ 3.2974890744

[Punteggio = n ^ 5 / l ^ 3 = (10 ^ (2 ^ 320) -1) / (100 ^ 3) = (10 ^ 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576-1) / (10 ^ 6)]

Nota che merito di essere frustato senza pietà per questa risposta, ma non ho potuto resistere. Non consiglio di comportarmi come me su stackexchange, per ovvie ragioni. :-P

EDIT: Sarebbe ancora più difficile resistere alla tentazione di andare con qualcosa del genere

long n;main(){putchar('z'-'A');putchar('e');putchar('+');while(--n){putchar('z'-'A');}

... ma suppongo che una regola voluta ma non specificata fosse che l'intera serie di cifre che compongono il numero deve essere stampata.

Nuovo rubino: punteggio ~ f _{ω ^ω2 +1} (126 ² 2 ¹²⁶ )

dove f _α (n) è la gerarchia in rapida crescita.

n=?~.ord;H=->a{b,*c=a;eval"b ?H[b==$.?c:[b==~$.?n:b-(b<=>$.)]*n+c]:p(n+=n);"*n};eval"H[~n];".*n*n<<n

Provalo online!

La *nsono solo stringa e matrice moltiplicazione, quindi dovrebbe andare bene.

Codice non golfato:

n = 126
H =-> a {
    b, *c = a
    n.times{
        case b
        when nil
            puts(n += n)
        when 0
            H[c]
        when -1
            H[[n]*n+c]
        else
            H[[b.-b<=>0]*n+c]
        end
    }
}
(n*n<<n).times{H[~n]}

dove b.-b<=>0restituisce un numero intero 1più vicino 0di b.

Spiegazione:

Stampa nall'inizio di ogni chiamata di H.

H[[]]raddoppia n( nvolte), cioè n = n<<n.

H[[0,a,b,c,...,z]]chiamate H[[a,b,c,...,z]]( nvolte).

H[[k+1,a,b,c,...,z]]chiama H[[k]*n+[a,b,c,...,z]]( nvolte), dove [k]*n = [k,k,...,k].

H[[-1,a,b,c,...,z]]chiamate H[[n]*n+[a,b,c,...,z]]( nvolte).

H[[-(k+1),a,b,c,...,z]]chiamate H[[-k]*n+[a,b,c,...,z]]( nvolte).

H[k] = H[[k]].

Il mio programma si inizializza n = 126, quindi chiama H[-n-1]126 ² 2 ¹²⁶ volte.

Esempi:

H[[0]]chiamerà H[[]]quale si applica n = n<<n( nvolte).

H[[0,0]]chiamerà H[[0]]( nvolte).

H[[1]]chiamerà H[[0]*n]( nvolte).

H[[-1]]chiamerà H[[n]*n]( nvolte).

H[[-1,-1]]chiamerà H[[n]*n+[-1]]( nvolte).

H[[-3]]chiamerà H[[-2]*n]( nvolte).

Provalo online!

Vedi le revisioni per altre cose interessanti.

Haskell - La funzione di Ackermann applicata al suo risultato 20 volte - 99 caratteri

Questa è la migliore soluzione haskell che posso trovare sulla base della funzione ackermann - potresti notare alcune somiglianze con la soluzione di nm, l'i = round $ log pi è stato ispirato da lì e il resto è una coincidenza: D

i=round$log pi
n?m|m<i=n+i|n<i=i?(m-i)|True=(n-i)?m?(m-i)
a n=n?n
b=a.a.a.a
main=print$b$b$b$b$b$i

Esegue la funzione ackermann su se stesso 20 volte, a partire da una, essendo la sequenza

• 1,
• 3,
• 61,
• un (61,61),
• a (a (61,61), a (61,61)) --- lo chiameremo ₂ (61) o ₄ (1) ---
• a ₃ (61)
• ...
• un ₁₈ (61) o un ₂₀ (1). Penso che questo sia approssimativamente g ₁₈ (vedi sotto).

Per quanto riguarda la stima, Wikipedia dice:

a (m, n) = 2 ↑ ^m-2 (n + 3) - 3

Da questo possiamo vedere a3 (1) = a (61,61) = 2 ↑ ⁵⁹ 64 + 3, che è chiaramente maggiore di g1 = 3 ↑ ⁴ 3, a meno che il 3 all'inizio non sia molto più importante di quanto penso. Dopodiché, ogni livello fa quanto segue (scartando le costanti insignificanti in a _n ):

• g _n = 3 ↑ ^{g _n-1} 3
• a _n ~ = 2 ↑ ^{a _n-1} (a _n-1 )

Se questi sono approssimativamente equivalenti, allora un ₂₀ (1) ~ = g ₁₈ . Il termine finale in a _n (a _n-1 ) è di gran lunga maggiore di 3, quindi è potenzialmente superiore a g ₁₈ . Vedrò se riesco a capire se ciò aumenterebbe anche una singola iterazione e riferirà.

codice macchina x86 - 100 byte (assemblato come file MSDOS .com)

Nota: può piegare leggermente le regole

Questo programma produrrà 2 ^{(65536 * 8 + 32)} nove che porterebbero il punteggio a (10 ^{2 524320} -1) / 1000000

Come contatore questo programma utilizza l'intero stack (64 kB) più due registri a 16 bit

Codice assemblato:

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

Montaggio:

ORG 0x100

SECTION .TEXT
            mov bh, [b_ss]
            mov dx, ss
            mov [b_ss], dx
            mov [b_sp], sp
            mov ss, bx
            xor sp, sp
            mov bx, inthackdst
            inc bx
            mov ah, [inthacksrc]
            mov [bx], ah
            mov al, [nine]
            xor ah, ah
            inc ah
            inc ah
            inc ah
inthacksrc: adc ah, ah
            inc ah
            add ah, ah
            xor cx, cx
fillstack:  push cx
nine:       cmp sp, cx
            jnz fillstack
regloop:    xor dx, dx
dxloop:     xor cx, cx
cxloop:     xor bx, bx
inthackdst: int '?'
            inc cx
            jnz cxloop
            inc dx
            jnz dxloop
            pop cx
            inc cx
            jnz restack
popmore:    cmp sp, dx
            jz end
            pop cx
            inc cx
            jz popmore
restack:    push cx
            xor cx, cx
            cmp sp, dx
            jnz restack
            jmp regloop
end:        mov sp, [b_sp]
            mov ax, [b_ss]
            mov ss, ax
            ret

b_ss:       dw 'SX'
b_sp:       db 'X'

C

La dimensione del file è di 45 byte.

Il programma è:

main(){long d='~~~~~~~~';while(--d)printf("%ld",d);}

E il numero prodotto è maggiore di 10 ^ (10 ^ (10 ^ 1.305451600608433)).

Il file a cui ho reindirizzato std è attualmente di oltre 16 GB e continua a crescere.

Il programma terminerebbe in un lasso di tempo ragionevole se avessi un computer migliore.

Il mio punteggio è incomprensibile con virgola mobile a precisione doppia.

GNU Bash, 10 ^ 40964096² / 80 ^ 3 ≈ 10 ↑↑ 2.072820169

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C count=$C$C|tr \\$((C-C)) $SHLVL'

C = 4096 su qualsiasi sistema ragionevole. SHLVL è un piccolo numero intero positivo (di solito 1 o 2 a seconda che / bin / sh sia bash o meno).

Solo 64 bit UNIX:

Punteggio: ~ 10 ^ (40964096409640964096 * 40964096409640964096) / 88 ^ 3

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C$C$C$C count=$C$C$C$C$C|tr \\$((C-C)) $SHLVL'

C, 10 ^ 10 ^ 2485766 ≈ 10 ↑↑ 3.805871804

unsigned a['~'<<'\v'],l='~'<<'\v',i,z;main(){while(*a<~z)for(i=l;printf("%u",~z),i--&&!++a[i];);}

Creiamo un array di 258048 numeri interi senza segno. Non poteva essere un unsigned long perché questo rendeva il programma troppo lungo. Non sono firmati perché non voglio usare un comportamento indefinito, questo codice è C corretto (a parte la mancanza di ritorno da main ()) e verrà compilato ed eseguito su qualsiasi macchina normale, continuerà a funzionare per molto tempo però . Questa dimensione è la più grande che possiamo esprimere legalmente senza usare caratteri non ascii.

Passiamo attraverso l'array a partire dall'ultimo elemento. Stampiamo le cifre di 2^32-1, incrementiamo l'elemento e rilasciamo il ciclo se l'elemento non si è spostato a 0. In questo modo ripeteremo i (2^32 - 1)^254048 = 2^8257536tempi, stampando 10 cifre ogni volta.

Ecco un codice di esempio che mostra il principio in un intervallo di dati più limitato:

#include <stdio.h>
unsigned int a[3],l=3,i,f;

int
main(int argc, char *argc){
        while (*a<4) {
        for (i = l; i-- && (a[i] = (a[i] + 1) % 5) == 0;);
            for (f = 0; f < l; f++)
                printf("%lu ", a[f]);
            printf("\n");
        }
}

Il risultato è circa 10 ^ 10 ^ 2485766 diviso per un milione che è ancora circa 10 ^ 10 ^ 2485766.

Powershell (2.53e107976 / 72³ = 6.78e107970 ≈ 10 ↑↑ 1.701853371)

Questa operazione richiede molto più di 5 secondi per l'esecuzione.

-join(-split(gci \ -r -EA:SilentlyContinue|select Length))-replace"[^\d]"

Recupera e concatena la lunghezza in byte di ogni file sull'unità corrente. Regex elimina tutti i caratteri non numerici.

Python 3, punteggio = ack (126.126) / 100 ^ 3

g=len('"');i=ord('~');f=lambda m,n:(f(m-g,f(m,n-g))if n else f(m-g,g))if m else n+g
print(f(i,i))

La funzione f è la funzione ackermann, che ho abbastanza spazio per invocare.

Modifica: precedentemente "else n + 1", che violava le regole della sfida - complimenti a Simply Beautiful Art.

JavaScript 98 caratteri

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(m.E<<k<<k<<k<<m.E);i+=j)a+=k;alert(a)

genera 2.718e + 239622337 ≈ 10 ↑↑ 2.9232195202

Per un punteggio di poco più di 2.718e + 239622331 ≈ 10 ↑↑ 2.9232195197

che è il più grande che riesco a fare senza il crash del browser.

(console.log (a) mostrerà l'output completo)

Non eseguire questi:

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(k<<k<<k<<k<<k<<k<<k);i+=j)a+=k;alert(a)

produrrebbe 2.718 + e121333054704 ≈ 10 ↑↑ 3.0189898069 (aka 2.718 * 10 ^ (1.213 * 10 ^ 12) per confrontare con la risposta più lunga:

versione più estrema, se non ha bloccato il browser: (80 caratteri)

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<k;i+=j)a+=k;alert(a)

che creerebbe un numero della stessa dimensione di e * 10 ^ (10 ^ 19) ≈ 10 ↑↑ 3.106786869689

Modifica: la soluzione originale di codice aggiornata ha generato solo 2.718e + 464

Python 3: 98 caratteri, ≈ 10 ↑↑ 256

Utilizzando una funzione con argomento variabile:

E=lambda n,*C:E(*([~-n][:n]+[int("%d%d"%(k,k))for k in C]))if C else n;print(E(*range(ord('~'))))

In effetti, E decrementa il primo argomento mentre aumenta il resto degli argomenti, tranne che invece di inserire -1 negli argomenti lascia cadere l'argomento. Poiché ogni ciclo decrementa il primo argomento o diminuisce il numero di argomenti, questo è garantito per terminare. La funzione crescente utilizzata è int ("% d% d"% (k, k)), che fornisce un risultato tra k ** 2 + 2 * k e 10 * k ** 2 + k. Il mio codice utilizza il simbolo *, ma non come moltiplicazione. È usato per lavorare con un numero variabile di argomenti, che penso dovrebbero seguire le regole poiché il punto chiaro delle regole era limitare operazioni specifiche, non i simboli stessi.

Alcuni esempi di quanto grande E diventa rapidamente:

E(1,1) = 1111
E(0,1,1) = E(11,11) = (approx) 10^8191
E(1,1,1) = E(1111,1111) = (approx) 10^(10^335)
E(2,1,1) = E(11111111,11111111) = (approx) 10^(10^3344779)

Solo i primi due sono eseguibili sul mio computer in un ragionevole lasso di tempo.

Quindi, E viene invocato da E(*range(ord('~')))- che significa:

E(0,1,2,3,4,5, ... ,121,122,123,124,125)

Non sono del tutto sicuro di quanto sia grande (ho cercato di approssimarlo senza successo) - ma è ovvio che è ~ davvero ~ grande.

Ad esempio, circa dodici cicli in, il risultato è circa: (tecnicamente un po 'più di)

E(2**27211,2**27211,2**27212,2**27212,2**27212,2**27212,2**27213,2**27213,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636)

Stima del risultato:

Se ci avviciniamo al passaggio crescente lambda k: 10 * k**2, la funzione può essere descritta come

E(n, C₁, C₂, ... Cᵥ) ≈ E(10^(n²/2) ⋅ C₁²ⁿ, 10^(n²/2) ⋅ C₂²ⁿ, ... 10^(n²/2) ⋅ Cᵥ²ⁿ)
                     ≈ E(10^((10^(n²/2) ⋅ C₁²ⁿ)²/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )
                     ≈ E(10^((10^n² ⋅ C₁⁴ⁿ)/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )

La cosa rilevante che stiamo facendo qui è costruire una torre di poteri di dieci, quindi il punteggio finale può essere approssimato come 10 ↑↑ 256.

Migliore stima dei risultati (anche se parziale):

Questo utilizza lo stesso 10 * k**2dell'altra stima.

E(0, b) = 10 * b**2
E(1, b) = 10 * (10 * b**2)**2 = 10 * 100 * b**4 = 10**3 * b**4
E(2, b) = 10 * (10**3 * b**4)**2 = 10 * (10**6 * b**8) = 10**7 * b**8
E(a, b) = 10**(2**(a+1)-1) * b**(2**(a+1))

Secondo la stima precedente, sarebbe:

E(a, b) = 10**(a**2/a) * b**(2*a)

Che è significativamente più piccolo del valore reale poiché usa a**2invece di 2**aper 10 e usa a*2invece di 2**aper b.

C (punteggio ≈ 10 ^ 20.000.000.000 ≈ 10 ↑↑ 3.005558275)

• ~ 20 GB di output
• 41 caratteri (41 ^ 3 non significa nulla)

main(){for(;rand();printf("%d",rand()));}

Nonostante rand()l'output sia deterministico perché non esiste una funzione seed.