Zainspirowany tym pytaniem na temat SO , Twoim zadaniem jest stworzenie programu, który będzie działał w (co najmniej) dwóch głównych wersjach wybranego języka, które generują różne wyniki.

Zasady

• Można użyć dowolnego języka, który ma więcej niż jedną wersję główną.
  • Na potrzeby tego wyzwania sugerowałbym, że „wersja główna” to miejsce, w którym zmienia się pierwsza liczba w numerze wersji.
    • PHP 4 i PHP 5 są różne, PHP 5.3 i PHP 5.4 nie są.
  • Ponieważ jednak nie znam schematu wersjonowania dla wszystkich języków, jeśli możesz wystarczająco dobrze argumentować w swojej sprawie, jestem pewien, że społeczność określi, czy sam rzetelnie określiłeś „główną wersję”.
• Kod należy skompilować i uruchamiać za pomocą tych samych flag i wprowadzać za każdym razem
  • Z wyjątkiem zmiany wersji języka, jeśli jest to istotne
• Błędy nie liczą się jako dane wyjściowe, a odpowiedzi, które powodują błędy, są dyskwalifikowane (zamiast tego wynik błędu jest po prostu ignorowany)
• Program nie powinien pobierać danych innych niż wymagane do uruchomienia.
• Dla każdej danej wersji wynik powinien być zawsze taki sam
• Chodzi o to, aby zmiana była konsekwencją zmiany specyfikacji języka, a nie specyfikacji VM lub metadanych środowiskowych

Punktacja

• ocena typu golf-kod dla długości, więc +1dla każdego znaku / bajtu
• -1dla każdej różnicy w długości wyjściowej.
  • np. wyjścia w wersji 1 abcde(5 znaków), wyjścia w wersji 2 123abc(6 znaków) =-1

Inne zasady

• Obowiązują standardowe wyjątki - bez programów zewnętrznych, żądań internetowych itp.
• Twój program powinien zakończyć się (w ciągu 2 sekund)
• Najniższy wynik wygrywa.

Punktacja „lepsza”

Zachowaj oryginalne odpowiedzi, w trosce o sprawiedliwość, oznaczę zwycięzcę na podstawie oryginalnych zasad.

Ponieważ moja pierwotna punktacja jest zasadniczo zepsuta, dlaczego nie powtórzyć punktacji / spróbować ponownie za pomocą następującego systemu punktacji:

• ocena typu golf-kod dla długości, więc +1dla każdego znaku / bajtu
• +1dla każdej różnicy długości wydruku
  • abcdei 123456->+1
• -1dla każdej unikalnej różnicy znaków na wyjściu (ograniczona do długości najkrótszego wyniku)
  • abcdei 123456->-5
  • 12345i 123456->-1
  • 12345i 123455->0
• Wyniki najbliższe zerowej wygranej
• W przypadku drugiego remisu wygrywa prosty wynik golfowy .

Poprawiona odpowiedź na „lepszy” system punktacji

C89 / C99, wynik: 0

Mój program ma 52 znaki i używa tego samego mechanizmu, co w mojej oryginalnej odpowiedzi, aby uzyskać różne wyniki. Działa to, ponieważ C89 nie traktuje //jako komentarza:

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

Wyniki:

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

Stara odpowiedź:

C89 / C99, wynik: -Nieskończoność?

Nie jestem do końca pewien, czy ten program nie łamie zasad, ale nieważne. Ten program wykorzystuje fakt, że w C89 //nie jest poprawnym komentarzem, ale /* ... */jest.

Za pomocą sztuczki komentowania wykonywana jest inna funkcja. W C89 funkcja drukuje tylko, "trolololol..."aż stos się przepełni (więc może zakończyć się w ciągu 2 sekund).

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 punktów mniej niż kolejna najlepsza odpowiedź

print(range(100))

W Pythonie 2 to wypisze całą listę liczb całkowitych od 0 do 99.

W Pythonie 3 rangejest generatorem, więc wypisze tylko „zakres (0,100)”.

Ponieważ nigdy nie spotkałem się z ograniczeniem wielkości liczb w Pythonie, mogę zastąpić to 100 znacznie większą liczbą (na przykład 2 ** 1000) i uzyskać praktycznie nieskończoną różnicę w wynikach.

Edytowane, aby odzwierciedlić fakt, że chociaż mogę uzyskać nieskończenie niski wynik dla dowolnego praktycznego celu, nie mogę osiągnąć faktycznej nieskończoności za pomocą programu, który kończy się poniżej 2 sekund

W przypadku zaktualizowanego systemu punktacji rozstrzygającego przesyłam:

print(range(4))

Wydajność:

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

Python 3: range(0, 4)

Pierwszy wydruk ma 5 unikalnych znaków ( [123]), drugi wydruk ma 8 unikalnych znaków ( range(4)), różnica w długości wydruku wynosi 1, kod ma 15 znaków, najkrótszy wynik to 11 znaków ... zasady te są dość mylące, ale Myślę, że to prowadzi mnie do końcowego wyniku 15 + 1 min (11,5 + 8) = 5.

Python - 0 punktów

Nie mam pojęcia, jak to działa: P Natknąłem się na niego podczas wypróbowywania losowego kodu.

int

W Pythonie 3 jest <class 'int'>i w Pythonie 2 <type 'int'>(przy użyciu konsoli interaktywnej)
Wynik „Lepszy”: 3 (długość) + 1 (różn. Char.) - 4 (unikatowe znaki)

Starsze Python 1 - 7 punktów

print()

Ogromne podziękowania dla @grc za tę wersję i pomoc w odjęciu czterech punktów!

W Pythonie 2 ta instrukcja jest interpretowana jako print ()drukująca pustą krotkę ().
W Pythonie 3 printjest funkcją i powoduje, że nic nie jest drukowane.
Wynik „Lepszy”: 7 (długość) + 2 (róż. Char.) - 2 (unikalne znaki)

Starsze Python 2 - 13 punktów:

print(1,2)

Wynik „Lepszy”: 12 (długość) + 2 (char diff. O / p) - 1 (unikatowe znaki o / p)

Wiem, że to nie wygra, ale nadal dałem odpowiedź, ponieważ jest to moja pierwsza próba w Pythonie :)

DO#

Zmieniłem również algorytmy wnioskowania typu metody ogólnej między C # 2, 3 i 4. Na przykład:

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

W metodzie C # 2 wnioskowanie o typach mówi, że T nie może być jednocześnie inti int?, i tak wytwarza 2. W metodzie C # 3 wnioskowanie typu mówi „najlepszy kompromis pomiędzy inti int?jest int?”, dlatego wybiera M<int?>i wytwarza 1.

Rubinowy, 4 znaki + 0 różnic długości znaków - 3 unikalna różnica znaków = wynik 1

p ?d

Na Ruby 1.9 zostanie wydrukowane "d". Na 1.8 drukuje 100.

Objaśnienie: ?djest "d"w wersji 1.9, a 100(kod ASCII dla d) w wersji 1.8. p xjest równoważne z puts x.inspect. *to zarówno powtarzanie ciągów, jak i mnożenie.

Wersja „zoptymalizowana” dla starej punktacji:

Ruby, 8 znaków - 999999989 różnica znaków = wynik -999999981

p ?!*1e9

Drukuje 33000000000.0dla 1.8 i "!!!!!!... !!!"dla 1.9. ( ?!jest 33w wersji 1.8 i "!"1.9 i *jest zarówno powtarzaniem, jak i mnożeniem).

Naprawdę, możesz pomnożyć tak daleko, jak chcesz, zależy to tylko od tego, jak szybki jest twój komputer.

Bash - -∞ (do praktycznych limitów)

Skutecznie, niezależnie od tego, ile masz pamięci. Np. Z około 10 GB:

echo {0..999999999}

Bash 2: nie obsługuje zakresów w rozszerzaniu nawiasów, więc drukuje {0..999999999}.

Bash 3:

Dowolny język - -∞ (do praktycznych ograniczeń)

Będziesz mieć to w prawie każdym języku, nawet jeśli skończy się to nieco bardziej skomplikowanym. Gdy tylko możesz utworzyć dwie różne wartości, możesz napisać kod, który generuje dowolnie różne dane wyjściowe. Lepsza metoda punktacji zignorowałaby różnice w danych wyjściowych.

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

DO#

Poniższy kod wygeneruje różne dane wyjściowe dla C # 5.0 i poprzednich wersji 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();
        }
    }
}

Wyjście: C # 5.0

10
20
30
40

Wyjście: C # 4.0

40
40
40
40

Przyczynę wyjaśniono w poście na blogu Erica Lipperta

Zamykanie przez zmienną pętli uważane jest za szkodliwe

Python, -14 punktów (różnica długości 3 - 17 znaków = -14)

2/3

Wyjścia Python 2: 0

Wyjścia Python 3: 0.6666666666666666

Wersja Better Scoring, 5 punktów (różnica długości 3 + 2 znaków = 5)

3/2

Wyjścia Python 2: 1

Wyjścia Python 3: 1.5

DO#

Dodałem kowariancję i kontrawariancję do C # 4, więc programy w postaci:

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

Produkowałby falsew C # 2 i 3 oraz truew C # 4.

Można jednak argumentować, że to się nie liczy, ponieważ biblioteka zawierająca definicję IEnumerable<T>również musiała się zmienić.

C ++ 98/11 - Punktacja „Lepsza” (115 znaków - 115 unikalnych różnic postaci w wyniku = wynik 0)

Lekko zredagowana wersja zgodna z nowymi zasadami punktacji

Gra w golfa:

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

Wersja bez golfa:

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

Nowe rozwiązanie niewiele różni się od starego. W nowym rozwiązaniu dane wyjściowe zarówno w C ++ 11, jak i C ++ 98 mają 116 znaków jednakowej długości, ale jedynym wspólnym znakiem jest nowy znak linii dołączony przez funkcję puts.

Dla C ++ 98 u8in u8"\x7E"[0]będzie nadal zamieniane, ale teraz z "\x0B". Tak więc wartość wynikowa po przetwarzaniu wstępnym będzie "\x0B""\x7E"[0]. Oba łańcuchy zostaną połączone "\x0B\x7E"i operator indeksu dolnego uzyska dostęp do pierwszego elementu, w tym przypadku znaku o wartości 11 w kodowaniu znaków. Dodatkowo izostanie dodana wartość, która początkowo wynosi 114. Tak więc znak o wartości 125 zostanie zapisany w wynikowej tablicy. Gdy idojdzie do zera, wszystkie wartości od 125 do 11 zostaną zapisane w tablicy i putswydrukują wszystkie znaki o wartościach od 11 do 125, a także końcowy nowy wiersz.

W C ++ 11 u8"\x7E"[0]będzie interpretowany jako ciąg UTF-8 składający się z pojedynczego znaku o wartości szesnastkowej 7E. Operator indeksu dolnego będzie teraz uzyskiwał dostęp do tego znaku, a jego wartość idodawana jest do niego, co daje wartość dziesiętną 241 podczas pierwszej iteracji. Gdy idojdzie do zera, wszystkie wartości do 126 zostaną zapisane w tablicy i putswydrukują znaki o wartościach od 126 do 241, plus nowy wiersz.

W zależności od użytego zestawu znaków spowoduje to różne wyniki, ponieważ większość zestawów znaków ma tylko pierwsze 128 znaków wspólnych.

W przypadku ISO-8859-2 dane wyjściowe byłyby następujące:

C ++ 98:

C ++ 11:

C ++ (106 znaków - 107 różnica w wynikach = wynik -1) (STARE ZASADY)

Gra w golfa:

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

Wersja bez golfa:

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

Skompilowane z g++ -std=c++98 main.cppi g++ -std=c++11 main.cpp.

W rzeczywistości można zastąpić 108dowolną liczbą dodatnią z zakresu liczb całkowitych, aby uzyskać wyniki ujemne. Tak długo, jak jest większy niż 108;)

W C ++ 98 #define u8 "f"spowoduje, że preprocesor do zastąpienia u8""[0]z "f"""[0]. Spowoduje to, że w "f"[0]końcu stanie się pojedynczym znakiem 'f'zapisanym w tablicy.

puts(c)wypisze wynikową tablicę składającą się z i-1 'f'.

W C ++ 11 u8""[0]spowoduje, że pusty ciąg zostanie zinterpretowany jako ciąg UTF-8, więc nie jest wykonywana konkatenacja ciągu. Ponieważ jest to ciąg C, operator indeksu dolnego uzyska dostęp do kończącego zerowego bajtu i zapisze go w tablicy.

Na koniec puts(c)wydrukuje wynikową tablicę, która składa się tylko z pustych bajtów. Ale gdy putsprzestanie czytać dane wejściowe, gdy tylko napotka pusty bajt, wypisze tylko nowy wiersz i nic więcej.

CSS2 vs CSS3 48 punktów

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

Renderowane jako ABCDEFGHIJKLMNOPQRSTUVWXYZ(małe litery) w przeglądarkach CSS3

Renderowane jak abcdefghijklmnopqrstuvwxyzw przeglądarkach innych niż CSS3

74 znaki - 26 unikalnych różnic znaków = 48

Perl, 24 znaki - (9 * (10 ^ 9)) - 1 różnica znaków = wynik - ((9 * (10 ^ 9)) - 1) +24

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

Drukuje 9e9 razy adla wszystkich wersji poniżej 5, drukuje adla wszystkich wersji powyżej 5. Możesz sprawić, że wynik będzie nieskończenie niski, po prostu dodając więcej as do drugiego wyjścia.

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

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

W Befunge 93 to dałoby 3 spacje, a <vnastępnie 76 spacji, a <vnastępnie 76 spacji <v, następnie 76 spacji, następnie <v77 spacji, a vnastępnie 78 spacji. Długość: 3 + 2 + 76 + 2 + 76 + 2 + 76 + 2 + 77 + 1 + 78 = 395Można to w prosty sposób rozszerzyć, dodając dodatkowe linie podobne do pierwszych 5 linii.

W Befunge 98 byłoby to wyjście <v <v <v <v v.

Różnica w długości: 395 - 17 = 378. Wynik byłby (według starych zasad):-342

_{Uwaga: Mógłbym uzyskać jeszcze większą różnicę, gdybym użył .zamiast ,; różnica byłaby-684}

Zmiana reguły:

To jest trochę trudniejsze.

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

Wyjście 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

Wyjście 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ługości: 2576. Żadna z postaci między strunami nie jest taka sama, więc jeśli poprawnie zrozumiałem wyzwanie, mój wynik to 164 - 2576 = -2412(tak, miałem celować 0, ale to było fajniejsze). Jeśli muszę to zrobić, aby każdy znak w każdym ciągu był niepowtarzalny i różny od siebie, mogę to zrobić, proszę mi powiedzieć.

Powershell, punktacja „Better”, -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, wynik: 0 (najlepszy przypadek)

srand(2);echo rand();

Wow, wyjaśnienie będzie zabawne.

Według tej strony , srand()funkcja wydaje się być uszkodzony z PHP 5.1.5 do PHP 5.3.14 . Dlatego będziemy brać pod uwagę PHP 4.4.9 i jedną losową wersję PHP 5, która mieści się w określonym powyżej przedziale czasowym.

Wyjście PHP 4.4.9: 1505335290

Nie sądzę, że jest to łamanie zasad; Ponieważ wydaje się to być błędem, wynik powinien być taki sam, ale tak nie jest. Nasza inna wersja PHP po prostu pominie srand()funkcję i wyświetli losową liczbę.

Java (około -2 000 000 000)

Wersje Java są czasami nazywane 1.x, ale myślę, że nadal są zgodne z regułami.

Prostym sposobem jest sprawdzenie, czy istnieje klasa, która została wprowadzona w określonej wersji.

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

(Zależy trochę od terminala, czy możliwe jest wyprowadzenie 2 miliardów znaków w ciągu dwóch sekund / W przypadku nowej punktacji zamień Integer.MAX_VALUEna liczbę bajtów programu, aby uzyskać doskonały wynik zero.)

Ten kod zależy od używanej wersji VM / JDK (czy to się liczy?)

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

Drukuje zs dla JDK Java 6 i wcześniejszych oraz as dla najnowszych wersji.

JavaScript (ES3 vs ES5) - 9 punktów

długość 10 + różnica długości 0 - różnica wyjściowa1

[].map?1:0

Wyjścia 1dla nowoczesnych przeglądarek, które wspierają Array.prototype.map. Dane wyjściowe 0w starszych przeglądarkach. Testowałem to z IE8.

Przy starych zasadach: 0 punktów

długość 26 - różnica długości26

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

Dane wyjściowe 00000000000000000000000000w nowoczesnych przeglądarkach. I pusty sznur na starym.

Python - 0

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

Python 2 drukuje quine, podczas gdy Python 3 nic nie drukuje.

EDYCJA: zaktualizowana, naprawiona.

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

W APL w starym stylu (jak Dyalog if ⎕ML=0*) ↑oznacza mix , co w przypadku 1-wymiarowego wektora nic nie robi. W APL-ach w stylu APL2, takich jak GNU APL (lub Dyalog if ⎕ML=3), ↑oznacza pierwszy , który bierze pierwszy element wektora.

W ten sposób następuje 5bajtów (Charset APL nie mieszczą się w bajcie)

↑⍳3e5

wyświetli 1988894bajty (lista cyfr od 1 do 3e5 oddzielona spacjami) w dialektach APL w starym stylu,

i 1bajt (tylko pierwszy numer na wspomnianej liście, który jest 1i dlatego ma długość 1), w dialektach APL typu APL2.

Uwagi:

• ⎕MLoznacza poziom migracji . W Dyalog APL, im wyższa wartość ⎕ML, tym więcej funkcji w stylu APL2 jest włączonych. Domyślnie jest to 0. (I to zmienna globalna! Zabawa!)
• 3e5była najwyższą 3-znakową wartością, którą akceptowałaby Dyalog APL ⍳. 4e5dał mi LIMIT ERROR. Ograniczenie to prawdopodobnie zależy od tłumacza. (GNU APL nie miał problemów z wyższymi wartościami).

Bash 7 (14-bajtowa długość programu + 0 różnic w długości wyjściowej - 7 różnic w unikatowych znakach w danych wyjściowych)

Powiązane z odpowiedzią @Gilles, ale inną funkcją rozszerzenia i różnymi wersjami. Punktacja według edytowanego pytania:

echo {1..9..2}

Dane wyjściowe dla bash 3.x:

{1..9..2}

Dane wyjściowe dla bash 4.x:

1 3 5 7 9

PHP: −134217684 (43-134217727)

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

Stosowanie:

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

W PHP5 + to nic nie wydrukuje, ponieważ ip2long z niepoprawnym argumentem zamienia się w false, który jest zerowany. W PHP4 ip2long("")zwraca -1 i wypełniamy pusty ciąg 128 MB og a.

Maska jest dopasowana, dzięki czemu wraca na długo przed 2 sekundami na mojej maszynie. Jeśli nie dasz rady w 2 sekundy, kup lepszy sprzęt!

Z nowymi zasadami: 0 (40 - 40. Nie możesz zbliżyć się do zera.)

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

Wyjścia:

In PHP4: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 
In PHP5: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

Wykorzystanie komentarza C89 / C99, 45 znaków, 0 punktów

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

wyjście c89

QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|} - 45 znaków

wyjście c99

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

C ++ 98 / C ++ 11

#include <iostream>

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

W przypadku standardowego kompilatora C ++ 98 dane wyjściowe 199711 są większe niż litera „x”, podczas gdy w przypadku standardowego kompilatora C ++ 11 dane wyjściowe 201103 są większe niż litera „x”. Różnica długości danych wyjściowych wynosi zatem 1392 znaki. Oznacza to, że faktyczne odtwarzanie kodu źródłowego w golfa nie jest opłacalne, ponieważ znacznie większy efekt można uzyskać po prostu zastępując "x"go dłuższym ciągiem lub mnożąc przez __cpluspluspewną liczbę.

SmileBASIC 3 / SmileBASIC 2, wynik: -5 (oryginalna ocena)

?1E9

W nowoczesnych wersjach SB jest to drukowane 1000000000zgodnie z oczekiwaniami, ale w wersji 2 i wcześniejszej drukowane z 10powodu błędu.

TI-Basic 83 Plus vs. 84 Plus, wynik 5-1 = 4

length("setTime(

Wyjścia 2na TI-83 Plus, gdzie ten sam program jest analizowany jako coś, co wygląda, length("?►DMSponieważ setTime(polecenie nie zostało jeszcze wprowadzone. Więc ciąg zawiera dwa 1-bajtowe tokeny, a jego długość wynosi 2.

Dane wyjściowe 1na TI-84 Plus, ponieważ łańcuch zawierający pojedynczy 2-bajtowy token ma długość 1.

Idź 1.9-> 1.10. Wynik = 1 - 1 = 0

Z 1.10 notatek :

Nie ma już ograniczenia dla ustawienia GOMAXPROCS. (W Go 1.9 limit wynosił 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