Inspiriert von dieser Frage zu SO besteht Ihre Aufgabe darin, ein Programm zu erstellen, das in (mindestens) zwei Hauptversionen der von Ihnen gewählten Sprache gültig ist und unterschiedliche Ergebnisse liefert.

Regeln

• Jede Sprache mit mehr als einer Hauptversion kann verwendet werden.
  • Für die Zwecke dieser Herausforderung würde ich eine "Hauptversion" vorschlagen, bei der sich die erste Nummer in der Versionsnummer ändert.
    • PHP 4 und PHP 5 unterscheiden sich, PHP 5.3 und PHP 5.4 nicht.
  • Da ich das Versionsschema jedoch nicht für alle Sprachen kenne, kann die Community sicher feststellen, ob Sie die "Hauptversion" selbst fair ermittelt haben.
• Der Code muss kompiliert und jedes Mal mit denselben Flags und Eingaben ausgeführt werden
  • Ausgenommen, die Version der Sprache zu ändern, wenn dies relevant ist
• Fehler zählen nicht als Ausgabe, und Antworten, die Fehler verursachen, werden disqualifiziert (Fehlerausgaben werden nur ignoriert).
• Das Programm sollte nur die Eingaben vornehmen, die zum Ausführen erforderlich sind.
• Für jede gegebene Version sollte die Ausgabe immer gleich sein
• Die Änderung soll eine Folge einer Änderung der Sprachspezifikation und nicht der VM-Spezifikation oder der Umgebungsmetadaten sein

Wertung

• Code-Golf- Typ Bewertung nach Länge, also +1für jedes Zeichen / Byte
• -1für jedes Zeichen Unterschied in der Länge der Ausgabe.
  • zB Ausgabe von Version 1 abcde(5 Zeichen), Ausgabe von Version 2 123abc(6 Zeichen) =-1

Andere Regeln

• Es gelten Standardausnahmen - keine externen Programme, Webanfragen usw.
• Ihr Programm sollte beendet sein (innerhalb von 2 Sekunden)
• Die niedrigste Punktzahl gewinnt.

"Bessere" Wertung

Behalten Sie Ihre ursprünglichen Antworten bei, im Interesse der Fairness markiere ich den Gewinner anhand der ursprünglichen Regeln.

Da meine ursprüngliche Wertung grundsätzlich fehlerhaft ist, können Sie sie mit folgendem Bewertungssystem erneut bewerten / wiederholen:

• Code-Golf- Typ Bewertung nach Länge, also +1für jedes Zeichen / Byte
• +1für jeden Zeichenunterschied in der Länge der Ausgabe
  • abcdeund 123456->+1
• -1für jeden eindeutigen Zeichenunterschied in der Ausgabe (begrenzt auf die Länge der kürzesten Ausgabe)
  • abcdeund 123456->-5
  • 12345und 123456->-1
  • 12345und 123455->0
• Punktzahl, die dem Nullsieg am nächsten kommt
• Bei einem zweiten Unentschieden gewinnt der einfache Code-Golf- Score.

Überarbeitete Antwort für "besseres" Bewertungssystem

C89 / C99, Score: 0

Mein Programm ist 52 Zeichen lang und verwendet den gleichen Mechanismus wie in meiner ursprünglichen Antwort, um die unterschiedliche Ausgabe zu erzielen. Dies funktioniert, weil C89 nicht //als Kommentar behandelt wird:

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

Die Ergebnisse:

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

Alte Antwort:

C89 / C99, Score: -Infinity?

Ich bin nicht ganz sicher, ob dieses Programm nicht gegen die Regeln verstößt, aber egal. Dieses Programm nutzt die Tatsache aus, dass in C89 //kein gültiger Kommentar steht sondern /* ... */steht.

Mit dem Kommentar-Trick wird eine andere Funktion ausgeführt. In C89 wird die Funktion nur gedruckt, "trolololol..."bis der Stapel überläuft (sodass sie möglicherweise innerhalb von 2 Sekunden beendet ist).

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 Punkte weniger als die nächstbeste Antwort

print(range(100))

In Python 2 wird hiermit die gesamte Liste der Ganzzahlen von 0 bis 99 gedruckt.

In Python 3 rangeist es ein Generator und gibt daher nur "range (0,100)" aus.

Da ich in Python noch nie auf eine Größenbeschränkung für Zahlen gestoßen bin, kann ich diese 100 durch eine viel größere Zahl (z. B. 2 ** 1000) ersetzen und am Ende einen praktisch unbegrenzten Unterschied in der Ausgabe feststellen.

Bearbeitet, um der Tatsache Rechnung zu tragen, dass ich zwar für jeden praktischen Zweck eine unendlich niedrige Punktzahl erzielen kann, mit einem Programm, das unter 2 Sekunden endet, jedoch nicht die tatsächliche Unendlichkeit erreichen kann

Für das aktualisierte Punktesystem würde ich Folgendes einreichen:

print(range(4))

Ausgabe:

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

Python 3: range(0, 4)

Der erste Druck hat 5 eindeutige Zeichen ( [123]), der zweite Druck hat 8 eindeutige Zeichen ( range(4)), der Unterschied in der Länge der Ausgabe ist 1, der Code hat 15 Zeichen, die kürzeste Ausgabe ist 11 Zeichen ... diese Regeln sind aber ziemlich verwirrend Ich denke, das bringt mich zu einem Endergebnis von 15 + 1-min (11,5 + 8) = 5.

Python - 0 Punkte

Keine Ahnung, wie das funktioniert: P Bin gerade beim Ausprobieren von Zufallscode darauf gestoßen.

int

Auf Python 3 ist es <class 'int'>und auf Python 2 ist es <type 'int'>(mit interaktiver Konsole)
"Besser" Punktzahl: 3 (Länge) + 1 (Char Diff.) - 4 (eindeutige Zeichen)

Älteres Python 1 - 7 Punkte

print()

Vielen Dank an @grc für diese Version und hilf mir, vier Punkte abzuziehen!

In Python 2 wird diese Anweisung so interpretiert, print ()dass das leere Tupel gedruckt wird ().
In Python 3 ist das printeine Funktion und führt dazu, dass nichts gedruckt wird.
"Besser" Score: 7 (Länge) + 2 (Char Diff.) - 2 (einzigartige Zeichen)

Älteres Python 2 - 13 Punkte:

print(1,2)

"Besser" Punktzahl: 12 (Länge) + 2 (Char Diff. O / P) - 1 (Unique Chars O / P)

Ich weiß, dass dies nicht gewinnen wird, gab aber dennoch eine Antwort, da dies mein erster Python-Versuch ist :)

C #

Ich habe auch die generischen Inferenzalgorithmen für Methodentypen zwischen C # 2, 3 und 4 geändert. Zum Beispiel:

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

In der C # 2-Methode besagt die Typinferenz, dass T nicht beide intund sein int?kann und daher produziert 2. In der C # 3-Methode besagt die Typinferenz "Der beste Kompromiss zwischen intund int?ist int?" und wählt M<int?>und produziert daher 1.

Ruby, 4 Zeichen + 0 Zeichenlängendifferenz - 3 eindeutige Zeichenunterschiede = 1 Punkt

p ?d

In Ruby 1.9 wird gedruckt "d". Am 1.8 wird gedruckt 100.

Erklärung: ?dsteht "d"in 1.9 und 100(der ASCII-Code für d) in 1.8. p xist äquivalent zu puts x.inspect. *ist sowohl String-Wiederholung als auch Multiplikation.

"Optimierte" Version für altes Scoring:

Ruby, 8 Zeichen - 999999989 Zeichen Differenz = Punktzahl von -999999981

p ?!*1e9

Ausdrucke 33000000000.0für 1.8 und "!!!!!!... !!!"für 1.9. ( ?!ist 33in 1.8 und "!"in 1.9, und* ist Zeichenfolge-Wiederholung und Multiplikation.)

Sie können mit der Multiplikation wirklich so weit gehen, wie Sie möchten, es hängt nur davon ab, wie schnell Ihr Computer ist.

Bash - -∞ (bis zu praktischen Grenzen)

Effektiv, wie viel Speicher Sie haben. ZB mit ca. 10GB:

echo {0..999999999}

Bash 2: Unterstützt keine Bereiche bei der Klammererweiterung, druckt also {0..999999999}.

Bash 3:

Beliebige Sprache - -∞ (bis zu praktischen Grenzen)

Sie werden das in so ziemlich jeder Sprache haben, auch wenn es etwas komplexer wird. Sobald Sie zwei verschiedene Werte eingeben können, können Sie Code schreiben, der eine willkürlich unterschiedliche Ausgabe erzeugt. Eine bessere Bewertungsmethode würde die Unterschiede in der Ausgabe ignorieren.

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

C #

Der folgende Code würde die unterschiedliche Ausgabe für C # 5.0 und frühere Versionen von C # erzeugen.

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

Ausgabe: C # 5.0

10
20
30
40

Ausgabe: C # 4.0

40
40
40
40

Der Grund wird in dem Blogbeitrag von Eric Lippert erläutert

Das Schließen der Schleifenvariablen wird als schädlich angesehen

Python, -14 Punkte (3 - 17 Zeichenlängendifferenz = -14)

2/3

Python 2-Ausgänge: 0

Python 3-Ausgänge: 0.6666666666666666

Bessere Wertung, 5 Punkte (3 + 2 Zeichenlängendifferenz = 5)

3/2

Python 2-Ausgänge: 1

Python 3-Ausgänge: 1.5

C #

Ich habe C # 4 Kovarianz und Kontravarianz hinzugefügt, also Programme der Form:

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

Würde falsein C # 2 und 3 und truein C # 4 produzieren.

Man könnte jedoch argumentieren, dass dies nicht zählt, da sich auch die Bibliothek, die die Definition von enthält IEnumerable<T>, ändern musste.

C ++ 98/11 - "Bessere" Bewertung (115 Zeichen - 115 eindeutige Zeichenunterschiede in der Ausgabe = Punktzahl von 0)

Eine leicht überarbeitete Version, um den neuen Bewertungsregeln zu entsprechen

Golf gespielt:

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

Ungolfed-Version:

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

Die neue Lösung unterscheidet sich nicht wesentlich von der alten. In der neuen Lösung ist die Ausgabe in C ++ 11 und C ++ 98 mit 116 Zeichen gleich lang, aber das einzige gemeinsame Zeichen ist das von der Puts-Funktion angehängte neue Zeilenzeichen.

Für C ++ 98 wird das u8in u8"\x7E"[0]noch ersetzt, aber jetzt mit "\x0B". So wird der resultierende Wert nach der Vorverarbeitung sein "\x0B""\x7E"[0]. Die beiden Zeichenfolgen werden verkettet "\x0B\x7E"und der Indexoperator greift auf das erste Element zu, in diesem Fall auf das Zeichen mit dem Wert 11 in der Zeichencodierung. Zusätzlich wird der Wert von iaddiert, der ursprünglich 114 ist. Das Zeichen mit dem Wert 125 wird also in das resultierende Array geschrieben. Wiei Null werden alle Werte von 125 bis 11 in das Array geschrieben und putsalle Zeichen mit den Werten von 11 bis 125 plus der nachfolgenden neuen Zeile gedruckt.

In C ++ wird 11 u8"\x7E"[0]als UTF-8-String interpretiert, der aus dem Einzelzeichen mit dem Hexadezimalwert 7E besteht. Der tiefgestellte Operator greift jetzt auf dieses Zeichen zu und der Wert von iwird hinzugefügt, was zu dem Dezimalwert 241 während der ersten Iteration führt. Während iauf Null geht, werden alle Werte bis 126 in das Array und geschriebenputs die Zeichen mit den Werten von 126 bis 241 plus der nachfolgenden neuen Zeile gedruckt.

Dies führt je nach verwendetem Zeichensatz zu unterschiedlichen Ergebnissen, da die meisten Zeichensätze nur die ersten 128 Zeichen gemeinsam haben.

Für ISO-8859-2 wäre die Ausgabe wie folgt:

C ++ 98:

C ++ 11:

C ++ (106 Zeichen - 107 Unterschied in der Ausgabe = Punktzahl von -1) (ALTE REGELN)

Golf gespielt:

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

Ungolfed-Version:

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

Kompiliert mit g++ -std=c++98 main.cppundg++ -std=c++11 main.cpp .

Eigentlich können Sie ersetzen 108 jede positive Zahl im ganzzahligen Bereich , um negative Ergebnisse zu erzielen. Solange es größer als 108 ist;)

In C ++ 98 #define u8 "f"bewirkt , dass der Prä - Prozessor zu ersetzen u8""[0]mit "f"""[0]. Dies führt dazu "f"[0], dass es sich letztendlich um ein einzelnes Zeichen handelt 'f', das in ein Array geschrieben wird.

puts(c)druckt das resultierende Array, bestehend aus i-1 'f'.

In C ++ 11 u8""[0]wird die leere Zeichenfolge als UTF-8-Zeichenfolge interpretiert, sodass keine Zeichenfolgenverkettung erfolgt. Da es sich um eine C-Zeichenfolge handelt, greift der Indexoperator auf das abschließende Nullbyte zu und schreibt es in ein Array.

Am Ende puts(c)wird das resultierende Array gedruckt, das nur aus Null-Bytes besteht. Aber wie putshält den Eingang zu lesen, sobald es einen Null - Byte trifft, wird es nur eine neue Zeile gedruckt werden und nichts mehr.

CSS2 vs CSS3 48 Punkte

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

Gerendert als ABCDEFGHIJKLMNOPQRSTUVWXYZ(Kapitälchen) in CSS3-Browsern

Gerendert wie abcdefghijklmnopqrstuvwxyzauf Nicht-CSS3-Browsern

74 Zeichen - 26 Zeichen Unterschied = 48

Perl, 24 Zeichen - (9 * (10 ^ 9)) - 1 Zeichenunterschied = Punktzahl von - ((9 * (10 ^ 9)) - 1) +24

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

Druckt 9e9-mal a für alle Versionen unter 5, druckt afür alle Versionen über 5. Sie können die Punktzahl unendlich niedrig machen, indem Sie ader zweiten Ausgabe einfach mehr s hinzufügen .

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

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

In Befunge 93 würde dies 3 Leerzeichen ausgeben <v, gefolgt von 76 Leerzeichen, gefolgt von <v76 Leerzeichen <v, dann 76 Leerzeichen, dann <vgefolgt von 77 Leerzeichenv um 78 Leerzeichen gefolgt. Länge:3 + 2 + 76 + 2 + 76 + 2 + 76 + 2 + 77 + 1 + 78 = 395 Diese Option kann problemlos erweitert werden, indem zusätzliche Zeilen hinzugefügt werden, die den ersten fünf Zeilen ähneln.

In Befunge 98 würde dies ausgegeben <v <v <v <v v .

Der Unterschied in der Länge: 395 - 17 = 378. Das Ergebnis wäre also (nach den alten Regeln):-342

_{Hinweis: Ich hätte einen noch größeren Unterschied feststellen können, wenn ich .anstelle von verwendet hätte ,. der Unterschied wäre gewesen-684}

Regeländerung:

Das ist etwas kniffliger.

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

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 Ausgabe:

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

Längen: 2576. Keiner der Charaktere zwischen den Saiten ist derselbe. Wenn ich die Herausforderung also richtig verstanden habe, ist meine Punktzahl 164 - 2576 = -2412(ja, ich hätte zielen sollen 0, aber das hat mehr Spaß gemacht). Wenn ich es so machen muss, dass jedes Zeichen in jeder Zeichenkette einzigartig und voneinander verschieden ist, kann ich das, bitte sag es mir.

Powershell, "Bessere" Wertung, -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, Score: 0 (bester Fall)

srand(2);echo rand();

Wow, das wird lustig zu erklären sein.

Laut dieser Websitesrand() scheint die Funktion von PHP 5.1.5 auf PHP 5.3.14 unterbrochen zu sein . Daher werden wir PHP 4.4.9 und eine zufällige Version von PHP 5, die in das oben angegebene Versionsintervall fällt, weiter untersuchen.

PHP 4.4.9 Ausgabe: 1505335290

Ich glaube nicht, dass dies gegen Regeln verstößt. Da es sich um einen Fehler zu sein scheint, die Ausgabe sollte gleich sein, aber es ist nicht. Unsere andere PHP-Version überspringt einfach die srand()Funktion und gibt eine Zufallszahl aus.

Java (ungefähr -2.000.000.000)

Die Java-Versionen werden manchmal als 1.x bezeichnet, aber ich denke, es liegt immer noch innerhalb der Regeln.

Auf einfache Weise können Sie überprüfen, ob eine Klasse vorhanden ist, die in einer bestimmten Version eingeführt wurde.

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

(Hängt ein wenig von Ihrem Terminal ab, ob es möglich ist, 2 Milliarden Zeichen in zwei Sekunden auszugeben.) / Ersetzen Sie für die neue Wertung Integer.MAX_VALUE .)

Dieser Code hängt von der Version des verwendeten VM / JDK ab (zählt das?)

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

Es druckt zs für Java 6 und frühere JDKs und as für neuere Versionen.

JavaScript (ES3 vs ES5) - 9 Punkte

Länge 10 + Längendifferenz 0 - Ausgabedifferenz1

[].map?1:0

Ausgaben 1für moderne Browser, die Array.prototype.map unterstützen. Ausgänge0 in älteren Browsern. Ich habe das mit IE8 getestet.

Mit alten Regeln: 0 Punkte

Länge 26 - Längenunterschied26

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

Ausgaben 00000000000000000000000000in modernen Browsern. Und leere Zeichenfolge auf alt.

Python - 0

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

Python 2 druckt ein Quine, während Python 3 nichts druckt.

EDIT: Aktualisiert, behoben.

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

In APLs alten Stils (wie Dyalog if ⎕ML=0 *) ↑bedeutet mix , was auf einem eindimensionalen Vektor nichts bewirkt. In APL2-ähnlichen APLs bedeutet wie GNU APL (oder Dyalog if ⎕ML=3) zuerst↑ , dass das erste Element eines Vektors genommen wird.

Somit wird die folgende 5Bytes (der APL charset tut fit in einem Byte),

↑⍳3e5

gibt 1988894Bytes (die durch Leerzeichen getrennte Liste von Zahlen von 1 bis 3e5) in APL-Dialekten alten Stils aus,

und 1Byte (nur die erste Zahl in der Liste, die 1und daher von Länge ist 1) in APL2-artigen APL-Dialekten.

Anmerkungen:

• ⎕MLbedeutet Migrationsebene . Je höher Sie in Dyalog APL einstellen ⎕ML, desto mehr APL2-ähnliche Funktionen werden aktiviert. Der Standardwert ist0 . (Und es ist eine globale Variable! Spaß!)
• 3e5war der höchste 3-Zeichen-Wert, den Dyalog APL akzeptieren würde ⍳. 4e5gab mir eine LIMIT ERROR. Diese Einschränkung ist wahrscheinlich vom Interpreter abhängig. (GNU APL hatte keine Probleme mit höheren Werten.)

Bash 7 (14 Bytes Programmlänge + 0 Unterschied in der Ausgabelänge - 7 Unterschied in eindeutigen Zeichen in der Ausgabe)

Bezogen auf @ Gilles Antwort, aber eine andere Erweiterungsfunktion und verschiedene Versionen. Bewertung gemäß der bearbeiteten Frage:

echo {1..9..2}

Ausgabe für Bash 3.x:

{1..9..2}

Ausgabe für Bash 4.x:

1 3 5 7 9

PHP: −134217684 (43 - 134217727)

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

Verwendung:

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

In PHP5 + gibt dies nichts aus, da ip2long mit ungültigem Argument in false umgewandelt wird, was zu Null wird. In PHP4 gibt es ip2long("")-1 zurück und wir füllen den leeren String mit 128MB og auf a.

Die Maske ist so angebracht, dass sie lange vor den 2 Sekunden auf meiner Maschine zurückkehrt. Wenn Sie es in 2s nicht schaffen, kaufen Sie bessere Hardware!

Mit neuen Regeln: 0 (40 - 40. Näher an Null kommt man nicht heran.)

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

Ausgänge:

In PHP4: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 
In PHP5: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

C89 / C99 Kommentar-Exploit, 45 Zeichen, 0 Punkte

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

c89 ausgang

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

c99 ausgang

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

C ++ 98 / C ++ 11

#include <iostream>

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

Bei einem standardkonformen C ++ 98-Compiler wird das 199711-fache des Buchstabens 'x' ausgegeben, während bei einem standardkonformen C ++ 11-Compiler das 201103-fache des Buchstabens 'x' ausgegeben wird. Der Längenunterschied der Ausgabe beträgt daher 1392 Zeichen. Dies bedeutet, dass es sich nicht lohnt, den Quellcode zu spielen, da ein viel größerer Effekt erzielt werden kann, indem man ihn nur durch "x"eine längere Saite ersetzt oder __cplusplusmit einer bestimmten Zahl multipliziert .

SmileBASIC 3 / SmileBASIC 2, Score: -5 (ursprüngliche Wertung)

?1E9

In modernen Versionen von SB wird dies 1000000000wie erwartet gedruckt, in Version 2 und früher jedoch10 aufgrund eines Fehlers.

TI-Basic 83 Plus gegen 84 Plus, Ergebnis 5-1 = 4

length("setTime(

Ausgaben 2auf dem TI-83 Plus, bei denen dasselbe Programm als etwas analysiert wird, das aussiehtlength("?►DMS , weil diesetTime( Befehl noch nicht eingeführt wurde. Die Zeichenfolge enthält also zwei 1-Byte-Token, ihre Länge beträgt 2.

Ausgabe 1auf dem TI-84 Plus, da eine Zeichenfolge, die ein einzelnes 2-Byte-Token enthält, die Länge 1 hat.

Gehe zu 1.9-> 1.10. Ergebnis = 1 - 1 = 0

Ab 1.10 Anmerkungen :

Die GOMAXPROCS-Einstellung ist nicht mehr begrenzt. (In Go 1.9 war das Limit 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