Escriba el programa más corto que genere la mayor cantidad de advertencias y errores del compilador.

42

El reto:

Escriba un programa muy corto que, cuando se compila, crea la mayor cantidad de advertencias y errores del compilador. Se puede escribir en cualquier lenguaje de programación.

Tanteo:

La puntuación se determina por la siguiente ecuación: errors_and_warnings_length/code_length. La puntuación más alta gana.

Ejemplo:

El programa C # classtiene 5 caracteres de largo y genera 3 advertencias, que es una puntuación de (1/5) * 3 = 0.6.

EDITAR:

Debido a cierta confusión, los programas deben tener al menos 1 char de largo. De lo contrario, obtendría una puntuación de infinito.

MD XF
fuente
17
Si bien me gusta el concepto, la métrica me parece un poco preocupante. Que compilador ¿Qué ajustes (especialmente con respecto a las advertencias)? Quiero decir, gcc -Wall -pedantices muy diferente de simple ol` gcces diferente de tcces presumiblemente diferente de algún otro compilador de c.
dmckee
2
Solo obtén un compilador en ruso o alemán, obtienes algunos errores
LARGOS
2
Me encantaría ver respuestas en lenguajes distintos de C / C ++.
Ken Bloom
44
Me hubiera gustado que el desafío fuera generar tantos errores diferentes como sea posible
Hannesh
3
Ejem. De lo contrario, su puntaje sería indefinido .
wizzwizz4

Respuestas:

94

GCC, la puntuación de 2 200 /36 ≈ 4,5 × 10 58

#include __FILE__
#include __FILE__

En realidad no he terminado de compilar este código, pero basado en pruebas y matemáticas simples, debería producir un total de 2 200 #include nested too deeply errores.

Por supuesto, el programa es trivialmente extensible. La adición de una tercera línea trae la puntuación hasta 3 200 /54 ≈ 4,9 × 10 93 . Cuatro líneas dan 4 200 /72 ≈ 3,6 × 10 118 , y así sucesivamente.

Ilmari Karonen
fuente
66
Muy inteligente respuesta. +1
Príncipe John Wesley
55
Muy inteligente, estoy de acuerdo, pero lo consideraría como un error ("anidado demasiado profundo"), no un error separado para cada línea de la traza inversa.
Kevin
1
@Kevin: Solo para que quede claro, debería producir ese error 2²⁰⁰ veces, una por cada posible ruta por la cual se pueda alcanzar el límite de anidamiento. El hecho de que cada error también incluya 200 líneas de traza inversa hace que la salida sea aún más detallada.
Ilmari Karonen
1
Hmm Podría jurar cuando lo probé anoche gcc rescató después de 1 error, pero parece estar imprimiendo más ahora. Objeción retirada. Por cierto, ¿200 del estándar c?
Kevin
1
@Kevin Per gcc.gnu.org/onlinedocs/gcc-4.8.2/cpp/Implementation-limits.html : " Imponemos un límite arbitrario de 200 niveles [de anidados #include], para evitar la recurrencia fuera de control. El estándar requiere al menos 15 niveles ".
zwol
48

C, 0 caracteres - Puntuación = (1/0) * 1 = Infinito



genera 1 error:

/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

l0n3sh4rk
fuente
49
1/0 es indefinido, no "infinito".
Frank
3
+1 Incluso si 1/0 no está definido, es demostrablemente mayor que uno dividido por cualquier número mayor. 0 toma el pastel.
jnm2
66
@ jnm2 no estoy seguro de eso. 1/0 no está definido y, aunque el lado derecho se aproxima a + infinito, eso no hace que 1/0 esté definido en absoluto.
kaoD
55
Como el dominio es positivo, creo que lo que dije tiene sentido. La teoría es divertida, pero creo que necesitamos algo de sentido común aquí. Recuerde la mayoría de los errores de compilación para la menor cantidad de código. El límite es obvio.
jnm2
15
1.0 / 0.0 = + INF, al menos de acuerdo con IEEE 754 :) Por lo tanto, solo tiene que hacer el cálculo en coma flotante.
Keith Randall
19

GCC, puntaje 5586.6 (y más si es necesario)

179 caracteres, 1000003 advertencias / errores (usando -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}

Esto puede extenderse arbitrariamente, por supuesto. Por ejemplo, usar 10 #defines en lugar de 5 y una duración de 20 "llamadas" en lugar de 10 conduciría a una puntuación de aproximadamente (20 ** 10) / (179 * 4) = 14301675977.65 (y tomaría bastante tiempo ejecutarlo) ;)

Schnaader
fuente
77
Usando #define X(A) A,A,A,A,A,A,Ay X(X(X(X(X(X(A))))))puede duplicar el código mucho más rápido.
Ugoren
12

CCG dos veces, 86

22 caracteres, 1898 errores + advertencias en mi sistema.
Estoy seguro de que este enfoque se puede mejorar mucho, eligiendo archivos más largos con nombres más cortos.

#include</usr/bin/gcc>
Ugoren
fuente
3
/usr/bin/gdbes significativamente más grande (5.5M vs 760K), pero /vmlinuza 5.6M podría ser su mejor apuesta.
wchargin
12

HQ9 ++, 1 (límite de (n + 29) / n)

Lo siguiente emite la advertencia Warning: this is not a quinepara cada Q en el código.

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

Lo pequeño es bueno, ¿verdad? Hmm ...

boothby
fuente
FWIW, esto es una broma. Si eso no fuera obvio.
stand
10

C, .727

11 caracteres, 5 errores, 3 advertencias, (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

luser droog
fuente
Cuento 5 errores, más 3 advertencias
Kevin
Supongo que tienes razón. Estaba contando las cadenas "error:" y "advertencia:".
luser droog
55
Creo que ganas si solo contamos diferentes errores / advertencias.
ugoren
Si se usa -Werror en la línea de comando, las advertencias se convierten en errores. Y también, qué compilador de C utilizado afectará el número de errores reportados (o si -Werror está disponible, etc.) Se podría argumentar que la longitud de la línea de comando para invocación podría contarse como parte de la longitud del "programa" ... y cada La versión del compilador en cada plataforma es una categoría separada. :-)
Dr. Rebmu
8

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

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

Producirá c.asm:3: error: label or instruction expected at start of line2 ^ 64 veces. Nuevamente, esto es fácilmente extensible a salidas mucho más grandes.

dupdo
fuente
2

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

Quería ver qué tan bien podría hacerlo en C ++ sin usar el preprocesador. Este programa produce 2,139,390,572 bytes de salida, la mayoría de los cuales es un mensaje de error único.

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

Sin golf:

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;
}

Este programa funciona definiendo una plantilla de estructura recursiva R que contiene un typedef D que contiene dos copias de R. Esto da como resultado un nombre de tipo que crece exponencialmente, que se imprime en su totalidad en el mensaje de error. Desafortunadamente, g ++ parece ahogarse al intentar imprimir un mensaje de error de más de (1 << 31) bytes. 2,139,390,572 bytes fue lo más cerca que pude llegar al límite sin pasar. Tengo curiosidad por saber si alguien puede ajustar los límites de recursión y los tipos de parámetros 27, float, 24, int*const*para acercarse al límite (o encontrar un compilador que pueda imprimir un mensaje de error aún más largo).

Extractos del mensaje de error:

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 bytes / 211 bytes = 10,139,291.8

Tuerca calculadora
fuente
Es por eso que siempre uso STLfilt ... ¡Bienvenido a PPCG! ¡Esta es una gran primera presentación!
Mego
1
Desafortunadamente parece que entendí mal el desafío; parece que los envíos se puntúan por el número de mensajes de error, no por el recuento de bytes. Obviamente mi entrada de 1 error no es muy competitiva. Quizás mi respuesta debería trasladarse aquí
Cálculo de la tuerca
-1

SmileBASIC, 1/1 = 1

A

Genera el error Syntax Error in 0:1

12Me21
fuente
SB solo genera un error a la vez, por lo que esta es realmente la única respuesta que puede dar.
caracol_