Se un programma termina e non c'è nessuno che lo veda, si ferma?


99

È tempo di affrontare la verità: non saremo qui per sempre, ma almeno possiamo scrivere un programma che sopravviverà alla razza umana anche se lotta fino alla fine dei tempi.

Il tuo compito è scrivere un programma che abbia un tempo di esecuzione previsto superiore al tempo rimanente fino alla fine dell'universo.

Puoi presumere che:

  • L'universo morirà di entropia in 10 1000 anni.
  • Il tuo computer:
    • Sopravviverà all'universo, perché è fatto di Unobtainium .
    • Ha un limite infinito di memoria / stack / ricorsione.
    • Il suo processore ha una velocità limitata.

Devi mostrare che il tuo programma termina (scusami, nessun loop infinito) e calcolare il tempo di esecuzione previsto.

Si applicano le scappatoie standard .

Questa è una sfida del codice golf, quindi vince il codice più breve che soddisfa i criteri.

MODIFICA :

Sfortunatamente, è stato scoperto (30 minuti dopo) che il campo di improbabilità di Unobtainium interferisce con l'orologio interno del computer, rendendolo inutile. Quindi i programmi basati sul tempo si fermano immediatamente. (Chi lascerebbe comunque un programma che aspetta solo la sua eredità vivente?).

Il processore del computer è simile all'Intel i7-4578U, quindi un modo per misurare il tempo di esecuzione è eseguire il programma su un computer simile con un input più piccolo (spero) ed estrapolarne il tempo di esecuzione.


Podio

#CharsLanguageUpvotes        Author        
1    5      CJam              20       Dennis                  
2    5      J                      5         algorithmshark      
3    7      GolfScript       30       Peter Taylor          
4    9     Python             39       xnor                      
5    10   Matlab             5         SchighSchagh      

* Voti positivi al 31/08


40
Sono stato tentato di creare un tag [codice più lento] per questa domanda. : P
Maniglia della porta

5
Un Bogosort non funzionerebbe perché mentre è infinitamente improbabile che non finisca mai, potrebbe richiedere un tempo infinito per terminare. Vi sono, tuttavia, molte terribili espressioni regolari basate su NFA che potrebbero soddisfare i criteri "finiranno, ma non prima che l'universo sia morto".
DavidO

49
Il tuo titolo dovrebbe essere una maglietta
user-2147482637

4
Bella domanda, ma non dovrebbe essere contest di popolarità?
IazertyuiopI

Risposte:


34

CJam, 5 byte

0{)}h

Come funziona

 0   " Push 0.                                 ";
 {   "                                         ";
   ) " Increment the Big Integer on the stack. ";
 }h  " Repeat if the value is non-zero.        ";

Questo programma si interromperà quando l'heap non sarà più in grado di memorizzare il Big Integer, cosa che non accadrà presto in un moderno computer desktop.

La dimensione heap predefinita è 4.179.623.936 byte sul mio computer (Java 8 su Fedora). Può essere aumentato a un valore arbitrario con -Xmx, quindi l'unico limite reale è la memoria principale disponibile.

Tempo della morte

Supponendo che l'interprete abbia bisogno di x bit di memoria per memorizzare un intero intero non negativo inferiore a 2 x , dobbiamo contare fino a 2 8 × 4.179.623.936 = 2 33.436.991.488 . Con un incremento per ciclo di clock e il mio Core i7-3770 (3,9 GHz con turbo), questo richiederà 2 33.436.991.488 ÷ 3.400.000.000> 10 10.065.537.393 secondi, che è superiore a 10 10.065.537.385 anni.


14
Non credo che tu possa fare affidamento su risorse limitate, come afferma la domanda "Il tuo computer ha un limite infinito di memoria / stack / ricorsione".
Greg Hewgill,

4
Memoria !=infinita tipi di dati infiniti. Se ho un terabyte di RAM, un numero intero a 8 bit senza segno arriva comunque a 255.
wchargin

6
@GregHewgill: con risorse illimitate, puoi aumentare la dimensione massima dell'heap Java a qualsiasi valore arbitrario, ma sarà sempre finito.
Dennis,

2
@Dennis, ma poi aggiungi una riga ogni volta attraverso il ciclo per raddoppiare la dimensione dell'heap. È una cosa divertente sugli infiniti :-)
Carl Witthoft,

9
@CarlWitthoft: non puoi farlo dall'interno del programma.
Dennis,

62

JavaScript, 39

(function f(x){for(;x!=++x;)f(x+1)})(0)

Spiegazione

Poiché JavaScript non rappresenta con precisione numeri interi grandi, il ciclo for(;x!=++x;)termina una volta xcolpito 9007199254740992.

Il corpo del ciclo for verrà eseguito Fib(9007199254740992) - 1volte, dove si Fib(n)trova l'ennesimo numero di fibonacci.

Dai test, so che il mio computer eseguirà meno di 150.000 iterazioni al secondo. In realtà, sarebbe molto più lento perché lo stack sarebbe diventato molto grande.

Pertanto, l' (Fib(9007199254740992) - 1) / 150000esecuzione del programma richiederà almeno secondi. Non sono stato in grado di calcolare Fib(9007199254740992)perché è così grande, ma so che è molto più grande di 10 1000 * 150.000.

EDIT: come notato nei commenti, Fib(9007199254740992)è circa 4.4092 * 10 1882393317509686 , che è effettivamente abbastanza grande.


9
Dato che fib(n)può essere approssimato da phi^n, possiamo usare log((sqrt(5) + 1)/2)*9007199254740992per calcolare quante cifre fib(9007199254740992)si scopre che si tratta 1.8823933*10^15.
overactor

11
@overactor, Secondo Wolfram Alpha, Fib(9007199254740992)(usando la forma continua con phi) è approssimativamente 4.4092... * 10^1882393317509686. Calcolo
Brian S

1
lo stack crescente non riduce la velocità della CPU ... a meno che non si tenga conto della larghezza della riga dell'indirizzo di memoria limitata / larghezza dell'indirizzo illimitata (nel qual caso il rallentamento è ancora lineare nella lunghezza dell'indirizzo presupponendo una codifica ragionevole) o persino i limiti fisici nella memoria e la velocità della luce (nel qual caso il rallentamento è cbrico nel valore dell'indirizzo assumendo la memorizzazione spaziale; anche i livelli di DNA della densità dei dati alla fine iniziano a sommarsi, anche se gestisci un accesso casuale efficiente nello spazio)
John Dvorak,

1
@JamesKhoury No, la funzione che hai appena scritto è equivalente for(x=0;x!=++x;)e itera solo 9007199254740992 volte.
Peter Olson,

4
@SylvainLeroux un'architettura con infinite quantità di RAM probabilmente avrebbe semplicemente interlacciato l'heap e lo stack e li avrebbe fatti crescere entrambi verso l'alto.
John Dvorak,

47

Python (9)

9**9**1e9

Questo ha più di 10 ** 10000000 bit, quindi il calcolo dovrebbe portarci lontano dalla morte per calore.

Ho verificato che questo richiede sempre più tempo per valori più grandi ma comunque ragionevoli, quindi non è solo ottimizzato dall'interprete.

Modifica: golfato due caratteri rimuovendo le parentesi grazie a @ user2357112. TIL che Python tratta gli esponenti successivi come una torre di potere.


4
OverflowError: (34, 'Result too large')
apple16

93
@ apple16 Forse sul tuo computer, ma il mio ha un "limite infinito di memoria / stack / ricorsione".
xnor

64
Va bene ragazzi. L'ho eseguito nell'ultimo universo e ho ottenuto ...82528057365719799011536835265979955007740933949599830498796942400000000009(2.6 * 10 ^ 954242509 cifre omesse per evitare il collasso del buco nero ). Dovresti davvero aggiornare a Unobtanium.
xnor

10
L'esponenziazione è associativa corretta, quindi puoi lasciare le parentesi.
user2357112,

10
Vale la pena notare che 9**9**9e9è altrettanto breve e richiede un po 'più di lunghezze universali per calcolare, oltre a sembrare un po' più bello.
abarnert,

35

GolfScript ( 12 7 caratteri)

9,{\?}*

Questo calcola e stampa 8 ^ 7 ^ 6 ^ 5 ^ 4 ^ 3 ^ 2 ~ = 10 ^ 10 ^ 10 ^ 10 ^ 183230. Per stamparlo (non importa il calcolo) in 10 ^ 1000 anni ~ = 10 ^ 1007,5 secondi, deve stampare circa 10 ^ (10 ^ 10 ^ 10 ^ 183230 - 10 ^ 3) cifre al secondo.


22
Ma si fermerà molto prima con un messaggio "stampante fuori carta" ...
Floris,

1
@Floris chi diavolo usa i media fisici in questi giorni?
John Dvorak,

3
@ JanDvorak, ho appena ipotizzato che Floris e le 7 persone che lo hanno votato siano della generazione di mio nonno, quando tutta la produzione era destinata all'alimentazione continua.
Peter Taylor,

2
@PeterTaylor - forse non è così vecchio, ma io sono abbastanza vecchio da ricordare di aver inviato "lavori batch" al "computer" (nei giorni in cui non c'erano dubbi, in una popolazione studentesca di 20k, quale computer intendevi), e raccolta della stampa il giorno seguente. Tu (e altri 7) avete correttamente ipotizzato che si trattasse di un tentativo di umorismo, non di una critica seria alla vostra sceneggiatura eccellente e ridicolmente breve.
Floris,

35

Marbelous 68 66 byte

}0
--@2
@2/\=0MB
}0@1\/
&0/\>0!!
--
@1
00@0
--/\=0
\\@0&0

Marbelous è un linguaggio a 8 bit con valori rappresentati solo da biglie in una macchina simile a Rube Goldberg, quindi non è stato molto facile. Questo approccio è approssimativamente equivalente al seguente pseudo-codice:

function recursiveFunction(int i)
{
    for(int j = i*512; j > 0; j--)
    {
        recursiveFunction(i - 1);
    }
}

poiché il valore massimo è 256, (rappresentato da 0 nel programma Marbleous, che viene gestito in modo diverso in luoghi diversi) recursiveFunction (1) verrà chiamato un totale di 256!*512^256cui equivale 10^1200, abbastanza facilmente da sopravvivere all'universo.

Marbelous non ha un interprete molto veloce, sembra che possa eseguire 10^11chiamate di questa funzione all'anno, il che significa che stiamo guardando un periodo di tempo di 10^1189anni.

Ulteriore spiegazione della scheda Marbelous

00@0
--/\=0
\\@0&0

00è un linguaggio letterale (o un marmo), rappresentato in esadecimale (quindi 0). Questo marmo cade sul --, che diminuisce di 1 qualsiasi marmo (00 avvolge e si trasforma in FF o 255 in decimale). Il Marmo con ora il valore FF cade sulla \\quale lo spinge una colonna a destra, in basso @0. Questo è un portale e teletrasporta il marmo all'altro @0dispositivo. Lì, il marmo atterra sul /\dispositivo, che è un duplicatore, mette una copia del marmo --alla sua sinistra (questo marmo continuerà a scorrere tra i portali e si ridurrà su ogni anello) e uno =0alla sua destra.=0confronta il marmo con il valore zero e lascia cadere il marmo attraverso se è uguale e lo spinge a destra in caso contrario. Se il marmo ha il valore 0, atterra su &0un sincronizzatore, che spiegherò più avanti, più avanti.

Tutto sommato, questo inizia con un marmo di valore 0 in un ciclo e lo decrementa fino a raggiungere nuovamente 0, quindi inserisce questo marmo di valore 0 in un sincronizzatore e continua a ciclo allo stesso tempo.

}0@1
&0/\>0!!
--
@1

}0è un dispositivo di input, inizialmente l'ennesimo input (base 0) della riga di comando quando si chiama il programma viene inserito in ogni }ndispositivo. Quindi se si chiama questo programma con l'ingresso della riga di comando 2, un valore di marmo 02 sostituirà questo }0. Questo marmo quindi cade nel &0dispositivo, un altro sincronizzatore, i &nsincronizzatori trattengono i marmi fino a quando non &nvengono archiviati anche tutti gli altri corrispondenti . Il marmo viene quindi decrementato, teletrasportato e duplicato in modo molto simile al ciclo precedentemente spiegato. La copia giusta viene quindi verificata per la disuguaglianza con zero ( >0) se non è 0, passa attraverso. Se è 0, viene spinto a destra e atterra !!, il che termina la scheda.

Ok, finora abbiamo un loop che conta continuamente da 255 a 0 e consente a un altro loop simile (alimentato dall'input della riga di comando) di essere eseguito una volta ogni volta che colpisce 0. Quando questo secondo loop ha funzionato n volte (massimo 256 ) il programma termina. Quindi questo è un massimo di 65536 esecuzioni del ciclo. Non abbastanza per sopravvivere all'universo.

}0
--@2
@2/\=0MB

Questo dovrebbe iniziare a sembrare familiare, l'input viene decrementato una volta, quindi questo valore gira e viene copiato (nota che il marmo viene decrementato solo una volta, non ad ogni ciclo). Viene quindi verificato l'uguaglianza su 0 e se non è zero atterra MB. Questa è una funzione in Marbelous, ogni file può contenere più schede e ogni scheda è una funzione, ogni funzione deve essere nominata precedendo la griglia :[name]. Ogni funzione tranne la prima funzione nel file, che ha un nome standard: MB. Quindi questo loop chiama di nuovo continuamente la scheda madre con un valore in n - 1cui n è il valore con cui è stata chiamata questa istanza della funzione.

Allora perchè n*512?

Bene, il primo loop viene eseguito in 4 tick (e 256 volte) e il secondo loop viene eseguito n volte prima che la scheda termini. Ciò significa che la scheda funziona per circa le n*4*256zecche. L'ultimo loop (che esegue la chiamata ricorsiva della funzione) è composto e viene eseguito in 2 tick, il che significa che riesce a chiamare i n*4*256/2 = n*512tempi della funzione .

Quali sono i simboli che non hai menzionato?

\/ è un cestino, che rimuove i marmi dalla scheda, questo fa sì che i marmi scartati non interferiscano con altri marmi che si ripetono in un round e impediscono al programma di terminare.

indennità

Poiché i marmi che cadono dalla parte inferiore di una tavola marbel vengono inviati a STDOUT, questo programma stampa una pletora di caratteri ASCII mentre è in esecuzione.


2
Grande spiegazione, grazie!
Decadimento beta

2
Caspita, questa è un'idea geniale! La lingua Marbelous è così divertente!
rubik,

2
+1 Proprio quello che volevo vedere. Un linguaggio più folle di BrainFuck :) Esiste un sito Web con tutorial e maggiori informazioni a riguardo? (Il link del titolo sembra avere meno documenti della tua risposta)
Sylwester,

2
@Sylwester, sono contento che ti piaccia, Marbelous è attualmente ancora in fase di sviluppo ma ci aspettiamo di averlo in una condizione più stabile nel prossimo futuro, a quel punto tutorial, documentazione più ampia, librerie standard e speriamo che un interprete online lo farà Seguire.
overactor

21

Perl, 66 58 caratteri

sub A{($m,$n)=@_;$m?A($m-1,$n?A($m,$n-1):1):$n+1;}A(9,9);

Quanto sopra è un'implementazione della funzione Ackermann – Péter . Non ho idea di quanto sia grande A (9,9), ma sono abbastanza sicuro che ci vorrà un tempo sorprendentemente lungo per valutare.


5
+1 ... Stavo cercando di trovare una lingua con la funzione Ackermann integrata, ma non ci sono riuscito prima che la mia pazienza si esaurisse. : D
Martin Ender,

3
$n?A($m-1,A($m,$n-1)):A($m-1,1)ammette un facile risparmio di 8 caratteri premendo l'operatore ternario.
Peter Taylor,

3
Sono abbastanza sicuro che il numero di cifre in A (9,9) sia maggiore del volume dell'universo osservabile misurato in lunghezze cubiche di Planck.
Kasperd,

6
@kasperd È un eufemismo piuttosto massiccio. Il volume dell'universo osservabile è solo dell'ordine di 10 ^ 184 volumi planck. In confronto, ci sono qualcosa come 10 ^ 19700 cifre nel numero che descrive il numero di cifre in A (4,4), che a sua volta è incomprensibilmente minuscolo rispetto ad A (9,9).
user19057,

3
@ user19057 Sembra che chiamare l'affermazione di Kasperd un "eufemismo massiccio" sia un eufemismo enorme. : P
Nicu Stiurca,

20

MATLAB, 58 52 caratteri

Abbiamo bisogno di almeno una soluzione aritmetica di precisione finita, quindi:

y=ones(1,999);while y*y',y=mod(y+1,primes(7910));end

x = uni (1.999); y = x; mentre qualsiasi (y), y = mod (y + x, primi (7910)); fine

( grazie a @DennisJaheruddin per aver eliminato 6 caratteri )

Il numero di cicli necessari per il completamento è dato dal prodotto dei primi 999 numeri primi. Poiché la stragrande maggioranza di questi sono ben oltre i 10, il tempo necessario per realizzare la convergenza sarebbe di centinaia o migliaia di ordini di grandezza superiori al limite di tempo minimo.


+1 Mi ci è voluto un po 'per vedere cosa stai facendo lì. Bello!
Punto fisso

+1 CRT, vero?
Flawr,

Bene, penso che alcuni caratteri possano essere salvati in questo modo: y = uni (1.999); mentre y * y ', y = mod (y + 1, primes (7910)); fine
Dennis Jaheruddin

@DennisJaheruddin: accorciamento brillante. Aggiornerò.
COTO

Sebbene non sia più la stessa soluzione, dovrebbe essere comunque abbastanza simile, e ancora un po 'più breve:p=1:9e9;y=p;while+y*y',y=mod(y+1,p),end
Dennis Jaheruddin,

19

Mathematica, 25 19 byte

Questa soluzione è stata pubblicata prima che le funzioni temporali fossero squalificate.

While[TimeUsed[]<10^10^5]

TimeUsed[]restituisce i secondi dall'inizio della sessione e Mathematica utilizza tipi di precisione arbitraria. Ci sono circa 10 7 secondi in un anno, quindi attendere 10 10000 secondi dovrebbe essere sufficiente.

Alternativa più breve / semplice (/ valida):

For[i=0,++i<9^9^9,]

Contiamo invece e basta. Dovremo contare un po 'di più, perché possiamo fare molti incrementi in un secondo, ma il limite più alto in realtà non costa i caratteri.

Tecnicamente, in entrambe le soluzioni, potrei usare un limite molto più basso perché il problema non specifica una velocità minima del processore.


Lo adoro! Questa risposta mi ha fatto davvero ridere ad alta voce con un grande sorriso sul mio viso.
Todd Lehman,

1
Mi dispiace, per motivi di creatività, ho dovuto ritagliare soluzioni basate sul tempo (come la tua prima). Per favore, non odiarmi. :)
kb_sou,

5
@kbsou Beh, l'ho battuto con l'altro, quindi non mi interessa davvero. Ma altrimenti squalificare le risposte in modo retrospettivo per i cambiamenti delle regole non è bello però. ;)
Martin Ender,

1
Mathematica è davvero così lento, che l'elaborazione 9^9^9richiede più di 10^1000anni? 9^9^9Stimo che il calcolo sul mio U7300 da 1,3 GHz impiegherebbe bcmeno di 6 mesi. (Basato sull'estrapolazione del tempo di calcolo 9^200000e 9^400000.)
Kasperd,

2
@ArtOfCode Mathematica utilizza tipi di precisione arbitraria, quindi proverà effettivamente a determinare il valore corretto.
Martin Ender,

16

Python 3 - 49

Questo fa qualcosa di utile: calcola Pi con una precisione senza precedenti usando la serie infinita Gregory-Leibniz.

Nel caso ve lo stiate chiedendo, questo programma fa girare i 10**10**10**2.004302604952323tempi.

sum([4/(i*2+1)*-1**i for i in range(1e99**1e99)])

Precisione arbitraria: 78

from decimal import*
sum([Decimal(4/(i*2+1)*-1**i)for i in range(1e99**1e99)])

Fonte immagine

Il respiro terminale

A causa degli enormi calcoli in corso, le 1e99**1e99iterazioni durano poco meno di 1e99**1e99anni. Ora, (1e99**1e99)-1e1000fa praticamente nessuna differenza. Ciò significa che questo programma durerà molto più a lungo della morte del nostro universo.

Rinascita

Ora, gli scienziati propongono che in 10**10**56 years, l'universo rinascerà a causa di fluttuazioni quantistiche o tunnel. Quindi, se ogni universo è esattamente lo stesso, in quanti universi vivrà il mio programma?

(1e99**1e99)/(1e10+1e1000+10**10**56)=1e9701

Supponendo che l'universo vivrà sempre 1e10+1e1000anni e poi impiegheranno 10**10**56anni per "riavviare", il mio programma vivrà attraverso 1e9701universi. Ciò presuppone, ovviamente, che l'obubbio possa vivere attraverso il Big Bang.


3
termina quando raggiunge la fine dell'intervallo @Philipp. sì, alla fine termina.
Malachi,

1
1000**1000è 1e3000, non è 1e2000.
Cornstalks,

1
@Cornstalks Grazie, non avevo una calcolatrice abbastanza buona per trovarlo, quindi ho fatto un'ipotesi sulla base del fatto 100**100=1E200.
Decadimento beta

1
@BetaDecay: potrei suggerire Wolfram | Alpha come calcolatrice online . Se non l'hai mai usato, è davvero fantastico!
Cornstalks,

2
@anyoneinterested O 1000 ^ 1000 = (10 ^ 3) ^ 1000 = (10 * 10 * 10) * (10 * 10 * 10) * ... * (10 * 10 * 10) [1000 volte] = 10 ^ 3000
IazertyuiopI

12

Python 59 (funziona la maggior parte del tempo)

Non ho resistito

from random import*
while sum(random()for i in range(99)):0

Sebbene sia vero che ciò potrebbe teoricamente terminare in meno di un millisecondo, l'autonomia media è ben oltre il 10^400tempo specificato per la durata di vita dell'universo. Grazie a @BetaDecay, @undergroundmonorail e @DaboRoss per averlo ridotto di circa 17 caratteri.


Per arrivare a 71 puoi sostituirlo continueconpass
Beta Decay

@BetaDecay Nice catch
KSab

3
Penso che dal momento che la domanda richiede il tempo di esecuzione previsto , non è un problema che questo possa terminare presto. Il problema più grande è che non si può dimostrare che si risolva affatto.
user19057,

4
@ user19057 Supponendo ciò che ha detto KSab, il tempo di esecuzione previsto è finito e il programma termina con una probabilità del 100%. Ovviamente il modulo casuale utilizza effettivamente un PRNG, che è ciclico, quindi molto probabilmente questo non terminerà mai.
Jerome Baum,

1
Penso che puoi tagliare 3 caratteri sostituendo 'pass' con '0'.
daboross,

8

J - 5 caratteri, penso

Si noti che tutto quanto segue è in aritmetica di precisione arbitraria, perché il numero 9 ha sempre un po ' xaccanto.

In sette personaggi, abbiamo !^:!!9x, che è un po 'come correre

n = 9!
for i in range(n!):
    n = n!

in arbitraria precisione aritmetica. Questo è decisamente oltre il limite perché Synthetica lo ha detto , quindi abbiamo un limite superiore.

In sei caratteri, possiamo anche scrivere ^/i.9x, che calcola ogni risultato intermedio di 0 ^ 1 ^ 2 ^ 3 ^ 4 ^ 5 ^ 6 ^ 7 ^ 8. Wolfram | Alpha dice che 2^3^4^5^6^7^8è approssimativamente 10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 6.65185, il che probabilmente cancella anche l'ispezione.

Abbiamo anche i cinque caratteri !!!9x, che è solo ((9!)!) !. W | A dice che è 10 ^ 10 ^ 10 ^ 6.2695, che dovrebbe essere ancora abbastanza grande ... È come1.6097e1859933 cifre -ish, che è decisamente più grande di 3.154e1016, il numero di nanosecondi nell'universo, ma ammetterò che non ho idea di come si possa capire i veri runtime di queste cose.

La sola stampa dovrebbe richiedere abbastanza tempo per durare più a lungo dell'universo, quindi dovrebbe andare bene.


7

C, 63 56 caratteri

f(x,y){return x?f(x-1,y?f(x,y-1):1):y+1;}main(){f(9,9);}

Questo si basa su un'idea di un ragazzo di nome Wilhelm. Il mio unico contributo è quello di condensare il codice in questo breve (e illeggibile) pezzo.

Dimostrare che termina è fatto per induzione.

  • Se x è 0, termina immediatamente.
  • Se termina per x-1 e qualsiasi y, termina anche per x, questo può essere mostrato per induzione.

Dimostrare la fase di induzione per induzione:

  • Se y è 0, c'è solo una chiamata ricorsiva con x-1, che termina per ipotesi di induzione.
  • Se f (x, y-1) termina, anche f (x, y) termina perché la chiamata più interna di f è esattamente f (x, y-1) e la chiamata più esterna termina secondo l'ipotesi di induzione.

Il tempo di esecuzione previsto è A (9,9) / 11837 secondi. Questo numero ha più cifre del numero di quark nell'universo osservabile.


(Ab) usa il preprocessore e definisci m = main, r = return e z = 99999, quindi riscrivi il tuo programma come, f (x, y) {rx? F (x-1, y? F (x, y- 1): 1): y + 1;} m () {f (z, z);} che richiederà un tempo incredibilmente lungo :-)
ChuckCottrill,

5
@ChuckCottrill Se le regole consentivano i programmi, che richiedono specifiche macro del preprocessore, e quelli non contavano per la lunghezza del programma, allora qualsiasi attività può essere risolta in un carattere.
Kasperd,

6

Matlab ( 10 8 caratteri)

1:9e1016

IMHO, la maggior parte delle voci si sta sforzando troppo calcolando cose grandi e complicate. Questo codice inizializzerà semplicemente un array di 9x10 1016 double secondi contando da 1, che richiede 7,2x10 ^ 1017 byte. Su una CPU moderna, con una larghezza di banda di memoria massima di 21 GB / s oppure 6.63x10 ^ 17 byte / anno , ci vorranno almeno 1.09x10 1000 anni per l'inizializzazione anche l'array, e tanto meno provare a stamparlo in quanto non mi sono preoccupato sopprimendo l'output con un punto e virgola finale. (;


vecchie soluzioni

nan(3e508)

In alternativa

inf(3e508)

Questo codice creerà semplicemente una matrice quadrata di NaNinfiniti di dimensioni 3e508x 3e508 = 9e1016doppie o 7.2e1017byte di 8 byte.


1
Cos'è quello? 1016? Devono essere 9999! (O ho frainteso qualcosa?)
Mega Man,

@MegaMan Il prompt dei problemi richiede un limite inferiore di runtime di 10 ^ 1000 anni. Essendo golf, non volevo essere dispendioso e calcolare troppo a lungo, quindi ho cercato di farlo fermare il prima possibile dopo aver raggiunto la soglia. :)
Nicu Stiurca,

ah, ok, non conoscevo questa regola
Mega Man il

5

Perl, 16 caratteri

/$_^/for'.*'x1e9

Questo crea una stringa ripetendo ". *" Un miliardo di volte, quindi la usa sia come ago che come pagliaio in una partita regex. Questo, a sua volta, fa sì che il motore regex tenti ogni possibile partizione di una stringa lunga due miliardi di caratteri. Secondo questa formula di Wikipedia , ci sono circa 10 35218 tali partizioni.

La soluzione sopra è lunga 16 caratteri, ma richiede solo circa 2 GB di memoria, il che significa che può essere eseguita su un vero computer. Se assumiamo memoria infinita e dimensioni finite del registro (che probabilmente non ha senso), può essere ridotto a 15 caratteri aumentando notevolmente il tempo di esecuzione:

/$_^/for'.*'x~0

(Non l'ho provato, ma penso che potrebbe funzionare con un Perl a 32 bit costruito su un computer a 64 bit con almeno 6 GB di RAM.)

Appunti:

  • x è l'operatore di ripetizione stringa.
  • il fornon è un ciclo reale; è usato solo per salvare un personaggio (rispetto a$_=".*"x1e9;/$_^/ ).
  • il finale ^ in regex assicura che solo la stringa vuota possa corrispondere; poiché i quantificatori regex sono avidi per impostazione predefinita, questa è l'ultima cosa che il motore proverà.
  • i benchmark sul mio computer per i valori (1..13) suggeriscono che il tempo di esecuzione è in realtà O (exp (n)), che è anche più di O (exp (sqrt (n))) nella formula di Wikipedia.

4

J (12)

(!^:(!!9))9x

Cosa si riduce in Python (supponendo che !funzioni):

a = 9 
for i in range((9!)!):
    a = a!

MODIFICARE:

Bene, il programma può richiedere, al massimo, 2 × 10^-1858926 secondi per ciclo entro il tempo richiesto. Suggerimento: questo non funzionerà nemmeno per il primo ciclo, non importa l'ultimo;).

Inoltre: questo programma potrebbe aver bisogno di più memoria di quanta c'è l'entropia nell'universo ...


3
"potrebbe aver bisogno di più memoria di quanta c'è l'entropia nell'universo" - Puoi xrange()
ridurlo

1
Inoltre, !non funziona in Python. Hai bisogno import mathe math.factorial().
daviewales,

4

C # 217

Non sono un gran giocatore di golf, ma non ho resistito alla funzione di Ackerman . Inoltre non so davvero come calcolare il runtime, ma si fermerà sicuramente e durerà sicuramente più a lungo di questa versione .

class P{
static void Main(){for(int i=0;i<100;i++){for(int j=0;j<100;j++){Console.WriteLine(ack(i,j));}}}
static int ack(int m,int n){if (m==0) return n+1;if (n ==0) return ack(m-1,1);return ack(m-1,ack(m,n-1));}
}

È possibile salvare 10 byte rinominando la ackfunzione con un nome a carattere singolo come a.
pepery

4

Primo tentativo di codice golf, ma qui va.

VBA - 57 45

x=0
do
if rnd()*rnd()<>0 then x=0
x=x+1
while 1=1

Quindi X aumenterà di uno se si verifica un evento 1 in 2 ^ 128 e ripristinerà se non si verifica. Il codice termina quando si verifica questo evento 2 ^ 64 + 1 volte di seguito. Non so come iniziare a calcolare il tempo, ma immagino che sia enorme.

EDIT: ho elaborato la matematica e la probabilità che ciò accada in ogni ciclo è 1 in 2 ^ 128 ^ (1 + 2 ^ 64) che è lunga circa 20000 cifre. Supponendo 1000000 loop / sec (campo di baseball dal numero di aria sottile) e 30000000 s / anno che è 3 * 10 ^ 13 cicli all'anno tempo 10 ^ 1000 anni rimasti è 3 * 10 ^ 1013 cicli, quindi questo probabilmente durerebbe circa 20 volte il tempo rimanente rimasto nell'universo. Sono contento che la mia matematica sostenga la mia intuizione.


Penso che l'ultima riga dovrebbe essere While x=1, giusto? (altrimenti è un ciclo infinito). Inoltre, puoi eliminare 12 caratteri se lo sostituisci Dim x As Doublecon x=0(VBA non richiede di dichiarare le variabili a meno che non specifichi Option Explicit)
kb_sou

Non lo guardo come un ciclo infinito in quanto si interrompe quando x trabocca che è alla fine.
Myles Horne,

Sicuramente non funziona con while x = 1 in quanto ciò generalmente impedirebbe l'esecuzione del loop.
Myles Horne,

Se l'interruzione del ciclo in questo modo non soddisfa i criteri "nessun ciclo infinito", WHILE 1 = 1 potrebbe cambiare in WHILE ISNUMERIC (X).
Myles Horne,

4

C, 30 caratteri

main(i){++i&&main(i)+main(i);}

Supponendo che l'overflow firmato due complimenti di due e gli ints a 32 bit, questo funzionerà per circa 2 2 32 chiamate di funzione, che dovrebbero essere un sacco di tempo per la fine dell'universo.


Tuttavia, finirai per esaurire lo stack molto prima.
Sparr,

1
@Sparr Una delle regole è quella di assumere uno stack e una dimensione heap infiniti.
scragar

3

GolfScript, 13 caratteri

0{).`,9.?<}do

Questo programma conta da 0 a 10 9 9 −1 = 10 387420488 . Supponendo, ottimisticamente, che il computer funzioni a 100 GHz e può eseguire ogni iterazione del programma in un singolo ciclo, il programma funzionerà per 10 9 9 −12 secondi, o circa 3 × 10 9 9 −20 = 3 × 10 387420469 anni.

Per testare il programma, è possibile sostituire il 9con a 2, che lo farà fermare a 10 2 2 −1 = 10 3 = 1000. (Usando un 3invece di un2 lo farà fermare a 10 3 3 −1 = 10 26 , che , anche con le ipotesi ottimistiche di cui sopra, non raggiungerà per almeno alcuni milioni di anni.)


3

Tasto automatico 37

loop {
if (x+=1)>10^100000000
break
}

3

Haskell, 23

main=interact$take$2^30

Questo programma termina dopo aver letto 1073741824 caratteri da stdin . Se viene eseguito senza eseguire il piping di dati stdin, dovrai digitare questo numero di caratteri sulla tastiera. Supponendo che la tastiera abbia 105 tasti, ciascuno valutato per 100k cicli meccanici e programmato per generare sequenze di tasti non morte, la ripetizione automatica è disattivata e il socket della tastiera consente 100 cicli di connessione, questo fornisce un numero massimo di sequenze di tasti per uptime del computer di 1050000000, che è non abbastanza per terminare il programma.

Pertanto, il programma terminerà solo quando sarà disponibile un hardware migliore in termini di numero di cicli, che in realtà non è mai in questo universo in esecuzione. Forse la prossima volta, quando la qualità ha una priorità maggiore rispetto alla quantità. Fino ad allora, questo programma termina in linea di principio ma non in pratica.


Che cosa succede se le tastiere hot-swap mentre procedi?
Thomas,

Questo è coperto dai 100 cicli di connessione del socket della tastiera.
TheSpanishInquisition

Ma il punto del problema è che il programma non termina, da qualche parte dopo la morte termica dell'universo. Questo programma non può mai terminare; una volta che l'entropia diventa abbastanza alta, non avrai mai un'altra tastiera da collegare.
abarnert

1
Non sono ancora convinto. Se esegui il programma in remoto (o in una macchina virtuale), non sei limitato dalle capacità hardware di un singolo computer e 1 miliardo di colpi non è poi così tanto. Inoltre, il problema dice che il computer è fatto di obobio, e quindi anche la tastiera dovrebbe essere, quindi, può gestire 2 ^ 30 sequenze di tasti ...
Thomas,

3

~ ATH, 56

Nel linguaggio immaginario ~ ATH :

import universe U;
~ATH(U) {
} EXECUTE(NULL);
THIS.DIE()

~ ATH è un linguaggio insopportabile con cui lavorare. La sua logica è composta da nient'altro che anelli infiniti, o nella migliore delle ipotesi, anelli di costruzione effettivamente interminabile.

Quello che fanno molti programmatori ~ ATH è importare costrutti finiti e legare i loop alla loro durata. Ad esempio, il ciclo principale qui terminerà con la morte dell'universo, etichettato U. In questo modo devi solo aspettare miliardi di anni perché finisca invece che per sempre.

Chiedo scusa per le violazioni al limite della scappatoia; Ho pensato che fosse troppo rilevante per lasciar perdere.

Se qualcuno è stato effettivamente divertito da questo, maggiori dettagli: (1) , (2) , (3) , (4)


2

Rubino (34)

La linea ([0]*9).permutation.each{print} impiega circa 2,47 secondi per 9! stampa sulla mia macchina, mentre la linea ([0]*10).permutation.each{print}impiega circa 24,7 secondi per 10! stampe, quindi immagino di poter estrapolare qui e calcolare (24.7/10!)*470! seconds in yearsquale è 6,87 * 10 ^ 1040, che dovrebbe essere il tempo di esecuzione di:

([0]*470).permutation.each{print}

2

JavaScript 68 62 caratteri

(function a(m,n){return m==0?n+1:a(m-1,n==0?1:a(m,n-1))})(5,1)

Questo utilizza il funzione Ackermann che può essere scritta come

function ackermann(a, b) {
  if (a == 0) return b + 1;
  if (b == 0) return ackermann(a-1, 1);
  else return ackermann(a-1, ackermann(a, b-1));
}

Il suo tempo di esecuzione aumenta in modo esponenziale e richiede quindi molto tempo per il calcolo. Anche se non è inglese qui puoi ottenere una panoramica dei suoi valori di ritorno. Secondo la tabella è ackermann(5,1)uguale2↑↑(65533)-3 che è, sai, molto grande.


2
Questo può beneficiare di alcune delle stesse ottimizzazioni della precedente implementazione della funzione Perl Ackermann.
Peter Taylor,

Devo aver trascurato la soluzione perl. Grazie per la segnalazione.
henje,

invece di n==0?X:Y, puoi sempre faren?Y:X
Cyoce il

2

Befunge '93 - 40 byte

(Programma 20x2)

v<<<<<<<<<<<<<<<<<<<
>??????????????????@

Questo programma si basa su numeri casuali per dargli un ritardo. Poiché gli interpreti di Befunge sono piuttosto lenti, questo programma dovrebbe adattarsi al conto. E in caso contrario, possiamo sempre espanderlo in senso orizzontale. Non sono esattamente sicuro di come calcolare il tempo di esecuzione previsto di questo programma, ma so che ciascuno? ha una probabilità del 50/50 di ricominciare o cambiare la sua posizione orizzontale di 1. Ci sono 18? Penso che dovrebbe essere qualcosa del genere di (18 ^ 2) !, che Google Calculator dice "Infinito"

EDIT: Whoops Non ho notato l'altra risposta Befunge, questo è il mio primo post qui. Scusate.


Ehi, non preoccuparti dell'altra risposta befubnge o, o in generale, usando la stessa lingua di qualcun altro. Voglio dire, nessuno ha intenzione di battere quello matematico, quindi tutte le altre proposte sono divertenti. Il mio era.
AndoDaan,

2

APL, 10

Non penso che questa sia una risposta valida (in quanto non è deterministica), ma comunque ......

{?⍨1e9}⍣≡1

Questo programma calcola una permutazione casuale di numeri 1e9 (?⍨1e9 ) e si ripete fino a quando due uscite consecutive sono uguali ( ⍣≡)

Quindi, ogni volta che viene calcolata una permutazione, ha un 1 su 1000000000! possibilità di terminare. E 1000000000! è almeno 10 10 8 .

Il tempo necessario per calcolare una permutazione è reso irrilevante dal valore di 1000000000 !. Ma alcuni test mostrano che questo è O(n)e l'estrapolazione dà circa 30 secondi.

Tuttavia, il mio interprete rifiuta di accettare input per la funzione casuale maggiore di 2 31 -1 (quindi ho usato 1e9) e la generazione di permutazioni di 1000000000 numeri ha dato un errore completo nello spazio di lavoro. Tuttavia, concettualmente può essere fatto con un interprete APL ideale con memoria infinita.

Questo ci porta alla possibilità di utilizzare 2 63 -1 al posto di 1e9 per aumentare il tempo di esecuzione fino ad almeno 10 10 20 , ipotizzando un'architettura a 64 bit.

Ma aspetta, l'architettura è rilevante in un interprete ideale? Inferno no, quindi in realtà non c'è limite superiore al tempo di esecuzione !!


2

R, 45 byte

(f=function(x)if(x)f(x-1)+f(x-1)else 0)(9999)

È un vecchio thread ma non vedo risposta R, e non possiamo averlo!

Il tempo di esecuzione per me era di circa 1 secondo quando x era 20, suggerendo un tempo di esecuzione di 2 ^ 9979 secondi.

Se si sostituisce lo zero con uno, l'output sarebbe 2 ^ x, ma allo stato attuale l'output è zero qualunque sia x (evita problemi di overflow).


1

Javascript, 120 byte

a=[0];while(a.length<1e4)(function(){var b=0;while(b<a.length){a[b]=(a[b]+1)%9;if(a[b])return;b++}a.push(1)})();alert(a)

Può essere fatto con una memoria minima (probabilmente meno di mezzo megabyte) ma impiega (probabilmente) circa 10 8.750 anni per fermarsi.

Incrementa ripetutamente un BigInteger base-9 little-endian fino a raggiungere 9 10 4 -1 .


1

Python 3, 191 byte

from random import*
r=randint
f=lambda n:2if n<2else f(n-1)
x=9E999
s=x**x
for i in range(f(x)**f(s)):
 while exec(("r(0,f(x**i))+"*int(f(x)))+"r(0,f(x**i))")!=0:
  s=f(x**s)
  print(s)

Innanzitutto, f è una funzione fattoriale ricorsiva e ultra lenta. Quindi, c'è 9 * 10⁹⁹⁹ alimentato con se stesso, che genera un OverflowError, ma questo non accade su questo computer Unobtanium. Il For-Loop itera 9E999! ^ (9E999 ^ 9E999)! volte e passa alla successiva iterazione, se 9E999! +1 ints casuali tra 0 e 9E99 * ^ i! sono tutti 0 e in ogni iterazione di while-loop s viene impostato su (9E999 ^ s) !. Ho dimenticato che la stampa di s richiede tempo muuuuccchhhh ...
So che non è l'assolo più breve, ma penso che sia davvero efficace. Qualcuno può aiutarmi a calcolare il tempo di esecuzione?


1

Turing Machine But Way Peggio ancora , 167 byte

0 0 1 1 2 0 0
1 0 1 0 4 0 0
0 1 1 1 2 0 0
1 1 1 1 5 0 0
0 2 1 0 3 0 0
1 2 0 1 1 0 0
0 3 1 1 4 0 0
1 3 0 0 2 0 0
0 4 1 0 0 0 0
1 4 0 1 3 0 0
0 5 1 0 6 0 1
1 5 1 1 2 0 0

Provalo online!

Dovrebbe eseguire il Busy Beaver a 2 simboli a 6 stati dalla pagina di Wikipedia .

Come detto nella pagina di Wikipedia, viene eseguito 7,412×1036534passi. Questo è molto più della morte per calore, supponendo che esegua ciascun comando in più o uguale a un nanosecondo.

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.