Le défi:

Ecrivez un programme très court qui, une fois compilé, crée le plus grand nombre d’avertissements et d’erreurs du compilateur. Il peut être écrit dans n’importe quel langage de programmation.

Notation:

Le score est déterminé par cette équation: errors_and_warnings_length/code_length. Le score le plus élevé gagne.

Exemple:

Le programme C # class longueur de 5 caractères et génère 3 avertissements, soit un score de (1/5) * 3 = 0,6.

MODIFIER:

En raison d'une certaine confusion, les programmes doivent durer au moins 1 caractère. Sinon, cela donnerait un score d'infini.

17

Bien que j'aime le concept, je trouve la métrique un peu inquiétante. Quel compilateur? Quels paramètres (notamment en ce qui concerne les avertissements)? Je veux dire gcc -Wall -pedanticest très différent de plain ol` gccest différent de tccprobablement un autre compilateur C.

dmckee

2

Procurez - vous un compilateur en russe ou allemand, vous obtenez des erreurs LONGUES (sans jeu de mots)

ζ--

2

J'aimerais voir des réponses dans des langages autres que le C / C ++.

Ken Bloom

4

J'aurais aimé que le défi consiste à générer autant d' erreurs différentes que possible

Hannesh

3

Ahem. Sinon, son score serait indéfini .

wizzwizz4

94

GCC, partition 2 ²⁰⁰ /36 ≈ 4,5 × 10 ⁵⁸

#include __FILE__
#include __FILE__

Je n'ai pas encore fini de compiler ce code, mais d'après des tests et des calculs mathématiques simples, il devrait générer un total de 2 ²⁰⁰ #include nested too deeply erreurs.

Bien sûr, le programme est trivialement extensible. L' ajout d' une troisième ligne amène le score à 3 ²⁰⁰ /54 ≈ 4,9 × 10 ⁹³ . Quatre lignes donnent 4 ²⁰⁰ /72 ≈ 3,6 × 10 ¹¹⁸ , et ainsi de suite.

Ilmari Karonen
la source

6

Réponse très intelligente. +1

Prince John Wesley

5

Très intelligent, je suis d’accord, mais je considérerais cela comme une erreur ("imbriquée trop profondément") et non comme une erreur distincte pour chaque ligne de la trace arrière.

Kevin

1

@ Kevin: Juste pour clarifier, cela devrait générer cette erreur deux fois et demie, une fois pour chaque chemin possible par lequel la limite d'imbrication peut être atteinte. Le fait que chaque erreur comporte également 200 lignes de trace rend la sortie encore plus prolixe.

Ilmari Karonen

1

Hmm. Je pourrais jurer que lorsque j’ai essayé la nuit dernière, gcc s’est libéré après une erreur, mais il semble que l’impression continue de tourner. Objection retirée. Incidemment, 200 de la norme c?

Kevin

1

@Kevin Per gcc.gnu.org/onlinedocs/gcc-4.8.2/cpp/Implementation-limits.html : "Nous imposons une limite arbitraire de 200 niveaux [d'imbriqués #include], pour éviter une récursion effrénée. La norme requiert au moins 15 les niveaux."

Zwol

48

C, 0 caractères - Score = (1/0) * 1 = Infini

génère 1 erreur:

/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

Remarque: http://ideone.com/xdoJyA

l0n3sh4rk
la source

49

1/0 est indéfini, pas "infini".

Frank

3

+1 Même si 1/0 n'est pas défini, il est manifestement supérieur à un divisé par un nombre plus important. 0 prend le gâteau.

Jnm2

6

@ Jnm2 pas sûr à ce sujet. 1/0 n'est pas défini et, bien que le côté droit s'approche + l'infini, cela ne définit pas du tout 1/0.

kaoD

5

Comme le domaine est positif, je pense que ce que j'ai dit est logique. La théorie est amusante mais je pense que nous avons besoin de bon sens ici. Le plus d'erreurs du compilateur pour le moins de code, souvenez-vous. La limite est évidente.

Jnm2

15

1.0 / 0.0 = + INF, du moins selon IEEE 754 :) Il suffit donc de faire le calcul en virgule flottante.

Keith Randall

19

GCC, score 5586.6 (et plus si nécessaire)

179 caractères, 1000003 avertissements / erreurs (utilisation -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}

Cela peut être étendu arbitrairement, bien sûr. Par exemple, utiliser 10 #defines au lieu de 5 et une longueur de 20 "appels" au lieu de 10 donnerait un score d'environ (20 ** 10) / (179 * 4) = 14301675977.65 (et prendrait un certain temps à courir ;)

schnaader
la source

7

En utilisant #define X(A) A,A,A,A,A,A,Aet X(X(X(X(X(X(A))))))vous pouvez dupliquer le code beaucoup plus rapidement.

Ugoren

12

GCC deux fois, 86

22 caractères, 1898 erreurs + avertissements sur mon système.
Je suis sûr que cette approche peut être grandement améliorée en choisissant des fichiers plus longs avec des noms plus courts.

#include</usr/bin/gcc>

Ugoren
la source

3

/usr/bin/gdbest nettement plus grande (5,5 M contre 760 K), mais /vmlinuzà 5,6 M pourrait être votre meilleur pari.

wchargin

12

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

Ce qui suit émet l'avertissement Warning: this is not a quinepour chaque Q dans le code.

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

Petit c'est bien, non? Hmm ...

boothby
la source

FWIW, c'est une blague. Si ce n'était pas évident.

Boothby

10

C, .727

11 caractères, 5 erreurs, 3 avertissements, (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
la source

Je compte 5 erreurs, plus 3 avertissements

Kevin,

Je suppose que tu as raison. Je comptais les chaînes "error:" et "warning:".

Luser droog

5

Je pense que vous gagnez si nous ne comptons que différentes erreurs / avertissements.

Ugoren

Si -Werror est utilisé sur la ligne de commande, les avertissements sont promus en erreurs. Et aussi, quel compilateur C utilisé affectera le nombre d'erreurs signalées (ou si -Werror est disponible, etc.) On pourrait dire que la longueur de la ligne de commande pour l'invocation pourrait être comptée dans la longueur du "programme" ... et chaque La version du compilateur sur chaque plate-forme est une catégorie distincte. :-)

Dr. Rebmu

8

MSNA, score de 63/40 * 2 ^ 32 ≈ 2,905 * 10 ^ 19

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

Sortie c.asm:3: error: label or instruction expected at start of line2 ^ 64 fois. Encore une fois, ceci est facilement extensible à des sorties beaucoup plus grandes.

copie
la source

2

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

Je voulais voir comment je pouvais faire en C ++ sans utiliser le préprocesseur. Ce programme produit 2 139 390 572 octets de sortie, dont la plupart sont un seul message d'erreur.

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

Ce programme fonctionne en définissant un modèle de structure récursif R qui contient une typedef D contenant deux copies de R. Il en résulte un nom de type à croissance exponentielle, qui est imprimé intégralement dans le message d'erreur. Malheureusement, g ++ semble s’étouffer en essayant d’imprimer un message d’erreur de plus de (1 << 31) octets. 2 139 390 572 octets était le nombre le plus proche auquel je pouvais me rendre sans dépasser la limite. Je suis curieux de savoir si quelqu'un peut ajuster les limites de récursivité et les types de paramètres27, float, 24, int*const* pour se rapprocher de la limite (ou trouver un compilateur pouvant imprimer un message d'erreur encore plus long).

Extraits du message d'erreur:

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 592 octets / 211 octets = 10 139 291,8~~

Noix de calcul
la source

C'est pourquoi j'utilise toujours STLfilt ... Bienvenue dans PPCG! C'est une excellente première soumission!

Mego

1

Malheureusement, il semble que j'ai mal compris le défi. il semble que les soumissions sont notées en fonction du nombre de messages d'erreur et non du nombre d'octets. De toute évidence, mon erreur 1 entrée n’est pas très compétitive. Peut-être que ma réponse devrait être déplacée ici

Calculating Nut

-1

SmileBASIC, 1/1 = 1

Génère l'erreur Syntax Error in 0:1

12Me21
la source

SB ne générant qu'une erreur à la fois, il s'agit donc de la seule réponse que vous puissiez faire.

snail_

Écrivez le programme le plus court qui génère le plus grand nombre d'avertissements et d'erreurs du compilateur

Le défi:

Notation:

Exemple:

MODIFIER:

Réponses:

GCC, partition 2 ²⁰⁰ /36 ≈ 4,5 × 10 ⁵⁸

C, 0 caractères - Score = (1/0) * 1 = Infini

GCC, score 5586.6 (et plus si nécessaire)

GCC deux fois, 86

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

C, .727

MSNA, score de 63/40 * 2 ^ 32 ≈ 2,905 * 10 ^ 19

SmileBASIC, 1/1 = 1

Écrivez le programme le plus court qui génère le plus grand nombre d'avertissements et d'erreurs du compilateur

Le défi:

Notation:

Exemple:

MODIFIER:

Réponses:

GCC, partition 2 200 /36 ≈ 4,5 × 10 58

C, 0 caractères - Score = (1/0) * 1 = Infini

GCC, score 5586.6 (et plus si nécessaire)

GCC deux fois, 86

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

C, .727

MSNA, score de 63/40 * 2 ^ 32 ≈ 2,905 * 10 ^ 19

SmileBASIC, 1/1 = 1

GCC, partition 2 ²⁰⁰ /36 ≈ 4,5 × 10 ⁵⁸