Scrivi il programma più breve che genera la maggior parte degli avvisi e degli errori del compilatore


42

La sfida:

Scrivi un programma molto breve che, una volta compilato, crea la maggior quantità di avvisi ed errori del compilatore. Può essere scritto in qualsiasi linguaggio di programmazione.

punteggio:

Il punteggio è determinato da questa equazione: errors_and_warnings_length/code_length. Il punteggio più alto vince.

Esempio:

Il programma C # classè lungo 5 caratteri e genera 3 avvisi, che è un punteggio di (1/5) * 3 = 0,6.

MODIFICARE:

A causa di un po 'di confusione, i programmi devono essere lunghi almeno 1 carattere. Altrimenti otterrebbe un punteggio di infinito.


17
Mentre mi piace il concetto, trovo la metrica un po 'preoccupante. Quale compilatore? Quali impostazioni (soprattutto per quanto riguarda gli avvisi)? Voglio dire, gcc -Wall -pedanticè molto diverso da quello normale, gccè diverso da tccè presumibilmente diverso da qualche altro compilatore c.
dmckee,

2
Basta avere un compilatore in russo o tedesco, si ottengono alcuni errori LUNGHI (nessun gioco di
parole

2
Mi piacerebbe vedere le risposte in lingue diverse da C / C ++.
Ken Bloom,

4
Mi sarebbe piaciuto se la sfida era di generare il maggior numero di diversi errori possibili
Hannesh

3
Ahem. Altrimenti il ​​suo punteggio sarebbe indefinito .
wizzwizz4,

Risposte:


94

GCC, punteggio 2 200 /36 ≈ 4.5 × 10 58

#include __FILE__
#include __FILE__

In realtà non ho finito di compilare questo codice, ma basato su test e matematica semplice, dovrebbe produrre un totale di 2 200 #include nested too deeply errori.

Certo, il programma è banalmente estensibile. Aggiungendo una terza linea porta il punteggio massimo di 3 200 /54 ≈ 4,9 × 10 93 . Quattro linee danno 4 200 /72 ≈ 3,6 × 10 118 , e così via.


6
Risposta molto intelligente. +1
Prince John Wesley,

5
Molto intelligente sono d'accordo, ma lo considererei come 1 errore ("annidato troppo profondamente"), non un errore separato per ogni riga del backtrace.
Kevin,

1
@Kevin: Giusto per essere chiari, dovrebbe produrre quell'errore 2²⁰⁰ volte, una volta per ogni possibile percorso attraverso il quale è possibile raggiungere il limite di annidamento. Il fatto che ogni errore includa anche 200 righe di backtrace rende l'output ancora più dettagliato.
Ilmari Karonen,

1
Hmm. Potrei giurare quando l'ho provato ieri sera gcc è stato salvato dopo 1 errore, ma sembra che stia eseguendo la stampa più ora. Obiezione ritirata. Per inciso, è 200 dallo standard c?
Kevin,

1
@Kevin Per gcc.gnu.org/onlinedocs/gcc-4.8.2/cpp/Implementation-limits.html : " Imponiamo un limite arbitrario di 200 livelli [di nidificato #include], per evitare la ricorsione in fuga. Lo standard richiede almeno 15 livelli ".
zwol,

48

C, 0 caratteri - Punteggio = (1/0) * 1 = Infinito



genera 1 errore:

/usr/lib/gcc/i686-pc-linux-gnu/4.7.0/../../../crt1.o: In function `_start':
(.text+0x18): undefined reference to `main'
collect2: error: ld returned 1 exit status

Nota: http://ideone.com/xdoJyA


49
1/0 è indefinito, non "infinito".
Frank,

3
+1 Anche se 1/0 non è definito, è evidentemente più grande di uno diviso per un numero maggiore. 0 prende la torta.
jnm2,

6
@ jnm2 non ne sono sicuro. 1/0 non è definito e, sebbene il lato destro si avvicini a + infinito, ciò non rende affatto definito 1/0.
kaoD,

5
Poiché il dominio è positivo, penso che ciò che ho detto abbia senso. La teoria è divertente ma penso che qui abbiamo bisogno di buon senso. Ricorda gli errori del compilatore per la minima quantità di codice. Il limite è ovvio.
jnm2,

15
1.0 / 0.0 = + INF, almeno secondo IEEE 754 :) Quindi devi solo fare il calcolo in virgola mobile.
Keith Randall,

19

GCC, punteggio 5586,6 (e altro se necessario)

179 caratteri, 1000003 avvisi / errori (utilizzando -Wall)

#define E a,a,a,a,a,a,a,a,a,a
#define D E,E,E,E,E,E,E,E,E,E
#define C D,D,D,D,D,D,D,D,D,D
#define B C,C,C,C,C,C,C,C,C,C
#define A B,B,B,B,B,B,B,B,B,B
_(){A,A,A,A,A,A,A,A,A,A}

Questo può essere esteso arbitrariamente, ovviamente. Ad esempio, l'utilizzo di 10 #defines anziché 5 e una lunghezza di 20 "chiamate" anziché 10 porterebbe a un punteggio di circa (20 ** 10) / (179 * 4) = 14301675977.65 (e richiederebbe parecchio tempo per l'esecuzione ;)


7
Utilizzando #define X(A) A,A,A,A,A,A,Ae X(X(X(X(X(X(A))))))puoi duplicare il codice molto più velocemente.
ugoren,

12

GCC due volte, 86

22 caratteri, errori 1898 + avvisi sul mio sistema.
Sono sicuro che questo approccio può essere molto migliorato, scegliendo file più lunghi con nomi più brevi.

#include</usr/bin/gcc>

3
/usr/bin/gdbè significativamente più grande (5,5 M contro 760 K), ma /vmlinuza 5,6 M potrebbe essere la soluzione migliore.
wchargin

12

HQ9 ++, 1 (limite di (n + 29) / n)

Di seguito viene emesso un avviso Warning: this is not a quineper ogni Q nel codice.

QQQQQ...Q
Warning: this is not a quine

Piccolo va bene, vero? Hmm ...


FWIW, questo è uno scherzo. Se ciò non fosse ovvio.
stand del

10

C, .727

11 caratteri, 5 errori, 3 avvisi, (1/11) * 8 = .727273

m(;){@,x}2

cc -g -Wall    er.c   -o er
er.c:1: error: expected declaration specifiers or '...' before ';' token
er.c:1: warning: return type defaults to 'int'
er.c: In function 'm':
er.c:1: error: stray '@' in program
er.c:1: error: expected expression before ',' token
er.c:1: error: 'x' undeclared (first use in this function)
er.c:1: error: (Each undeclared identifier is reported only once
er.c:1: error: for each function it appears in.)
er.c:1: warning: left-hand operand of comma expression has no effect
er.c:1: warning: control reaches end of non-void function
er.c: At top level:
er.c:1: error: expected identifier or '(' before numeric constant


Conto 5 errori, più 3 avvertimenti
Kevin,

Suppongo tu abbia ragione. Stavo contando le stringhe "error:" e "warning:".
luser droog

5
Penso che tu vinca se contiamo solo errori / avvertenze diverse.
ugoren,

Se -Werror viene utilizzato nella riga di comando, gli avvisi vengono promossi a errori. Inoltre, quale compilatore C utilizzato influenzerà il numero di errori segnalati (o se -Werror è disponibile, ecc.) Si potrebbe sostenere che la lunghezza della riga di comando per l'invocazione potrebbe essere conteggiata come parte della lunghezza del "programma" ... e ogni la versione del compilatore su ciascuna piattaforma è una categoria separata. :-)
Dr. Rebmu

8

NASM, punteggio 63/40 * 2 ^ 32 ≈ 2.905 * 10 ^ 19

%rep 1<<32
%rep 1<<32
!
%endrep
%endrep

Verrà emesso c.asm:3: error: label or instruction expected at start of line2 ^ 64 volte. Anche in questo caso è facilmente estendibile a output molto più grandi.


2

C ++ 98 (211 byte) g ++ - 5 (Ubuntu 5.2.1-23ubuntu1 ~ 12.04) 5.2.1 0151031

Volevo vedere quanto potevo fare in C ++ senza usare il preprocessore. Questo programma produce 2.139.390.572 byte di output, la maggior parte dei quali è un singolo messaggio di errore.

template<int i,class S,class T>struct R{typedef R<i,typename R<i-1,S,S>::D,typename R<i-1,S,S>::D>D;};template<class S,class T>struct R<0,S,T>{typedef S D;};void f(){R<27,float,R<24,int*const*,int>::D>::D&E=4;}

me@Basement:~/src/junk$ ls -l a.C
-rw-rw-r-- 1 me me 211 Apr 27 21:44 a.C
me@Basement:~/src/junk$ g++-5 a.C -fmax-errors=1 2>a.C.errors.txt
me@Basement:~/src/junk$ ls -l a.C.errors.txt 
-rw-rw-r-- 1 me me 2139390572 Apr 27 22:01 a.C.errors.txt

Ungolfed:

template <int i, class S, class T>
struct R {
    typedef R<i, typename R<i-1,S,S>::D, typename R<i-1,S,S>::D> D;
};
template <class S, class T>
struct R<0, S, T> {
    typedef S D;
};
void f() {
    R<27, float, R<24, int*const*, int>::D>::D &E = 4;
}

Questo programma funziona definendo un modello di struttura ricorsiva R che contiene un typedef D contenente due copie di R. Ciò si traduce in un nome di tipo che cresce in modo esponenziale, che viene stampato per intero nel messaggio di errore. Sfortunatamente, g ++ sembra soffocare mentre tenta di stampare un messaggio di errore più lungo di (1 << 31) byte. 2.139.390.572 byte era il più vicino che potevo arrivare al limite senza andare oltre. Sono curioso di 27, float, 24, int*const*sapere se qualcuno può regolare i limiti di ricorsione e i tipi di parametri per avvicinarsi al limite (o trovare un compilatore in grado di stampare un messaggio di errore ancora più lungo).

Estratti dal messaggio di errore:

a.C: In function ‘void f()’:
a.C:1:208:  error:  invalid  initialization  of non-const reference of type
‘R<27, float, R<24, R<23, R<22, R<21, R<20, R<19, R<18, R<17, R<16, R<15,
R<14,  R<13, R<12, R<11, R<10, R<9, R<8, R<7, R<6, R<5, R<4, R<3, R<2, R<1,
int* const*, int* const*>, R<1, int* const*, int* const*> >, R<2, R<1, int*
const*,  int*  const*>,  R<1, int* const*, int* const*> > >, R<3, R<2, R<1,
int* const*, int* const*>, R<1, int* const*, int* const*> >, R<2, R<1, int*
const*,  int* const*>, R<1, int* const*, int* const*> > > >, R<4, R<3, R<2,
R<1, int* const*, int* const*>, R<1,
...
int*  const*,  int*  const*>  > > > > > > > > > > > > > > > > > > > > > > >
>::D& {aka R<27, R<26, R<25, R<24, R<23,  R<22,  R<21,  R<20,  R<19,  R<18,
R<17,  R<16,  R<15,  R<14, R<13, R<12, R<11, R<10, R<9, R<8, R<7, R<6, R<5,
R<4, R<3, R<2, R<1, float, float>, R<1, float, float> >, R<2,  R<1,  float,
float>,  R<1,  float, float> > >, R<3, R<2, R<1, float, float>, R<1, float,
float> >, R<2, R<1, float, float>, R<1, float, float> > > >, R<4, 
...
, R<1, float, float>, R<1, float, float> > >, R<3, R<2, R<1, float, float>,
R<1, float, float> >, R<2, R<1, float, float>, R<1, float, float> > > > > >
>  >  >  >  >  >  > > > > > > > > > > > > > > >&}’ from an rvalue of type
‘int’
    template<int    i,class   S,class   T>struct   R{typedef   R<i,typename
R<i-1,S,S>::D,typename  R<i-1,S,S>::D>D;};template<class  S,class  T>struct
R<0,S,T>{typedef                         S                         D;};void
f(){R<27,float,R<24,int*const*,int>::D>::D&E=4;}


                                                        ^
compilation terminated due to -fmax-errors=1.

2.139.390.572 byte / 211 byte = 10.139.291,8


Questo è il motivo per cui utilizzo sempre STLfilt ... Benvenuti in PPCG! Questa è un'ottima prima presentazione!
Mego

1
Sfortunatamente sembra che ho capito male la sfida; sembra che gli invii siano classificati in base al numero di messaggi di errore, non al conteggio dei byte. Ovviamente la mia voce con 1 errore non è molto competitiva. Forse la mia risposta dovrebbe essere spostata qui
Calcolo del dado

-1

SmileBASIC, 1/1 = 1

A

Genera l'errore Syntax Error in 0:1


SB genera sempre e solo un errore alla volta, quindi questa è davvero l'unica risposta che puoi fare.
snail_
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.