Sono uno sviluppatore e non ho voglia di fare il mio lavoro. So da XKCD che la migliore scusa per rallentare è la compilazione del tuo codice . Per questo motivo, penso di aver bisogno di un codice che verrà compilato per sempre!E poiché sono pigro e non voglio digitare molto, questo deve essere fatto con il codice più breve possibile.

Quindi, il tuo compito è scrivere un programma che sia sintatticamente valido, ma causi al compilatore di entrare in un ciclo infinito.

specificazioni

È necessario utilizzare un linguaggio che ha un compilatore, ovviamente.
Specificare l'implementazione utilizzata in ciascuna soluzione.
Questo è code-golf , quindi vince la soluzione valida più breve (in byte).
Il compilatore può terminare dall'esaurimento della memoria o dello spazio dello stack.

code-golf compile-time

— Esolanging Fruit
fonte

1

@obarakon Non sono d'accordo. Il codice dell'altra sfida non può essere facilmente trasferito su questa sfida. Le sfide mentre entrambe implicano un loop infinito sono fondamentalmente diverse.

— Sriotchilism O'Zaic,

1

@obarakon Non è neanche un imbecille di questa domanda , dato che non si tratta di code-golf.

— Esolanging Fruit,

2

Correlati

— Sriotchilism O'Zaic

1

Non sono sicuro che si adatti a questa sfida (e anche se lo facesse avrebbe un punteggio terribile), ma per chi è interessato ecco come lo farei Java: definire un processore di annotazione (frammento di ideone) che userete quando invocate javaccon il suo -processoropzione. Rende la compilazione di qualsiasi classe sospesa per sempre.

— Aaron,

6

Per le risposte che provocano l'arresto anomalo del compilatore: allo scopo di allentare, penso che vorresti che impiegasse il più tempo possibile per arrestarsi.

— GuitarPicker,

16

Japt , 2 byte

`ÿ

Puoi testarlo online qui , ma non lo consiglierei perché bloccherà il tuo browser.

Spiegazione

Japt utilizza la libreria shoco per comprimere le stringhe. Un backtick dice al compilatore di decomprimere tutto fino al backtick successivo o alla fine del file. Ogni byte procede come segue:

00-7F sono lasciati intatti.
80-BFogni trasformano in una coppia di due lettere minuscole comune ( at, oo, th, ecc).
C0-DFognuno consuma il byte successivo e si trasforma in una stringa di quattro lettere comune .
E0-EFognuno consuma i successivi tre byte e si trasforma in una stringa "comune" di otto lettere (che inizia Whererere scende da lì).
F0-F7 rompere il decompressore, sebbene restituisca ancora tutto fino al byte di interruzione.
F8-FFfa sì che il decompressore entri in un ciclo infinito. Non sono sicuro del perché, poiché non ho molta familiarità con il funzionamento interno della libreria shoco (e il codice JavaScript è completamente illeggibile ), ma in questo caso è molto utile.

Non credo che ci sia un altro modo per scherzare con il compilatore Japt, ma non si sa mai ...

— ETHproductions
fonte

10

Cosa vuoi dire che è illeggibile. Chiaramente non ci stai provando abbastanza.

— fəˈnɛtɪk,

Vorrei che ci fosse un decompilatore emscripten ...

— tbodt

58

TikZ (pdfTeX 3.14159265-2.6-1.40.17), 85 79 74 24 22 21 byte

Un sacco di byte salvati grazie a wchargin

Un byte salvato grazie a Chris H

\input tikz
\tikz\pic

In realtà l'ho incontrato per caso mentre stavo lavorando sui compiti. Ho trascorso un bel po 'ad aspettare che si compilasse prima di rendermi conto di ciò che stava accadendo.

Questo ha due parti:

\input tikz

Questo carica il pacchetto TikZ

e:

\tikz\pic

Questo avvia un \tikzambiente e un comando di disegno.

Cosa sta succedendo

Il compilatore pdflatex ha problemi con \tikz\pic, ed entra in modalità interattiva causando lo stallo indefinito.

— Sriotchilism O'Zaic
fonte

(1/2) Non riesco a riprodurre questo. Ottengo "Argomento in fuga \draw l\end {document}?! Il file è terminato durante la scansione dell'uso di \tikz@next." pdflatex 3.1415926-2.5-1.40.14 (TeX Live 2013 / Debian). tikz 2010/10/13 v2.10. Questo è standard apt install texlive-fullsu Ubuntu 14.04.

— mercoledì

1

@wchargin Sto usando la stessa versione di pdfTeX 3.14159265-2.6-1.40.17 (TeX Live 2016) e effettivamente esegue un ciclo indefinito. Grazie per i suggerimenti

— Sriotchilism O'Zaic,

1

Puoi salvare un byte usando \picinvece di \ draw` - esattamente lo stesso comportamento (testato usando tikz 1.142)

— Chris H

3

Non riesco a credere che in realtà sto sostenendo di non usare TikZ, ma sicuramente il suo utilizzo è eccessivo qui. Cosa c'è che non va nel vecchio \def\a{\a}\a(12 byte)? Oppure, poiché si tratta di code golf ed ~è attivo per impostazione predefinita, \def~{~}~(9 byte)?

— Loop Space

2

@LoopSpace Non c'è niente di sbagliato in loro, non sapevo proprio che esistesse. Se desideri fare la tua risposta, sentiti libero.

— Sriotchilism O'Zaic,

40

C, 18 byte

#include __FILE__

I compilatori di solito si arrendono dopo aver ripetuto circa 200 volte.

La costruzione DOM conta come una fase di compilazione? In tal caso, quindi x.htm:

<iframe src=x.htm>

— Neil
fonte

14

Ricordo che i frame ricorsivi erano soliti bloccare IE4 così duramente che a volte portava via componenti importanti del sistema operativo. Quindi l'HTML probabilmente conta.

10

@ ais523, questo perché, nei giorni IE4, Internet Explorer era un "importante componente del sistema operativo".

— Segna il

2

Un po 'di tweaking ed è valida PHP: <?include __FILE__;.

— Ismael Miguel,

6

Non riesco a pubblicare questa risposta perché il mio rappresentante non è abbastanza alto, ma due alternative sono: #include "/ dev / zero" e #include "/ dev / stdin" - fai attenzione a eseguire la prima !!

— rrauenza,

2

Quando l'ho provato, l'utilizzo della memoria di gcc ha iniziato a crescere rapidamente senza limiti, il sistema non ha risposto e il mio cane da guardia alla fine è entrato e riavviato. È stato abbastanza divertente :)

— rrauenza,

38

Java, 102 95 89 88 78 byte

class A<T>{}class B<T>extends A<A<?super B<B<T>>>>{A<?super B<A>>a=new B<>();}

Questo termina con un StackOverflowErrorche accade perché il sistema di risoluzione generico non può decidere una radice in base alla quale risolvere gli altri generici.

Crediti ove dovuti .

Che succede qui?

A<T>è lì per avere un genitore di 1 lettera. È generico Avrei potuto usare List, ma le importazioni e la ripetizione di 4 lettere sono troppo lunghe.
B<T> dichiara un generico di base.
B extends Aè necessario disporre di una gerarchia tra Be A.
extends A<A>crea un riferimento personale su A<T>.
A<? super B> attiva la ricerca di generici A<T>
B<B<T>>crea un riferimento personale su B<T>.
A<...> a=new B<>()forza l'uso dei generici, anziché semplicemente la definizione di quelli, forzando la risoluzione durante la compilazione Be non successivamente.
A<?super Bcrea un auto-riferimento, quindi abbiamo sia un riferimento a un tipo che a un altro nei generici di A.
B<A>crea un auto-riferimento, quindi abbiamo sia un riferimento a un tipo che a un altro nei generici di B.

Ora, il tipo Aha tipo generici Ae B, ma quale deve essere scelto? Dimentica te stesso, proviamo a risolvere B. Ping.

Va bene, Bha il tipo di generici Ae B, ma quale deve essere scelto? Dimentica te stesso, proviamo a risolvere A. Pong.

Questo tipo di ricorsione non può davvero essere evitato perché ci sono casi legittimi, come A<B<A<B<A<B<Object>>>>>>ad esempio un oggetto JSON: List<Map<String,Map<String,List<Map<String,List<String>>>>>>.

Risultato della compilazione

$ javac NoCompile.java


The system is out of resources.
Consult the following stack trace for details.
java.lang.StackOverflowError
        at com.sun.tools.javac.code.Types$UnaryVisitor.visit(Types.java:3260)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2587)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2579)
        at com.sun.tools.javac.code.Type$ClassType.accept(Type.java:554)
        at com.sun.tools.javac.code.Types$UnaryVisitor.visit(Types.java:3260)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2592)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2579)
        at com.sun.tools.javac.code.Type$ClassType.accept(Type.java:554)

Sul mio sistema, la traccia dello stack si interrompe dopo aver mostrato 1024 linee, che in realtà sono le stesse 4 linee ripetute 256 volte, dimostrando così una ricorsione infinita. Ti risparmierò l'intera traccia.

risparmi

102 → 95 byte: sostituito interface+ implementscon class+ extends.
95 → 89 byte: sostituito Longcon A(due volte).
89 → 88 byte: operatore diamante usato ( new B<A>()→ new B<>()).
88 → 78 byte: ha spostato la dichiarazione della variabile in un membro della classe, grazie a VoteToClose .

— Olivier Grégoire
fonte

1

Cosa sto guardando

— Addison Crump,

Puoi accorciarlo a 78 byte con:class A<T>{}class B<T>extends A<A<?super B<B<T>>>>{A<?super B<A>>b=new B<>();}

— Addison Crump,

@VoteToClose Stai guardando un primo esempio di indecidibilità nei generici di Java. Si suppone che ogni generico sia risolto rispetto a una radice comune alla quale viene quindi convalidata una contro. La cosa qui è che il generico di Bcontiene un riferimento indecidibile al generico di Acui a sua volta contiene un riferimento indecidibile al generico di B. Quando il risolutore non può decidere, controlla i riferimenti inclusi, ma qui entrambi i generici si riferiscono l'un l'altro in un modo indecidibile (principalmente grazie a riferimenti personali e alla superparola chiave. Quindi il risolutore in realtà fa un rumore metallico tra i due generici.

— Olivier Grégoire,

Stavo pensando di creare un problema in fase di compilazione con annotazioni cicliche: public @interface X {@X(x=X.class)Class<? extends X> x();}... Ma ho capito subito perché non avrebbe funzionato lol.

— Magic Octopus Urn

34

GNU Makefile, 8 7 byte

Un byte salvato grazie a KonradRudolph

Salvato come Makefilee invocato da make:

x:;make

Ciò produrrà una ricorsione di build infinita sul primo obiettivo trovato "x".

Inutile dire che non vuoi davvero eseguire questa bomba a forcella sul tuo server di produzione. :-)

make
make[1]: Entering directory `/path/to/my/dir'
make
make[2]: Entering directory `/path/to/my/dir'
make
make[3]: Entering directory `/path/to/my/dir'
make
make[4]: Entering directory `/path/to/my/dir'
make
make[5]: Entering directory `/path/to/my/dir'
make
make[6]: Entering directory `/path/to/my/dir'
make
make[7]: Entering directory `/path/to/my/dir'
make
...

Versione alternativa, 5 byte

Suggerito da Konrad Rudolph:

x:;$_

$_è un riferimento all'ultimo argomento del comando precedente. Più specificamente, viene risolto qui come il percorso assoluto del comando in esecuzione - che è esso makestesso.

Questo dovrebbe funzionare bene in un ambiente Bash originale, ma non su Windows + MinGW.

— Arnauld
fonte

2

Hmm, non credo makeche compili davvero il Makefile (lo interpreta semplicemente).

— Zeppelin,

3

@zeppelin Hai ragione, questa è probabilmente una risposta limite. Detto questo, i contributi che hanno comportato la ricorsione macro a livello del preprocessore non inizieranno nemmeno a compilare alcun codice effettivo.

— Arnauld,

11

Si adatta all'obiettivo previsto: avere un processo di generazione infinito. +1!

— YSC,

23

C ++, 60 58

template<class T>class a{a<T*>operator->();};a<int>i=i->b;

Ciò crea ricorsivamente istanze di class acon parametri di modello diversi. GCC 7.0 si interrompe dopo 900 livelli di ricorsione con tonnellate di errori operator->sull'essere privati, ma per esempio ICC 17 e Microsoft (R) C / C ++ Optimizing Compiler 19 scadono su godbolt .

Il problema è che probabilmente tutti i compilatori esauriranno la memoria a un certo punto nel tempo, quindi anche senza limiti di ricorsione questo si fermerà. Lo stesso vale probabilmente anche per la risposta Clojure.

Modifica: 2 byte salvati da bolov - Grazie

— Christoph
fonte

1

più breve:a<int>i=i->b;

— Bolov,

1

@ Tasche come ho affermato nella mia risposta, perché il valore predefinito operator->è privato all'interno di una classe. All'interno di una struttura è pubblica e pertanto i->bpuò accedervi.

— Christoph,

1

gcc 4.4.7 sembra essere sospeso indefinitamente qui. In attesa dell'infinito o che mostri l'output, a seconda di quale evento si verifichi per primo. Si aggiorna

— osuka_

1

@osuka_ è ancora in esecuzione?

— Christoph,

1

@Christoph no, si è schiantato con un SIGSEGV dopo averlo lasciato in esecuzione per un paio di giorni. Hai dimenticato di aggiornare, però - grazie per il promemoria!

— osuka_

23

Perl , 15 13 byte

BEGIN{{redo}}

Provalo online!

Ora con 2 byte salvati: @Zaid mi ha ricordato un modo più semplice di fare un ciclo in Perl.

Questo è piuttosto semplice: installa solo un hook parser con un loop infinito, facendo in modo che il codice impieghi infinitamente tempo per essere analizzato. (Perl è carino in quanto ti consente di eseguire codice arbitrario nel mezzo dell'analisi; gli hook di parser sono specificati in Perl stesso e spesso usati per fare cose come importare librerie o cambiare le regole di analisi per un identificatore che vuoi trattare come una parola chiave.) Provalo online! il link sopra fornisce l' -copzione (per compilare il codice per verificare la sintassi per la correttezza, ma non eseguirlo), per dimostrare che il ciclo infinito avviene al momento della compilazione.

Nel caso ti stia chiedendo del "tempo di compilazione" in un linguaggio di scripting: Perl in realtà si compila in bytecode e quindi esegue il bytecode, ma questo è un dettaglio che raramente è rilevante durante la programmazione. La -MO=famiglia di opzioni della riga di comando può essere utilizzata per eseguire operazioni con il bytecode diverso da quello in esecuzione (sebbene non con questo programma, poiché il ciclo infinito si verifica prima che il bytecode possa essere generato).

1

a:goto asembra anche bello (stesso addio purtroppo).

— Dada,

3

BEGIN{{redo}}ti farà risparmiare qualche byte

— Zaid,

20

C ++, 37 30 29 byte

int f(auto p){f(&p);},a=f(0);

Utilizza il futuro parametro della funzione automatica. È stato proposto in C ++ 17, ma non credo che ce l'abbia fatta. gcctuttavia lo supporta come estensione.

Fondamentalmente

void foo(auto p);

è equivalente a

template <class T>
void foo(T p);

Il codice tenta di creare un'istanza in fmodo ricorsivo con diversi argomenti di modello. gccfallisce con

errore fatale: la profondità di istanza del modello supera il massimo di 900 (utilizzare -ftemplate-depth = per aumentare il massimo)

Con l' -ftemplate-depth=10000ho ottenuto per sputare "Killed - tempo di elaborazione superato" su godbolt.

Controllalo su godbolt

1 byte salvato da Quentin. Grazie.

— bolov
fonte

1

È possibile salvare un byte utilizzando intcome tipo restituito :)

— Quentin

In effetti, i autoparametri di funzione non sono stati inseriti in C ++ 17; e inoltre int f() { ... }, a;non è una dichiarazione legale l'ultima volta che ho controllato. (Non è possibile mescolare dichiarazioni di funzioni con dichiarazioni di variabili del genere). Ciò che si ottiene qui è un dialetto estremamente specifico di C ++ di GCC. Non che ci sia qualcosa di sbagliato in questo contesto. :)

— Quuxplusone,

19

Lisp comune, 8 byte

#.(loop)

Il compilatore tenterà di leggere un modulo e incontrerà la macro del lettore di punti sharpsign , che valuta il codice al momento della lettura e utilizza il suo risultato come modulo per compilare. Qui, il codice in esecuzione è un ciclo infinito.

— coredump
fonte

17

TeX, 9 byte

\def~{~}~

TeX funziona espandendo le macro. Il più delle volte, le macro di TeX (chiamate anche sequenze di controllo ) sono di forma \namema è anche possibile definire determinati caratteri come macro, questi sono chiamati caratteri attivi . Il personaggio ~è attivo di default in TeX semplice e quindi può essere usato come nome di macro senza ulteriore dichiarazione. Quanto \def~{~}sopra definisce in ~modo che si espanda a ~. Cioè, ogni volta che si incontra TeX, ~lo sostituisce con ~e quindi riesamina la sostituzione, il che significa che incontra una ricorrenza completamente nuova ~e la sostituisce con ~. Questo definisce il ciclo infinito. Tutto ciò che serve è avviare il loop ed è quello che fa la finale ~.

Aggiunto in modifica

Per compilare correttamente , invoca come:

pdftex -ini "&pdftex \def~{~}~"

Il -iniflag dice che pdftexdovrebbe compilare un nuovo file di formato. Questo è un insieme precompilato di definizioni che possono essere caricate quando TeX viene successivamente richiamato per accelerare l'elaborazione di un documento (LaTeX2e ne è un esempio). Immagino che &pdftexaggiunge qualche byte, portando il totale a 17.

— Loop Space
fonte

Questo succede in fase di compilazione? La domanda richiede che si verifichi il ciclo infinito durante la compilazione, non durante l'esecuzione.

@ ais523 Non ci avevo pensato completamente. Stavo sfogliando la risposta di TikZ. Ho aggiunto un'alternativa che è sicuramente compilata, a spese di qualche byte in più.

— Loop Space

2

@ ais523: Come sempre, "compilare" e "correre" sono due facce della stessa medaglia. Personalmente, penso al codice sorgente di TeX come "compilazione" in documenti PDF (che vengono poi "eseguiti" dalla visualizzazione), allo stesso modo in cui il codice sorgente C ++ viene "compilato" in file .exe (che vengono poi "eseguiti" da in esecuzione). Ma potresti anche pensare al pdftexprogramma come "interpretazione" dell'input TeX per produrre un PDF come "output" - nello stesso modo in cui il g++programma "interpreta" l'input C ++ per produrre un file .exe come "output". ;)

— Quuxplusone,

13

Haskell, 25 + 17 = 42 byte

a= $(let a='a':a in[|a|])

Un semplice metaprogramma di Haskell che definisce un valore infinito e tenta di calcolare quel valore in fase di compilazione.

Richiamare con ghc -XTemplateHaskell <file.hs>(+17 per il parametro nel compilatore)

— user2407038
fonte

Non $(let a=a in a)funziona (per 32 byte)?

— Ry,

1

No! GHC è troppo intelligente. Qualsiasi ciclo infinito del modulo let a = a in aviene riscritto in un'eccezione, che causa semplicemente un errore del compilatore anziché un ciclo infinito. (anche se forse questo funzionerebbe con un altro compilatore Haskell, ma non ne ho uno a portata di mano per provare)

— user2407038

Funziona con runghc per me, quindi direi che è valido. (In realtà, funziona anche con ghc. 8.0.1 qui.)

— Ry

Veramente? Sono anche su ghc 8.0.1 - per me dà Exception when trying to run compile-time code: <<loop>>, sia nell'interprete che durante la compilazione ... tecnicamente anche il codice sopra muore con un'eccezione, ma un overflow dello stack, che è esplicitamente consentito dalla specifica - e se avessi una memoria infinita, sarebbe davvero in loop per sempre. L' <<loop>>eccezione si attiva molto prima che la mia macchina esaurisca la memoria.

— user2407038

12

gradle, 10 9 byte

for(;;){}

con il codice sopra inserito in un build.gradlefile. Gradle usa groovy come linguaggio di base, quindi stiamo davvero parlando di groovy qui, ma dato che la domanda riguardava il tempo di costruzione ho pensato che Gradle sarebbe stato più appropriato.

L'esecuzione di qualsiasi comando di compilazione gradle con il codice precedente stampa la riga di stato di compilazione compatibile con il capo appuntito:

$ gradle tasks
> Configuring > 0/1 projects > root project

se stai puntando a un rilancio, aggiungi il -dflag di debug per:

$ gradle -d tasks
14:56:25.522 [INFO] [org.gradle.internal.nativeintegration.services.NativeServices] Initialized native services in: .gradle/native
14:56:25.757 [DEBUG] [org.gradle.launcher.daemon.client.DaemonClient] Executing build 84908c0d-f28d-4c57-be61-40eaf0025e16.1 in daemon client {pid=27884}
14:56:25.761 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding IP addresses for network interface tun0
14:56:25.762 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a loopback interface? false
14:56:25.762 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a multicast interface? false
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x:x:x:x:x:x:%tun0
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x.x.x.x
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding IP addresses for network interface eth1
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a loopback interface? false
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a multicast interface? true
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x:x:x:x:x:x:%eth1
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x.x.x.x
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote multicast interface eth1
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding IP addresses for network interface lo
<snip>
14:57:07.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.
14:57:07.056 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Waiting to acquire shared lock on daemon addresses registry.
14:57:07.056 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Lock acquired.
14:57:07.056 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.
> Configuring > 0/1 projects > root project

che oltre a sembrare incredibilmente complicato si aggiorna anche con un nuovo set di:

15:07:57.054 [DEBUG] [org.gradle.launcher.daemon.server.Daemon] DaemonExpirationPeriodicCheck running
15:07:57.054 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Waiting to acquire shared lock on daemon addresses registry.
15:07:57.054 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Lock acquired.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Waiting to acquire shared lock on daemon addresses registry.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Lock acquired.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.

linee di stato ogni 10 secondi, facendo sembrare che la build sia occupata a fare importanti ... cose tecniche.

— Matias Bjarland
fonte

8

SWI-Prolog, 34 byte

term_expansion(_,_):-repeat,1=0.

Spiegazione

term_expansion/2 è qualcosa che viene chiamato automaticamente dal compilatore prima di compilare effettivamente il codice per trasformare alcuni termini nel codice sorgente in altri termini.

Qui, si introduce una nuova regola per term_expansion/2: repeat,1=0..

repeat/0 è un predicato che ha sempre successo e fornisce un numero infinito di punti di scelta.

1=0sta cercando di unificarsi 1con 0, che è sempre false. Ciò farà tornare indietro il compilatore repeat(poiché fornisce sempre un punto di scelta) e riproverà 1=0, ecc.

— Fatalize
fonte

Non funziona in GNU Prolog, quindi presumo che sia specifico dell'implementazione. Potresti voler inserire il nome di un compilatore nell'intestazione. (

@ ais523 Grazie, non ho controllato altri distrib, ma dato che le cose del compilatore sono di solito piuttosto specifiche, avrei dovuto conoscerlo meglio ...

— Fatalizzare il

@ ais523 Tuttavia, in base a ciò , potresti essere in grado di utilizzare expand_terminvece (come dice term_expansionnon può essere usato come qui in GNU Prolog). expand_termTuttavia, non funziona con SWI.

— Fatalizza il

7

GNU Make, 44

.PHONY:x
$(MAKEFILE_LIST):x;sleep 1;touch $@

Non posso chiedere credito per questo. Deriva dal libro di Robert Mecklenburg Gestione dei progetti con GNU Make: The Power of GNU Make for Building Anything .

Quando make esegue questo makefile, vede che il makefile è obsoleto (perché il target .PHONY non è aggiornato, quindi esegue il comando touch, che aggiorna il timestamp del makefile. Quindi make rilegge il file e scopre il file makefile non è aggiornato .... Bene, hai capito.

Preferisco questo all'altro rispondere come non utilizza la ricorsione. Sulla mia macchina virtuale, l'altra risposta di Make continua i processi di biforcazione e in qualche luogo profondo circa 7000, la macchina virtuale si blocca in modo irreversibile. Tuttavia, con questa risposta è in grado di continuare indefinitamente senza consumare risorse di sistema. Sarai davvero in grado di rilassarti con questa build. Ho superato oltre 1.000.000 di iterazioni senza apparente degrado del sistema.

Nota ho dovuto aggiungere il sleep 1modo che il timestamp del makefile sia effettivamente aggiornato ogni volta. Puoi cambiarlo in sleep 0.01se vuoi che passi attraverso le iterazioni un po 'più velocemente.

— 5 giri
fonte

6

GNU Forth, 15 byte

golfed

: : [do] [loop]

Ridefinisce (ricompila) la parola :e invoca un ciclo infinito immediato [do] [loop]all'interno della nuova definizione (proprio al momento della compilazione).

Una categoria di parole non viene compilata. Queste cosiddette parole immediate vengono eseguite (eseguite ora) indipendentemente dal fatto che l'interprete di testo stia interpretando o compilando.

Provalo online!

— zeppelin
fonte

5

Clojure, 21 byte

(defmacro a[]`(a))(a)

Lega il compilatore definendo una macro che emette ripetutamente chiamate su se stessa.

Sul mio telefono, questo fa sì che REPL si blocchi e ritardi il dispositivo. Sul mio laptop, questo fallisce completamente con StackOverflow.

Sfortunatamente StackOverflow si verifica istantaneamente, ma è ancora valido secondo le regole.

— Carcigenicate
fonte

5

MSBuild, 130 byte

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <Target Name="X">
        <Exec Command="msbuild"/>
    </Target>
</Project>

Salvalo come file con .projestensione ed eseguilo msbuilddal prompt dei comandi. MSBuild eseguirà il suo unico obiettivo che genererà semplicemente un altro msbuildprocesso.

— Danko Durbić
fonte

Il rientro è necessario affinché funzioni? E le newline? Normalmente è possibile giocare a golf su spazi bianchi.

No, è solo più facile da leggere. Il conteggio dei personaggi non include gli spazi bianchi.

— Danko Durbić,

1

Ah giusto. In tal caso, dovresti probabilmente menzionarlo nel corpo del post.

5

C, 31 byte

main[-1llu]={1};

Ispirato al trauma digitale . Compila con la -mcmodel=mediumbandiera.

Buona fortuna compilando questo, avrai bisogno di 1,8 yottabyte di RAM e spazio su disco.

— MD XF
fonte

4

Mathematica 33 byte

Compile[{},Evaluate@While[True,]]

Il codice tenterà di valutare simbolicamente l'argomento prima della compilazione e l'argomento stesso è un ciclo infinito. La funzione While ha un secondo argomento nullo poiché non è importante.

— Kelly Lowder
fonte

"prima della compilazione" Sì ... no.

— CalculatorFeline

Fornisci un argomento valido. reference.wolfram.com/language/tutorial/…

— Kelly Lowder,

La domanda è: il loop si verifica durante la Compilechiamata o prima di esso?

— CalculatorFeline

3

Haskell _{^{(GHC, senza Template Haskell o regole di riscrittura personalizzate)}} , 138

{-#LANGUAGE FlexibleContexts,UndecidableInstances#-}
data A x=A
class C y where y::y
instance C(A(A x))=>C(A x)where y=A
main|A<-y=pure()

Teoricamente, questo entra in un ciclo infinito più o meno allo stesso modo dell'approccio C ++ : il metodo polimorfico yè istanziato a tipi sempre più contorti. In pratica, la dimensione dello stack assegnata predefinita trabocca rapidamente:

$ ghc-7.10 wtmpf-file14146.hs 
[1 of 1] Compiling Main             ( wtmpf-file14146.hs, wtmpf-file14146.o )

wtmpf-file14146.hs:5:9:
    Context reduction stack overflow; size = 101
    Use -fcontext-stack=N to increase stack size to N
      C (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A t0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
    In a stmt of a pattern guard for
                   an equation for ‘main’:
      A <- y
    In an equation for ‘main’: main | A <- y = pure ()

Crediti a Luke Palmer .

— cessò di girare in senso antiorario
fonte

1

Haskell (ghc), 32 + 2 = 34 byte

{-#RULES""main=main#-}
main=main

corri con ghc -O <file>. Attiva una regola di riscrittura per la funzione principale che riscrive nella stessa cosa. L'unica sfortunata caratteristica è che ghc è abbastanza intelligente da rilevare ciò e arrestarsi dopo 100 iterazioni. Non conosco un modo semplice per disabilitare questo comportamento.

— Programma man
fonte

1

Boo, 25 byte

macro l:
 x=0 while 1>0
l

Ciò definisce una macro, che viene eseguita in fase di compilazione, che esegue un ciclo infinito e quindi richiama la macro.

— Mason Wheeler
fonte

1

Ruggine, 18 byte

include!(file!());

Auto-inclusione classica. Rustc è comunque fastidiosamente sano e, di default, salterà fuori dopo 128 ricorsioni, e si espande in profondità prima, quindi neanche la crescita esponenziale funziona. Lo stesso vale per le soluzioni C e C ++.

— CensoredUsername
fonte

0

Fattore , 29 16

<< [ t ] loop >>

La parte tra << >>viene eseguita al momento dell'analisi.

Per quanto riguarda quello che [ t ] loopfa, ti farò indovinare ...

Puoi inserirlo nell'ascoltatore così com'è, oppure aggiungerlo a qualsiasi vocabolario o file di script con le relative informazioni sulla piastra di caldaia.

— fede s.
fonte

0

PHP, 19 byte

<?include __FILE__;

— MD XF
fonte

Il codice più corto per essere legalmente rimosso

specificazioni

Japt , 2 byte

Spiegazione

TikZ (pdfTeX 3.14159265-2.6-1.40.17), 85 79 74 24 22 21 byte

Cosa sta succedendo

C, 18 byte

Java, 102 95 89 88 78 byte

Che succede qui?

Risultato della compilazione

risparmi

GNU Makefile, 8 7 byte

Versione alternativa, 5 byte

C ++, 60 58

Perl , 15 13 byte

C ++, 37 30 29 byte

Lisp comune, 8 byte

TeX, 9 byte

Haskell, 25 + 17 = 42 byte

gradle, 10 9 byte

SWI-Prolog, 34 byte

Spiegazione

GNU Make, 44

GNU Forth, 15 byte

Clojure, 21 byte

MSBuild, 130 byte

C, 31 byte

Mathematica 33 byte

Haskell (GHC, senza Template Haskell o regole di riscrittura personalizzate) , 138

Haskell (ghc), 32 + 2 = 34 byte

Boo, 25 byte

Ruggine, 18 byte

Fattore , 29 16

PHP, 19 byte

Haskell _{^{(GHC, senza Template Haskell o regole di riscrittura personalizzate)}} , 138