Lấy cảm hứng từ câu hỏi này trên SO , nhiệm vụ của bạn là tạo ra một chương trình hợp lệ trong (ít nhất) hai phiên bản chính của ngôn ngữ bạn đã chọn tạo ra đầu ra khác nhau.

Quy tắc

• Bất kỳ ngôn ngữ nào có nhiều hơn một phiên bản chính đều có thể được sử dụng.
  • Với mục đích của thử thách này, tôi sẽ đề xuất một "phiên bản chính" là nơi số đầu tiên trong số phiên bản thay đổi.
    • PHP 4 và PHP 5 khác nhau, PHP 5.3 và PHP 5.4 thì không.
  • Tuy nhiên, vì tôi không biết sơ đồ phiên bản cho tất cả các ngôn ngữ, nếu bạn có thể tranh luận về trường hợp của mình đủ tốt, tôi chắc chắn cộng đồng sẽ xác định xem bạn có công bằng khi tự xác định "phiên bản chính" không.
• Mã phải được biên dịch và chạy với cùng một cờ và nhập vào mỗi lần
  • Ngoại trừ thay đổi phiên bản của ngôn ngữ nếu điều này thích hợp
• Lỗi không được tính là đầu ra và câu trả lời tạo ra lỗi không đủ tiêu chuẩn (thay vì đầu ra lỗi chỉ bị bỏ qua)
• Chương trình không nên có đầu vào nào khác ngoài yêu cầu để làm cho nó chạy.
• Đối với mỗi phiên bản đã cho, đầu ra phải luôn giống nhau
• Ý định là sự thay đổi sẽ là hậu quả của sự thay đổi về thông số ngôn ngữ thay vì thông số kỹ thuật VM hoặc siêu dữ liệu môi trường

Chấm điểm

• chấm điểm loại mã golf cho chiều dài, vì vậy +1đối với mỗi char / byte
• -1cho mỗi ký tự khác nhau về độ dài của đầu ra.
  • ví dụ: đầu ra Phiên bản 1 abcde(5 ký tự), đầu ra Phiên bản 2 123abc(6 ký tự) =-1

Các quy tắc khác

• Ngoại lệ tiêu chuẩn được áp dụng - không có chương trình bên ngoài, yêu cầu web, v.v.
• Chương trình của bạn sẽ chấm dứt (trong vòng 2 giây)
• Điểm số thấp nhất chiến thắng.

"Ghi điểm" tốt hơn

Giữ câu trả lời ban đầu của bạn, vì lợi ích của sự công bằng, tôi sẽ đánh dấu người chiến thắng dựa trên các quy tắc ban đầu.

Vì điểm ban đầu của tôi bị hỏng cơ bản, tại sao không chấm lại / thử lại với hệ thống tính điểm sau:

• chấm điểm loại mã golf cho chiều dài, vì vậy +1đối với mỗi char / byte
• +1cho mỗi nhân vật khác nhau về chiều dài đầu ra
  • abcdevà 123456->+1
• -1cho mỗi khác biệt ký tự duy nhất trong đầu ra (giới hạn theo chiều dài của đầu ra ngắn nhất)
  • abcdevà 123456->-5
  • 12345và 123456->-1
  • 12345và 123455->0
• Điểm gần nhất với chiến thắng bằng không
• Trong trường hợp nghỉ giải lao thứ hai, điểm số mã golf đơn giản sẽ thắng.

Câu trả lời sửa đổi cho hệ thống tính điểm "tốt hơn"

C89 / C99, Điểm: 0

Chương trình của tôi dài 52 ký tự và sử dụng cùng một cơ chế như trong câu trả lời ban đầu của tôi để đạt được đầu ra khác nhau. Điều này hoạt động vì C89 không coi //là một nhận xét:

i=32;main(){putchar(i+++0//**/
+52)&&i<84&&main();}

Kết quả:

$ ./diff2c89
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS
$ ./diff2c99
TUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂Çüéâäàåç
$ ./diff2c99 | wc
      0       1      52
$ ./diff2c89 | wc
      0       1      52
$ wc diff2.c
      1       2      52 diff2.c

Câu trả lời cũ:

C89 / C99, Điểm: -Không hiệu quả?

Tôi không hoàn toàn chắc chắn nếu chương trình này không vi phạm các quy tắc, nhưng đừng bận tâm. Chương trình này khai thác thực tế là trong C89 //không phải là một nhận xét hợp lệ nhưng/* ... */ là.

Sử dụng thủ thuật nhận xét, một chức năng khác được thực thi. Trong C89, chức năng chỉ in "trolololol..."cho đến khi ngăn xếp tràn ra (vì vậy nó có thể kết thúc trong vòng 2 giây).

f1(){printf("ol");f1();}
f2(){printf("oll");}
main(){
    printf("tr");
    void (*f[])() = {f1,f2};
    f[0 //* trollololol */
      +1]();
}

C99

$ ./diffc99
troll

C89

$ ./diffc89
trolololololololololololololololololololololololololololololololololololololololololo
lolololololololololololololololololololololololololololololololololololololololololol
ololololololololololololololololololololololololol ....

Python - ít hơn 10 điểm so với câu trả lời hay nhất tiếp theo

print(range(100))

Trong Python 2, điều này sẽ in toàn bộ danh sách các số nguyên từ 0 đến 99.

Trong Python 3, range là một trình tạo và do đó, nó sẽ chỉ in "phạm vi (0,100)".

Thấy rằng tôi chưa bao giờ gặp phải giới hạn kích thước đối với các số trong Python, tôi có thể thay thế 100 đó bằng một số lớn hơn nhiều (ví dụ 2 ** 1000) và kết thúc với sự khác biệt gần như vô hạn trong đầu ra.

Được chỉnh sửa để phản ánh thực tế rằng, trong khi tôi có thể đạt được số điểm cực kỳ thấp cho bất kỳ mục đích thực tế nào, tôi không thể đạt đến vô hạn thực tế với một chương trình chấm dứt dưới 2 giây

Đối với hệ thống tính điểm tie-breaker được cập nhật, tôi sẽ gửi:

print(range(4))

Đầu ra:

Con trăn 2: [0, 1, 2, 3]

Con trăn 3: range(0, 4)

Bản in đầu tiên có 5 ký tự duy nhất ( [123]), bản in thứ hai có 8 ký tự duy nhất ( range(4)), sự khác biệt về độ dài đầu ra là 1, mã có 15 ký tự, đầu ra ngắn nhất là 11 ký tự ... các quy tắc này khá khó hiểu nhưng Tôi nghĩ rằng điều này mang lại cho tôi điểm số cuối cùng là 15 + 1 phút (11,5 + 8) = 5.

Con trăn - 0 điểm

Không biết cái này hoạt động như thế nào: P Chỉ vấp phải nó trong khi thử mã ngẫu nhiên.

int

Trên Python 3, nó <class 'int'>và trên Python 2, nó <type 'int'>(sử dụng bảng điều khiển tương tác)
Điểm "Tốt hơn": 3 (chiều dài) + 1 (char diff.) - 4 (ký tự duy nhất)

Python cũ hơn 1 - 7 điểm

print()

Cảm ơn rất nhiều đến @grc cho phiên bản này và giúp tôi trừ bốn điểm!

Trong Python 2, câu lệnh này được hiểu là print ()in ra bộ dữ liệu trống ().
Trong Python 3, đây printlà một hàm và kết quả là không có gì được in.
Điểm "Tốt hơn": 7 (chiều dài) + 2 (char diff.) - 2 (ký tự duy nhất)

Python cũ hơn 2 - 13 điểm:

print(1,2)

Điểm "Tốt hơn": 12 (chiều dài) + 2 (char diff. O / p) - 1 (ký tự duy nhất o / p)

Tôi biết điều này sẽ không chiến thắng nhưng vẫn đưa ra câu trả lời, vì đây là lần thử Python đầu tiên của tôi :)

C #

Tôi cũng đã thay đổi thuật toán suy luận kiểu phương thức chung giữa C # 2, 3 và 4. Ví dụ:

using System;
class C
{
  static int M<T>(T x, T y) { return 1; }
  static int M(object x, object y) { return 2; }
  static void Main() 
  {
    Console.WriteLine(M(1, new int?()));
  }
}

Trong C # 2 phương pháp loại suy luận nói rằng T không thể được cả hai intvà int?, và do đó tạo ra 2. Trong phương pháp C # 3, suy luận kiểu "thỏa hiệp tốt nhất giữa intvà int?là int?" và do đó chọn M<int?>và tạo 1.

Ruby, 4 ký tự + 0 chênh lệch độ dài char - 3 chênh lệch char duy nhất = điểm 1

p ?d

Trên Ruby 1.9, nó sẽ in "d". Trên 1.8, nó in 100.

Giải thích: ?dlà "d"trong 1.9 và 100(mã ASCII cho d) trong 1.8. p xtương đương với puts x.inspect. *là cả hai chuỗi lặp lại và nhân.

Phiên bản "Tối ưu hóa" để ghi điểm cũ:

Ruby, 8 ký tự - Chênh lệch 999999989 = số điểm -999999981

p ?!*1e9

In 33000000000.0cho 1.8 và "!!!!!!... !!!"cho 1.9. ( ?!nằm 33trong 1.8 và "!"1.9, và *cả hai chuỗi lặp lại và nhân.)

Thực sự, bạn có thể đi xa như bạn muốn với phép nhân, nó chỉ phụ thuộc vào tốc độ máy tính của bạn.

Bash - -∞ (đến giới hạn thực tế)

Hiệu quả, tuy nhiên nhiều bộ nhớ bạn có. Ví dụ: với khoảng 10 GB:

echo {0..999999999}

Bash 2: không hỗ trợ phạm vi mở rộng dấu ngoặc, nên in {0..999999999} .

Bash 3:

Bất kỳ ngôn ngữ nào - -∞ (tối đa giới hạn thực tế)

Bạn sẽ có ngôn ngữ này trong bất kỳ ngôn ngữ nào, ngay cả khi nó kết thúc phức tạp hơn một chút. Ngay khi bạn có thể tạo hai giá trị khác nhau, bạn có thể viết mã tạo ra đầu ra khác nhau tùy ý. Một phương pháp cho điểm tốt hơn sẽ bỏ qua sự khác biệt trong đầu ra.

version = … # some arbitrarily weird stuff
if version = 2:
    while not timed_out():
        print "version2"

C #

Mã sau sẽ tạo ra đầu ra khác nhau cho C # 5.0 và các phiên bản trước của C #

using System;
using System.Collections.Generic;

namespace TestConsoleAppClosure
{
    class Program
    {
        static void Main(string[] args)
        {
            var actions = new List<Action>();
            List<int> list = new List<int> { 10, 20, 30, 40 };
            foreach (var item in list)
            {
                  actions.Add(() => Console.WriteLine(item));
            }
            foreach (var act in actions) act();
        }
    }
}

Đầu ra: C # 5.0

10
20
30
40

Đầu ra: C # 4.0

40
40
40
40

Lý do được giải thích trong bài viết trên blog của Eric Lippert

Đóng trên biến vòng lặp được coi là có hại

Python, -14 Điểm (chênh lệch độ dài 3 - 17 char = -14)

2/3

Đầu ra Python 2: 0

Đầu ra Python 3: 0.6666666666666666

Phiên bản chấm điểm tốt hơn, 5 điểm (chênh lệch chiều dài 3 + 2 char = 5)

3/2

Đầu ra Python 2: 1

Đầu ra Python 3: 1.5

C #

Tôi đã thêm hiệp phương sai và chống chỉ định vào C # 4, vì vậy các chương trình có dạng:

using System;
using System.Collections.Generic;
class C
{
  static void Main() 
  {
    Console.WriteLine((new List<string>()) is IEnumerable<object>);
  }
}

Sẽ sản xuất falsetrong C # 2 và 3 vàtrue trong C # 4.

Tuy nhiên, người ta có thể lập luận rằng điều này không được tính vì thư viện chứa định nghĩa IEnumerable<T>cũng phải thay đổi.

C ++ 98/11 - Ghi điểm "Tốt hơn" (115 ký tự - 115 khác biệt ký tự duy nhất ở đầu ra = điểm 0)

Một phiên bản được chỉnh sửa một chút để tuân thủ các quy tắc tính điểm mới

Chơi gôn

#include<cstdio>
#define u8 "\x0B"
int main(){int i=116;char c[i];c[--i]=0;while(i-->0)c[i]=u8"\x7E"[0]+i;puts(c);}

Phiên bản bị đánh cắp:

#include <cstdio>
#define u8 "\x0B"
int main() {
    int i = 116;
    char c[i];
    c[--i] = 0;

    while(i-- > 0)
        c[i] = u8"\x7E"[0] + i;

    puts(c);
}

Giải pháp mới không khác nhiều so với giải pháp cũ. Trong giải pháp mới, đầu ra trong cả C ++ 11 và C ++ 98 có độ dài bằng 116 ký tự, nhưng ký tự duy nhất họ có chung là ký tự dòng mới được thêm vào bởi hàm put.

Đối với C ++ 98, phần u8trong u8"\x7E"[0]vẫn sẽ được thay thế, nhưng bây giờ với "\x0B". Vì vậy, giá trị kết quả sau khi tiền xử lý sẽ được "\x0B""\x7E"[0]. Hai chuỗi sẽ được nối với nhau"\x0B\x7E" và toán tử đăng ký sẽ truy cập vào phần tử đầu tiên, trong trường hợp này là ký tự có giá trị 11 trong mã hóa ký tự. Ngoài ra, giá trị của isẽ được thêm vào, mà về cơ bản là 114. Vì vậy, ký tự có giá trị 125 sẽ được ghi vào mảng kết quả. Khi ivề 0, tất cả các giá trị từ 125 đến 11 sẽ được ghi vào mảng và putssẽ in tất cả các ký tự có các giá trị từ 11 đến 125, cộng với dòng mới.

Trong C ++ 11 u8"\x7E"[0]sẽ được hiểu là một chuỗi UTF-8 bao gồm một ký tự có giá trị thập lục phân 7E. Toán tử đăng ký bây giờ sẽ truy cập ký tự này và giá trị củai được thêm vào nó, dẫn đến giá trị thập phân 241 trong lần lặp đầu tiên. Trong khi ivề không, tất cả các giá trị xuống 126 sẽ được ghi vào mảng và putssẽ in các ký tự có giá trị từ 126 đến 241, cộng với dòng mới.

Tùy thuộc vào bộ ký tự được sử dụng, điều này sẽ tạo ra các kết quả khác nhau, vì hầu hết các bộ ký tự chỉ có 128 ký tự đầu tiên.

Đối với ISO-8859-2, đầu ra sẽ như sau:

C ++ 98:

C ++ 11:

C ++ (106 ký tự - 107 chênh lệch sản lượng = điểm -1) (QUY TẮC OLD)

Chơi gôn

#include<cstdio>
#define u8 "f"
int main(){int i=108;char c[i];c[--i]=0;while(i-->0)c[i]=u8""[0];puts(c);}

Phiên bản bị đánh cắp:

#include <cstdio>
#define u8 "f"

int main() {
    int i = 108;
    char c[i];
    c[--i] = 0;

    while(i-- > 0)
            c[i] = u8""[0];

    puts(c);
}

Tổng hợp với g++ -std=c++98 main.cppvàg++ -std=c++11 main.cpp .

Thật ra bạn có thể thay thế 108 bằng bất kỳ số dương nào trong phạm vi số nguyên để đạt được điểm âm. Miễn là nó lớn hơn 108;)

Trong C ++ 98 #define u8 "f"sẽ khiến bộ tiền xử lý thay thế u8""[0]bằng "f"""[0]. Điều này sẽ dẫn đến "f"[0], cuối cùng trở thành một ký tự đơn 'f', được viết vào một mảng.

puts(c)sẽ in mảng kết quả, bao gồm i-1 'f'.

Trong C ++ 11 u8""[0]sẽ khiến chuỗi rỗng được hiểu là chuỗi UTF-8, do đó không có nối chuỗi nào được thực hiện. Vì đây là một chuỗi C, toán tử đăng ký sẽ truy cập vào byte null kết thúc và ghi nó vào một mảng.

Cuối cùng puts(c)sẽ in mảng kết quả, chỉ bao gồm các byte rỗng. Nhưng khi putsdừng đọc đầu vào ngay khi gặp byte rỗng, nó sẽ chỉ in một dòng mới và không có gì nữa.

CSS2 so với CSS3 48 điểm

<i style='font-feature-settings:"smcp" on;'>abcdefghijklmnopqrstuvwxyz</i>

Hiển thị như ABCDEFGHIJKLMNOPQRSTUVWXYZ (chữ hoa nhỏ) trên trình duyệt CSS3

Hiển thị như abcdefghijklmnopqrstuvwxyz trên các trình duyệt không phải CSS3

74 ký tự - 26 ký tự khác biệt = 48

Perl, 24 ký tự - (9 * (10 ^ 9)) - 1 char chênh lệch = điểm của - ((9 * (10 ^ 9)) - 1) +24

print$]>=5?"a":"a"x9e9;

In 9e9 lần acho tất cả các phiên bản dưới 5, in acho tất cả các phiên bản trên 5. Bạn có thể khiến điểm số thấp vô cùng chỉ bằng cách thêm nhiều as vào đầu ra thứ hai.

Befunge, 36 - 378 = -342; 164 - 2576 = -2412

"v
"<v
" <v
"  <v
"   <v
 <v:,<
 ^_@

Trong Befunge 93, điều này sẽ ra 3 chỗ, tiếp theo <v, tiếp theo là 76 chỗ, tiếp theo <v, sau đó 76 không gian, sau đó <v, sau đó 76 gian, sau đó <vtiếp theo 77 không gian, sau đó vtiếp theo là 78 dấu cách. Chiều dài:3 + 2 + 76 + 2 + 76 + 2 + 76 + 2 + 77 + 1 + 78 = 395 Đây có thể mở rộng tầm thường bằng cách thêm các dòng bổ sung tương tự như 5 dòng đầu tiên.

Trong Befunge 98, điều này sẽ xuất ra <v <v <v <v v .

Sự khác biệt về chiều dài : 395 - 17 = 378. Vì vậy, điểm số sẽ có được (theo quy tắc cũ):-342

_{Lưu ý: Tôi có thể đã nhận được một sự khác biệt thậm chí còn lớn hơn nếu tôi sử dụng .thay vì ,; sự khác biệt sẽ là-684}

Thay đổi quy tắc:

Đây là một chút khó khăn hơn.

"  "-v>"Befunge 93 very long strings"v>"F"0g" "1-`!#v_   "F"0g1-"F"0pvz
     _^p0"F"-1g0"F"_v#    `-1" "g0"F"<^"j++a81zzzzzz]zzzzzzzzzzzzzzz"<
             _@#`0:,<

Sản lượng Befunge 93:

sgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeB

Sản lượng Befunge 98:

j++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzz

Độ dài : 2576. Không có ký tự nào giữa các chuỗi giống nhau, vì vậy nếu tôi hiểu chính xác thử thách, điểm của tôi là 164 - 2576 = -2412(vâng, tôi phải nhắm đến 0, nhưng điều này vui hơn). Nếu tôi cần làm cho nó sao cho mỗi ký tự trong mỗi chuỗi là duy nhất và khác nhau, tôi có thể làm như vậy, xin vui lòng cho tôi biết.

Powershell, ghi điểm "Tốt hơn", -163 (15 - 178 char diff = -163)

$PSVersionTable

Powershell V2

Name                           Value                                                                   
----                           -----                                                                   
CLRVersion                     2.0.50727.5477                                                          
BuildVersion                   6.1.7601.17514                                                          
PSVersion                      2.0                                                                     
WSManStackVersion              2.0                                                                     
PSCompatibleVersions           {1.0, 2.0}                                                              
SerializationVersion           1.1.0.1                                                                 
PSRemotingProtocolVersion      2.1                                                                     

Powershell V3

Name                           Value                                                                   
----                           -----                                                                   
WSManStackVersion              3.0                                                                     
PSCompatibleVersions           {1.0, 2.0, 3.0}                                                         
SerializationVersion           1.1.0.1                                                                 
BuildVersion                   6.2.9200.16398                                                          
PSVersion                      3.0                                                                     
CLRVersion                     4.0.30319.1022                                                          
PSRemotingProtocolVersion      2.2 

PHP, Điểm: 0 (trường hợp tốt nhất)

srand(2);echo rand();

Wow, điều này sẽ rất vui để giải thích.

Theo trang web này , srand()chức năng dường như bị phá vỡ từ PHP 5.1.5 đến PHP 5.3.14 . Do đó, chúng tôi sẽ tiếp tục xem xét PHP 4.4.9 và một phiên bản ngẫu nhiên của PHP 5 nằm trong khoảng phiên bản được chỉ định ở trên.

Đầu ra PHP 4.4.9: 1505335290

Tôi không nghĩ rằng điều này là vi phạm quy tắc; Vì đây có vẻ là một lỗi, đầu ra sẽ giống nhau, nhưng không phải vậy. Phiên bản PHP khác của chúng tôi sẽ đơn giản bỏ qua srand()chức năng và xuất ra một số ngẫu nhiên.

Java (khoảng -2.000.000.000)

Các phiên bản Java đôi khi được gọi là 1.x, nhưng tôi nghĩ nó vẫn nằm trong quy tắc.

Cách dễ dàng là kiểm tra xem một lớp có tồn tại được giới thiệu trong một phiên bản cụ thể không.

try {
    Class.forName("java.lang.AutoCloseable");
    // Java 7 or later
    char[] text = new char[Integer.MAX_VALUE];
    Arrays.fill(text, 'a');
    System.out.println(new String(text));
} catch (Exception e) {
    // Java 6 or earlier
    System.out.println("-");
}

(Tùy thuộc một chút vào thiết bị đầu cuối của bạn cho dù có thể xuất 2 tỷ ký tự trong hai giây / Để ghi điểm mới, hãy thay thế Integer.MAX_VALUE bằng số byte của chương trình để đạt được điểm 0 hoàn hảo.)

Mã này phụ thuộc vào phiên bản VM / JDK được sử dụng (có tính không?)

import java.lang.reflect.Field;
import java.util.Arrays;

{
    Field fValue = null;
    for (Field f: String.class.getDeclaredFields()) {
            if (f.getName().equals("value")) {
                    fValue = f;
            }
    }
    char[] text = new char[10];
    Arrays.fill(text, 'a');
    String s1 = new String(text);
    String s2 = s1.substring(1);
    fValue.setAccessible(true);
    text = (char[]) fValue.get(s2);
    Arrays.fill(text, 'z');
    System.out.println(s1);
}

Nó in zs cho Java 6 và các JDK và as trước đó cho các phiên bản gần đây.

JavaScript (ES3 so với ES5) - 9 điểm

chiều dài 10 + chênh lệch chiều dài 0 - chênh lệch đầu ra1

[].map?1:0

Đầu ra 1cho các trình duyệt hiện đại hỗ trợ Array.prototype.map. Đầu ra 0trên các trình duyệt cũ hơn. Tôi đã thử nghiệm điều này với IE8.

Với quy tắc cũ: 0 điểm

chiều dài 26 - chênh lệch chiều dài26

Array([].map?27:0).join(0)

Đầu ra 00000000000000000000000000trên các trình duyệt hiện đại. Và chuỗi trống trên cũ.

Con trăn - 0

a='a=%r\ntry:print a%%a\nexcept:pass'
try:print a%a
except:pass

Python 2 in một quine, trong khi Python 3 không in gì cả.

EDIT: Cập nhật, cố định.

APL (5 - (1988894 - 1) = -1988888)

Trong các APL kiểu cũ (như Dyalog nếu ⎕ML=0 *), ↑có nghĩa là trộn , mà trên vectơ 1 chiều không làm gì cả. Trong các APL kiểu APL2, như GNU APL, (hoặc Dyalog nếu ⎕ML=3), ↑có nghĩa là đầu tiên , lấy mục đầu tiên của một vectơ.

Do đó, các 5byte sau (bộ ký tự APL không vừa trong một byte),

↑⍳3e5

sẽ xuất các 1988894byte (danh sách các số được phân tách bằng dấu cách từ 1 đến 3e5) theo phương ngữ APL kiểu cũ,

và 1byte (chỉ là số đầu tiên trong danh sách đã nói, 1do đó có độ dài 1), theo phương ngữ APL2 kiểu APL2.

Ghi chú:

• ⎕MLcó nghĩa là mức độ di chuyển . Trong Dyalog APL, bạn đặt càng cao ⎕ML, các tính năng kiểu APL2 càng được bật. Nó mặc định là 0. (Và đó là một biến toàn cầu! Vui!)
• 3e5là giá trị cao nhất 3 ký tự mà Dyalog APL sẽ chấp nhận ⍳. 4e5đã cho tôi một LIMIT ERROR. Hạn chế này có thể phụ thuộc vào thông dịch viên. (GNU APL không gặp rắc rối với các giá trị cao hơn.)

Bash 7 (Độ dài chương trình 14 byte + 0 chênh lệch về độ dài đầu ra - 7 chênh lệch về ký tự duy nhất ở đầu ra)

Liên quan đến câu trả lời @Gilles, nhưng một tính năng mở rộng khác nhau và các phiên bản khác nhau. Ghi điểm theo câu hỏi đã chỉnh sửa:

echo {1..9..2}

Đầu ra cho bash 3.x:

{1..9..2}

Đầu ra cho bash 4.x:

1 3 5 7 9

PHP: −134217684 (43 - 134217727)

echo str_pad("",ip2long("")&0x7ffffff,"a");

Sử dụng:

time php -r 'echo str_pad("",ip2long("")&0x7ffffff,"a");' > /tmp/test
1.61user 0.17system 0:01.79elapsed 99%CPU (0avgtext+0avgdata 142272maxresident)k
0inputs+0outputs (0major+35922minor)pagefaults 0swaps

Trong PHP5 +, điều này sẽ không in gì vì ip2long với đối số không hợp lệ biến thành false mà biến thành không. Trong PHP4, nó ip2long("")trả về -1 và chúng ta đệm chuỗi rỗng với 128 MB og a.

Mặt nạ được trang bị để nó quay trở lại lâu trước 2 giây trên máy của tôi. Nếu bạn không thể làm cho nó trong 2 giây mua phần cứng tốt hơn!

Với các quy tắc mới: 0 (40 - 40. Bạn không thể tiến gần hơn đến số không.)

echo str_pad("",40,chr(97+ip2long("")));

Đầu ra:

In PHP4: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 
In PHP5: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

Khai thác bình luận C89 / C99, 45 ký tự, 0 điểm

main(a){while(++a<47)putchar(79-a//**/~0
);}

đầu ra c89

QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|} - 45 char.

đầu ra c99

MLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"! - 45 char.

C ++ 98 / C ++ 11

#include <iostream>

int main()
{
  for (long i = 0; i < __cplusplus; ++i)
     std::cout << "x";
}

Đối với trình biên dịch C ++ 98 tuân thủ tiêu chuẩn, kết quả này xuất ra 199711 lần so với chữ 'x', trong khi đối với trình biên dịch C ++ 11 tuân thủ tiêu chuẩn, điều này tạo ra 201103 lần so với chữ 'x'. Do đó, độ dài khác nhau của đầu ra là 1392 ký tự. Điều này có nghĩa là việc đánh gôn mã nguồn thực sự không có giá trị, vì hiệu ứng lớn hơn nhiều có thể đạt được bằng cách chỉ thay thế "x"bằng một chuỗi dài hơn hoặc bằng cách nhân __cplusplusvới một số.

SmileBASIC 3 / SmileBASIC 2, Điểm: -5 (điểm ban đầu)

?1E9

Trong các phiên bản hiện đại của SB, bản in này 1000000000như mong đợi, nhưng trong phiên bản 2 trở về trước, nó đã in 10do lỗi.

TI-Basic 83 Plus so với 84 Plus, điểm 5-1 = 4

length("setTime(

Các đầu ra 2trên TI-83 Plus, trong đó cùng một chương trình được phân tích cú pháp như một thứ gì đó trông giống như length("?►DMSvì setTime(lệnh chưa được giới thiệu. Vì vậy, chuỗi chứa hai mã thông báo 1 byte, độ dài của nó là 2.

Đầu ra 1trên TI-84 Plus, vì một chuỗi chứa mã thông báo 2 byte đơn có độ dài 1.

Đi 1.9-> 1.10. Điểm = 1 - 1 = 0

Từ 1,10 ghi chú :

Không còn giới hạn đối với cài đặt GOMAXPROCS. (Trong Go 1.9, giới hạn là 1024.)

package main 
import (r"runtime")
var g=r.GOMAXPROCS
func main() {g(10340)
print(g(0))}

1,8: 256

1.9: 1024

1.10: 10340