Вдохновленный этим вопросом о SO , ваша задача состоит в том, чтобы создать программу, которая действительна (по крайней мере) в двух основных версиях выбранного вами языка и дает различный вывод.

правила

• Можно использовать любой язык, имеющий более одной основной версии.
  • Для целей этой задачи я бы предложил «основную версию», где изменяется первое число в номере версии.
    • PHP 4 и PHP 5 отличаются, PHP 5.3 и PHP 5.4 - нет.
  • Однако, поскольку я не знаю схемы управления версиями для всех языков, если вы сможете достаточно хорошо аргументировать свою позицию, я уверен, что сообщество определит, насколько вы были справедливы в определении «основной версии» самостоятельно.
• Код должен быть скомпилирован и запущен с одинаковыми флагами и каждый раз вводиться
  • За исключением изменения версии языка, если это уместно
• Ошибки не считаются выходными данными, а ответы, которые приводят к ошибкам, дисквалифицируются (вместо того, чтобы вывод ошибок просто игнорировался)
• Программа не должна предпринимать никаких действий, кроме той, которая требуется для ее запуска.
• Для каждой данной версии выходные данные всегда должны быть одинаковыми
• Предполагается, что это изменение должно быть следствием изменения спецификации языка, а не спецификации виртуальной машины или метаданных среды.

счет

• код-гольф типа выигрыша по длине, поэтому +1для каждого символа / байта
• -1для каждого символа разница в длине вывода.
  • например, выходные данные версии 1 abcde(5 символов), выходные данные версии 2 123abc(6 символов) =-1

Другие правила

• Применяются стандартные исключения - никаких внешних программ, веб-запросов и т. Д.
• Ваша программа должна завершиться (в течение 2 секунд)
• Самый низкий балл побеждает.

«Лучше» забил

Сохраняйте свои оригинальные ответы, в интересах справедливости я отмечу победителя на основе оригинальных правил.

Так как мой первоначальный результат в корне нарушен, почему бы не пересчитать / повторить попытку с помощью следующей системы оценок:

• код-гольф типа выигрыша по длине, поэтому +1для каждого символа / байта
• +1для каждого символа разница в длине вывода
  • abcdeи 123456->+1
• -1для каждого уникального различия символов в выводе (ограничено длиной кратчайшего вывода)
  • abcdeи 123456->-5
  • 12345и 123456->-1
  • 12345и 123455->0
• Очки, близкие к нулевой победе
• В случае второго тай-брейка выигрывает простой код-гольф .

Пересмотренный ответ для «лучшей» системы оценки

C89 / C99, оценка: 0

Моя программа длиной 52 символа и использует тот же механизм, что и в моем исходном ответе, для достижения другого результата. Это работает, потому что C89 не рассматривает //как комментарий:

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

Результаты:

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

Старый ответ:

C89 / C99, Оценка: -Бесконечность?

Я не совсем уверен, что эта программа не нарушает правила, но не берите в голову. Эта программа использует тот факт, что в C89 //это не правильный комментарий, но /* ... */есть.

Используя трюк с комментарием, выполняется другая функция. В C89 функция просто печатает "trolololol..."до тех пор, пока стек не переполнится (поэтому он может завершиться в течение 2 секунд).

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 - на 10 баллов меньше, чем следующий лучший ответ

print(range(100))

В Python 2 это напечатает весь список целых чисел от 0 до 99.

В Python 3 rangeесть генератор и поэтому он будет печатать только «диапазон (0,100)».

Поскольку я никогда не сталкивался с ограничением размера чисел в Python, я могу заменить эти 100 на гораздо большее число (например, 2 ** 1000) и в результате получить практически бесконечную разницу в выходных данных.

Отредактировано, чтобы отразить тот факт, что, хотя я могу получить бесконечно низкий балл для любой практической цели, я не могу достичь фактической бесконечности с программой, которая заканчивается менее чем за 2 секунды

Для обновленной системы оценки тай-брейков я бы отправил:

print(range(4))

Выход:

Python 2: [0, 1, 2, 3]

Python 3: range(0, 4)

Первый отпечаток содержит 5 уникальных символов ( [123]), второй - 8 уникальных символов ( range(4)), разница в длине вывода равна 1, код состоит из 15 символов, самый короткий вывод - 11 символов ... эти правила довольно запутанные, но Я думаю, что это подводит меня к окончательному счету 15 + 1-минута (11,5 + 8) = 5.

Питон - 0 очков

Понятия не имею, как это работает: P Просто наткнулся на него, пробуя случайный код.

int

На Python 3 это <class 'int'>и на Python 2, это <type 'int'>(с помощью интерактивной консоли)
«Лучше» Оценка: 3 (длина) + 1 (разность символов) - 4 (уникальные символы)

Старый Питон 1 - 7 очков

print()

Большое спасибо @grc за эту версию и помогу мне вычесть четыре очка!

В Python 2 это утверждение интерпретируется как то, print ()что печатает пустой кортеж ().
В Python 3 printфункция является функцией и ничего не печатается.
«Лучший» счет: 7 (длина) + 2 (разность символов) - 2 (уникальные символы)

Старый Python 2 - 13 очков:

print(1,2)

«Лучший» счет: 12 (длина) + 2 (разность символов о / п) - 1 (уникальные символы о / п)

Я знаю, что это не победит, но все же дал ответ, так как это моя первая попытка Python :)

C #

Я также изменил общие алгоритмы вывода типов методов между C # 2, 3 и 4. Например:

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?()));
  }
}

В C # 2 вывод типа метода говорит, что T не может быть одновременно intи int?, и так, и так производит 2. В C # 3 вывод типа метода говорит «лучший компромисс между intи int?есть int?» и поэтому выбирает M<int?>и производит 1.

Ruby, 4 символа + 0 различий в длинах символов - 3 уникальных разницы в символах = 1 балл

p ?d

На Ruby 1.9 он будет печататься "d". На 1.8 он печатает 100.

Пояснение: ?dэто "d"в 1.9 , и 100(ASCII - код для г) в 1.8. p xэквивалентно puts x.inspect. *это и повторение строк и умножение.

«Оптимизированная» версия для старой оценки:

Ruby, 8 символов - разница в 999999989 символов = оценка -999999981

p ?!*1e9

Отпечатки 33000000000.0для 1.8 и "!!!!!!... !!!"для 1.9. ( ?!Это 33в 1,8 и "!"в 1,9, и *является как струна повторение и умножение.)

На самом деле, с умножением вы можете пойти так далеко, как захотите, все зависит от скорости вашего компьютера.

Bash - -∞ (до практических пределов)

Фактически, сколько у вас памяти. Например, около 10 ГБ:

echo {0..999999999}

Bash 2: не поддерживает диапазоны в расширении фигурных скобок, поэтому печатает {0..999999999}.

Баш 3:

Любой язык - -∞ (до практических ограничений)

Вы получите это практически на любом языке, даже если это окажется немного сложнее. Как только вы можете сделать два разных значения, вы можете написать код, который будет производить произвольно разные выходные данные. Лучший метод оценки будет игнорировать различия в выходных данных.

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

C #

Следующий код даст другой вывод для C # 5.0 и предыдущих версий 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();
        }
    }
}

Выход: C # 5.0

10
20
30
40

Выход: C # 4.0

40
40
40
40

Причина объяснена в блоге Эрика Липперта

Закрытие по переменной цикла считается вредным

Python, -14 очков (разница длин символов от 3 до 17 = -14)

2/3

Выходы Python 2: 0

Выходы Python 3: 0.6666666666666666

Лучшая версия для скоринга, 5 баллов (разница в длине 3 + 2 символа = 5)

3/2

Выходы Python 2: 1

Выходы Python 3: 1.5

C #

Я добавил ковариацию и контравариантность в C # 4, поэтому программы вида:

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

Будет производить falseв C # 2 и 3 и trueв C # 4.

Однако можно утверждать, что это не считается, поскольку библиотека, содержащая определение, IEnumerable<T>также должна была измениться.

C ++ 98/11 - «Лучший» результат (115 символов - 115 уникальных символов, разница в результатах = 0 баллов)

Немного отредактированная версия, чтобы соответствовать новым правилам оценки

Golfed:

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

Безголовая версия:

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

Новое решение не сильно отличается от старого. В новом решении выходные данные как в C ++ 11, так и в C ++ 98 имеют одинаковую длину 116 символов, но их объединяет только один символ новой строки, добавляемый функцией put.

Для C ++ 98 u8in u8"\x7E"[0]все равно будет заменен, но теперь с "\x0B". Таким образом, полученное значение после предварительной обработки будет "\x0B""\x7E"[0]. Две строки будут объединены, "\x0B\x7E"и оператор нижнего индекса получит доступ к первому элементу, в этом случае символ со значением 11 в кодировке символов. Дополнительно iбудет добавлено значение, которое изначально равно 114. Таким образом, символ со значением 125 будет записан в результирующий массив. По мере iприближения к нулю все значения от 125 до 11 будут записаны в массив и putsбудут печатать все символы со значениями от 11 до 125 плюс завершающая новая строка.

В C ++ 11 u8"\x7E"[0]будет интерпретироваться как строка UTF-8, состоящая из одного символа с шестнадцатеричным значением 7E. Оператор нижнего индекса теперь будет обращаться к этому символу, и iк нему добавляется значение, что приводит к десятичному значению 241 во время первой итерации. Пока iидет ноль, все значения до 126 будут записаны в массив и putsбудут печатать символы со значениями от 126 до 241 плюс завершающая новая строка.

В зависимости от используемого набора символов это приведет к различным результатам, так как большинство наборов символов имеют только первые 128 общих символов.

Для ISO-8859-2 вывод будет следующим:

C ++ 98:

C ++ 11:

C ++ (106 символов - 107 разница в выводе = оценка -1) (СТАРЫЕ ПРАВИЛА)

Golfed:

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

Безголовая версия:

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

Составлено с g++ -std=c++98 main.cppи g++ -std=c++11 main.cpp.

На самом деле вы можете заменить 108любое положительное число в целочисленном диапазоне, чтобы получить отрицательные оценки. Пока это больше, чем 108;)

В C ++ 98 #define u8 "f"заставит препроцессор заменить u8""[0]на "f"""[0]. Это приведет к тому "f"[0], что в конечном итоге станет один символ 'f', который записывается в массив.

puts(c)выведет результирующий массив, состоящий из i-1 'f'.

В C ++ 11 u8""[0]пустая строка будет интерпретироваться как строка UTF-8, поэтому конкатенация строк не выполняется. Поскольку это C-строка, оператор нижнего индекса получит доступ к завершающему нулевому байту и запишет его в массив.

В конце puts(c)выведите итоговый массив, который состоит только из нулевых байтов. Но так как putsперестает читать ввод, как только он встречает нулевой байт, он будет печатать только новую строку и ничего больше.

CSS2 против CSS3 48 очков

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

Отображается как ABCDEFGHIJKLMNOPQRSTUVWXYZ(маленькие заглавные буквы) в браузерах CSS3

Отображается как abcdefghijklmnopqrstuvwxyzв не-CSS3 браузерах

74 символа - разница 26 уникальных символов = 48

Perl, 24 символа - (9 * (10 ^ 9)) - разница в 1 символ = оценка - ((9 * (10 ^ 9)) - 1) +24

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

Печатает 9e9 раз aдля всех версий ниже 5, печатает aдля всех версий выше 5. Вы можете сделать счет бесконечно низким, просто добавив больше as во второй вывод.

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

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

В Befunge 93 это вывело бы 3 пробела, а затем <v следуют 76 пробелов, <vзатем 76 пробелов <v, затем 76 пробелов, затем <v77 пробелов, затем v78 пробелов. Длина: 3 + 2 + 76 + 2 + 76 + 2 + 76 + 2 + 77 + 1 + 78 = 395Это легко расширяется путем добавления дополнительных строк, аналогичных первым 5 строкам.

В Befunge 98 это будет выводиться <v <v <v <v v.

Разница в длине: 395 - 17 = 378. Таким образом, оценка была бы (по старым правилам):-342

_{Примечание: я мог бы получить еще большую разницу, если бы использовал .вместо, ; разница была бы-684}

Изменение правила:

Это немного сложнее.

"  "-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:,<

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

Выход 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

Длины: 2576. Ни один из символов между строками не совпадает, поэтому, если я правильно понял задачу, мой результат будет 164 - 2576 = -2412(да, я должен был стремиться 0, но это было веселее). Если мне нужно сделать так, чтобы каждый символ в каждой строке был уникальным и отличался друг от друга, я могу сделать это, пожалуйста, сообщите мне.

Powershell, «лучший» результат, -163 (разница 15–178 символов = -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, оценка: 0 (в лучшем случае)

srand(2);echo rand();

Вау, это будет весело, чтобы объяснить.

Согласно этому веб-сайту , эта srand()функция, похоже, не работает с PHP 5.1.5 до PHP 5.3.14 . Поэтому мы собираемся рассмотреть PHP 4.4.9 и одну случайную версию PHP 5, которая попадает в указанный выше интервал версий.

Выход PHP 4.4.9: 1505335290

Я не думаю, что это нарушает правила; Поскольку это похоже на ошибку, вывод должен быть таким же, но это не так. Другая наша версия PHP просто пропустит srand()функцию и выведет случайное число.

Ява (около -2.000.000.000)

Версии Java иногда называют 1.x, но я думаю, что это все еще в рамках правил.

Самый простой способ - проверить, существует ли класс, представленный в конкретной версии.

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("-");
}

(Зависит немного от вашего терминала, можно ли вывести 2 миллиарда символов за две секунды. Для нового скоринга замените Integer.MAX_VALUEсчетчик байтов программы, чтобы получить идеальный нулевой счет.)

Этот код зависит от используемой версии VM / JDK (это считается?)

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

Он печатает zs для Java 6 и более ранних aверсий JDK и s для последних версий.

JavaScript (ES3 против ES5) - 9 очков

длина 10 + разница в длине 0 - разница на выходе1

[].map?1:0

Выходы 1для современных браузеров, которые поддерживают Array.prototype.map. Выводы 0в старых браузерах. Я проверил это с IE8.

Со старыми правилами: 0 баллов

длина 26 - разница в длине26

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

Выводы 00000000000000000000000000в современных браузерах. И пустая строка на старом.

Python - 0

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

Python 2 печатает лебеду, а Python 3 ничего не печатает.

РЕДАКТИРОВАТЬ: Обновлено, исправлено.

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

В APL старого стиля (например, Dyalog, если ⎕ML=0*) ↑означает mix , который на одномерном векторе ничего не делает. В APL2-стиле APL, такие как GNU APL (или Dyalog if ⎕ML=3), ↑означает first , который берет первый элемент вектора.

Таким образом, следующие 5байты (АПЗ кодировки делают посадку в бай),

↑⍳3e5

выводит 1988894байты (список чисел от 1 до 3e5, разделенных пробелами) на диалектах APL старого стиля,

и 1байт (только первое число в указанном списке, который имеет 1длину и, следовательно, имеет длину 1) в диалектах APL в стиле APL2.

Заметки:

• ⎕MLозначает уровень миграции . В Dyalog APL, чем выше значение ⎕ML, тем больше функций в стиле APL2. По умолчанию оно 0. (И это глобальная переменная! Весело!)
• 3e5было самым высоким 3-символьным значением, которое Dyalog APL примет ⍳. 4e5дал мне LIMIT ERROR. Это ограничение, вероятно, зависит от переводчика. (У GNU APL не было проблем с более высокими значениями.)

Bash 7 (длина программы 14 байтов + разница в длине вывода - 7 различий в уникальных символах в выходе)

Относится к ответу @Gilles, но имеет другую функцию расширения и разные версии. Оценка по отредактированному вопросу:

echo {1..9..2}

Выход для bash 3.x:

{1..9..2}

Выход для bash 4.x:

1 3 5 7 9

PHP: -134217684 (43 - 134217727)

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

Использование:

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

В PHP5 + это ничего не печатает, так как ip2long с недопустимым аргументом превращается в false, что приводит к нулю. В PHP4 он ip2long("")возвращает -1, и мы дополняем пустую строку 128 МБ ОГa .

Маска установлена ​​так, чтобы она возвращалась задолго до 2 секунд на моей машине. Если вы не можете сделать это за 2 секунды, купите лучшее оборудование!

С новыми правилами: 0 (40 - 40. Вы не можете приблизиться к нулю.)

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

Выходы:

In PHP4: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 
In PHP5: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

C89 / C99 комментарий, 45 символов, 0 очков

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

выход с89

QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|} - 45 знаков

выход C99

MLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"! - 45 знаков

С ++ 98 / C ++ 11

#include <iostream>

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

Для стандартного компилятора C ++ 98 это выводит 199711 раз букву «x», в то время как для стандартного компилятора C ++ 11 это 201103 умножение на букву «x». Следовательно, разница в длине вывода составляет 1392 символа. Это означает, что на самом деле игра в исходные коды не имеет смысла, так как гораздо больший эффект можно получить, просто заменив "x"более длинную строку или умножив ее __cplusplusна некоторое число.

SmileBASIC 3 / SmileBASIC 2, оценка: -5 (оригинальная оценка)

?1E9

В современных версиях SB он печатается, 1000000000как и ожидалось, но в версии 2 и более ранних он печатается 10из-за ошибки.

TI-Basic 83 Plus против 84 Plus, оценка 5-1 = 4

length("setTime(

Выходы 2на TI-83 Plus, где одна и та же программа анализируется как нечто похожее length("?►DMSна то, что setTime(команда еще не была введена. Таким образом, строка содержит два 1-байтовых токена, ее длина равна 2.

Выходы 1на TI-84 Plus, потому что строка, содержащая один 2-байтовый токен, имеет длину 1.

Перейти 1.9-> 1.10. Оценка = 1 - 1 = 0

С 1.10 отмечает :

Больше нет ограничений на настройку GOMAXPROCS. (В Go 1.9 лимит был 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