Các thách thức:

Viết một chương trình rất ngắn mà khi được biên dịch sẽ tạo ra nhiều cảnh báo và lỗi trình biên dịch nhất. Nó có thể được viết bằng bất kỳ ngôn ngữ lập trình nào.

Ghi điểm:

Điểm số được xác định bởi phương trình này : errors_and_warnings_length/code_length. Điểm số cao nhất chiến thắng.

Thí dụ:

Chương trình C # classdài 5 ký tự và tạo ra 3 cảnh báo, đó là số điểm (1/5) * 3 = 0,6.

BIÊN TẬP:

Vì một số nhầm lẫn, các chương trình phải dài ít nhất 1 char. Nếu không nó sẽ nhận được một số điểm vô cùng.

GCC, ghi bàn thắng 2 ²⁰⁰ /36 ≈ 4,5 × 10 ⁵⁸

#include __FILE__
#include __FILE__

Tôi chưa thực sự hoàn thành việc biên dịch mã này, nhưng dựa trên thử nghiệm và toán học đơn giản, nó sẽ tạo ra tổng cộng 2 ²⁰⁰ #include nested too deeply lỗi.

Tất nhiên, chương trình là mở rộng tầm thường. Thêm một dòng thứ ba mang lại tỷ số lên đến 3 ²⁰⁰ /54 ≈ 4,9 × 10 ⁹³ . Bốn dòng cung cấp cho 4 ²⁰⁰ /72 ≈ 3.6 × 10 ¹¹⁸ , và vân vân.

C, 0 ký tự - Điểm = (1/0) * 1 = Vô cực

tạo 1 lỗi:

/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

Lưu ý: http://ideone.com/xdoJyA

GCC, điểm 5586,6 (và hơn thế nữa nếu cần)

179 ký tự, 1000003 cảnh báo / lỗi (sử dụng -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}

Điều này có thể được mở rộng tùy ý, tất nhiên. Ví dụ: sử dụng 10 #definegiây thay vì 5 và độ dài 20 "cuộc gọi" thay vì 10 sẽ dẫn đến số điểm khoảng (20 ** 10) / (179 * 4) = 14301675977,65 (và sẽ mất khá nhiều thời gian để chạy ;)

GCC hai lần, 86

22 ký tự, 1898 lỗi + cảnh báo trên hệ thống của tôi.
Tôi chắc rằng phương pháp này có thể được cải thiện hơn nhiều, bằng cách chọn các tệp dài hơn với tên ngắn hơn.

#include</usr/bin/gcc>

HQ9 ++, 1 (giới hạn của (n + 29) / n)

Sau đây phát ra cảnh báo Warning: this is not a quinecho mỗi Q trong mã.

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

Nhỏ là tốt, phải không? Hừm ...

C, .727

11 ký tự, 5 lỗi, 3 cảnh báo, (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

NASM, điểm 63/40 * 2 ^ 32 2.905 * 10 ^ 19

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

Sẽ xuất c.asm:3: error: label or instruction expected at start of line2 ^ 64 lần. Một lần nữa điều này dễ dàng mở rộng cho đầu ra lớn hơn nhiều.

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

Tôi muốn xem tôi có thể làm tốt như thế nào trong C ++ mà không cần sử dụng bộ tiền xử lý. Chương trình này tạo ra 2.139.390.572 byte đầu ra, hầu hết là một thông báo lỗi.

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

Ung dung:

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

Chương trình này hoạt động bằng cách xác định một mẫu cấu trúc đệ quy R chứa một typedef D chứa hai bản sao của R. Điều này dẫn đến một tên loại phát triển theo cấp số nhân, được in đầy đủ trong thông báo lỗi. Thật không may, g ++ dường như bị nghẹt thở trong khi cố gắng in một thông báo lỗi dài hơn (1 << 31) byte. 2.139.390.572 byte là mức gần nhất mà tôi có thể đạt đến giới hạn mà không cần vượt qua. Tôi tò mò liệu có ai có thể điều chỉnh các giới hạn đệ quy và các loại tham số 27, float, 24, int*const*để tiến gần hơn đến giới hạn không (hoặc tìm một trình biên dịch có thể in một thông báo lỗi thậm chí dài hơn).

Đoạn trích từ thông báo lỗi:

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

SmileBASIC, 1/1 = 1

A

Tạo ra lỗi Syntax Error in 0:1