Ihre Herausforderung besteht darin, einen Polyglot zu schreiben, der in verschiedenen Versionen Ihrer Sprache funktioniert. Beim Ausführen wird immer die Sprachversion ausgegeben.

Regeln

• Ihr Programm sollte in mindestens zwei Versionen Ihrer Sprache funktionieren.
• Die Ausgabe Ihres Programms sollte nur die Versionsnummer sein. Keine fremden Daten.
• Ihr Programm kann die Versionsnummer nach Belieben ermitteln. Die Ausgabe muss jedoch Regel 2 entsprechen. Wie auch immer Sie die Versionsnummer bestimmen, die Ausgabe muss nur die Nummer sein.
• Ihr Programm muss nur die Hauptversion der Sprache ausgeben. In FooBar 12.3.456789-beta müsste Ihr Programm beispielsweise nur 12 ausgeben.
• Wenn Ihre Sprache Wörter oder Symbole vor oder nach der Versionsnummer einfügt, müssen Sie diese und nur die Nummer nicht ausgeben. In C89 muss Ihr Programm beispielsweise nur drucken 89, und in C ++ 0x muss Ihr Programm nur drucken 0.
• Wenn Sie den vollständigen Namen oder kleinere Versionsnummern drucken möchten, z. B. C89 im Gegensatz zu C99, muss nur der Name gedruckt werden. C89 build 32ist gültig, solange error in C89 build 32: foo barnicht.
• Ihr Programm verwendet möglicherweise keine eingebauten, Makro- oder benutzerdefinierten Compiler-Flags, um die Sprachversion zu ermitteln.

Wertung

Ihre Punktzahl ergibt sich aus der Codelänge geteilt durch die Anzahl der Versionen, in denen es funktioniert. Die niedrigste Punktzahl gewinnt, viel Glück!

Ernsthaft und tatsächlich , 3 Bytes, 1,5 Punkte

'1u

Probieren Sie es online aus: Wirklich , im Ernst

Erläuterung:

'1u
'1   both versions: push "1"
  u  Actually: increment character to "2"; Seriously: NOP
     (both versions: implicit print)

uund Dmit Funktionalität für Zeichenfolgen wurde nur in Actually (das ist Seriously v2) hinzugefügt.

Python 3.0 und Python 2, Punktzahl 6

(12 Bytes, 2 Versionen)

print(3/2*2)

Probieren Sie es online aus:

• Python 2

• Python 3

Beruht auf der Tatsache, dass Python 3+ standardmäßig Float-Division verwendet, im Gegensatz zu Python 2, das Floor-Division verwendet.

Java, 189 Bytes, 10 Versionen, Score = 18,9

Unterstützte Versionen: 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8und9

(Für frühere Ergebnisse überprüfen Sie den Verlauf !)

Object v(){int i=0;try{for(String[]s={"Locale","Map","Timer","Currency","UUID","Deque","Objects","Base64","zip.CRC32C"};;i++)Class.forName("java.util."+s[i]);}finally{return i<9?"1."+i:i;}}

Führen Sie es auf Java 8 aus
Führen Sie es auf Java 9 oder höher aus

Ungolfed

Object v(){
  int v=0;
  try {
    for(
      String[] s={
        "Locale",          // 1.1
        "Map",             // 1.2
        "Timer",           // 1.3
        "Currency",        // 1.4
        "UUID",            // 1.5
        "Deque",           // 1.6
        "Objects",         // 1.7
        "Base64",          // 1.8
        "zip.CRC32C"       // 9
      };;v++)
      Class.forName("java.util."+s[v]);
  } finally {
    // Swallowing ClassNotFoundException when the version is not the last one
    // Swallowing ArrayIndexOutOfBoundsException that occurs after reaching the last version.
    return v < 9 ? "1." + v : v; // Return either an int or a String
  }
}

Bitte beachten Sie, dass der Codeteil return v<9?"1."+v:v;(zuvor return(v<9?"1.":"")+v;) mit allen Versionen zwischen Java 1.0 und Java 1.3 verglichen werden muss. Ich habe keine Java 1.3 oder frühere Installation zur Verfügung, um diese Syntax zu testen.

Einführung

Die Java-Versionierung hat eine besondere Geschichte. Alle Versionen wurden historisch 1.xeinschließlich 1.0. Aber ... ab Java 9 und JEP223 wurde das Versionsschema von "using" auf " 1.xto" geändert x. Das ist die intern bekannte Version. Wir haben also die folgende Tabelle (zusammengestellt mit Javadoc und Wikipedia ):

 java.version | Rel. name | Product name
   property   |           |
--------------+-----------+-----------------
          1.0 | JDK 1.0   | Java 1
          1.1 | JDK 1.1   |
          1.2 | J2SE 1.2  | Java 2
          1.3 | J2SE 1.3  |
          1.4 | J2SE 1.4  |
          1.5 | J2SE 5.0  | Java 5
          1.6 | Java SE 6 | Java 6
          1.7 | Java SE 7 | Java 7
          1.8 | Java SE 8 | Java 8
          9   | Java SE 9 | Java 9

Dieser Herausforderungseintrag entspricht der Versionsspalte in der obigen Tabelle, die in der Systemeigenschaft enthalten ist "java.version".

Erläuterung

Ziel ist es zu überprüfen, ab welcher Version eine Klasse existiert, da Java Code nicht mehr unterstützt, aber niemals entfernt. Der Code wurde speziell in Java 1.0 geschrieben, um mit allen Versionen kompatibel zu sein, da das JDK (größtenteils) Source-Forward-kompatibel ist .

Die Implementierung versucht, die kürzesten Klassennamen zu finden, die von jeder Version eingeführt wurden. Um jedoch Bytes zu erhalten, muss versucht werden, ein gemeinsames Unterpaket auszuwählen. Bisher fand ich das effizienteste Paket, java.utilweil es mehrere wirklich kurz benannte Klassen enthält, die auf alle Java-Versionen verteilt sind.

Um die tatsächliche Versionsnummer zu ermitteln, werden die Klassennamen nach der Einführung der Version sortiert. Dann versuche ich, jede Klasse nacheinander zu instanziieren und den Array-Index zu erhöhen. Wenn die Klasse existiert, fahren wir mit der nächsten fort, andernfalls lassen wir die Ausnahme vom try-block abfangen. Wenn dies erledigt ist, wird eine weitere Ausnahme ausgelöst, da es keine Klassen mehr gibt, deren Existenz wir überprüfen müssen.

In jedem Fall verlässt der Thread den try-block mit einer Ausnahme. Diese Ausnahme wird nicht abgefangen, sondern dank des finallyBlocks "-block" einfach in den Wartezustand versetzt. Dadurch wird die Ausnahmebedingung in den Wartezustand versetzt, indem tatsächlich ein Wert zurückgegeben wird, "1."+vbei dem ves sich um den zuvor verwendeten Index handelt. Es kommt auch vor, dass dieser Index mit der Nebenversionsnummer von Java übereinstimmt.

Ein wichtiger Teil des Golfspiels bestand darin, java.utilfür jede Version den kürzesten neuen Klassennamen im Paket (oder in einem beliebigen Kinderpaket) zu finden. Hier ist die Tabelle, die ich verwendet habe, um diese Kosten zu berechnen.

Base cost: `java.util.` (10 chars)

 Version | Class name (cost in chars)     | Reduced name (cost in chars)
---------+--------------------------------+---------------------------
 9       | java.util.zip.CRC32C (20)      | zip.CRC32C (10)
 1.8     | java.util.Base64 (16)          | Base64 (6)
 1.7     | java.util.Objects (17)         | Objects (7)
 1.6     | java.util.Deque (15)           | Deque (5)
 1.5     | java.util.UUID (14)            | UUID (4)
 1.4     | java.util.Currency (18)        | Currency (8)
 1.3     | java.util.Timer (15)           | Timer (5)
 1.2     | java.util.Map (13)             | Map (3)
 1.1     | java.util.Locale (16)          | Locale (6)
 1.0     | <default>                      | <default>
---------+--------------------------------+---------------------------
Subtotal |                      144 chars |                  54 chars
    Base |                                |                  10 chars
   Total |                      144 chars |                  64 chars

Credits

• 30 Bytes gespart dank Kevin Cruijssen (obwohl ich es getan habe, bevor ich seinen Kommentar gelesen habe, das verspreche ich!).
• 26 weitere Bytes dank Neil gespart (nein, darüber habe ich nicht nachgedacht)
• 12 Bytes dank Nevay und dem netten Out-of-the- Box- Try-Catch-Denken!
• Nochmal 11 Bytes von Neil und der schöne, tragbare finallyTrick.
• 2 weitere Bytes dank Kevin Cruijssen durch Ersetzen return(i<9?"1.":"")+i;durch return i<9?"1."+i:i;(dies muss gegen 1.0 oder höchstens 1.3 validiert werden, da vor 1.4 keine Syntaxänderungen stattgefunden haben)

Mit eingebauten

Wenn Builtins erlaubt wären:

String v(){return System.getProperty("java.version");}

54 Bytes für 13 Versionen (von 1,0 bis 12), die Punktzahl würde also 4,1538 betragen.

Python , 606 Bytes / 15 Versionen = Punktzahl 40,4

-67 Bytes (lol) dank NoOneIsHere.

Die Versionen sind 0.9.1, 2 (.0), 2.2, 2.2.2, 2.5.0, 2.5.1, 3 (.0), 3.1, 3.1.3, 3.2.1, 3.3, 3.4, 3.5 und 3.6 .

try:eval('1&2')
except:print('0.9.1');1/0
if`'\n'`<'\'\\n\'':print(2);1/0
try:from email import _Parser;print(2.2);1/0
except:0
try:eval('"go"in""')
except:print('2.2.2');1/0
try:int('2\x00',10);print(2.5);1/0
except:0
if pow(2,100)<1:print('2.5.1');1/0
if str(round(1,0))>'1':print(3);1/0
if format(complex(-0.0,2.0),'-')<'(-':print(3.1);1/0
if str(1.0/7)<repr(1.0/7):print('3.1.3');1/0
try:eval('u"abc"')
except:print('3.2.1');1/0
try:int(base=10);print(3.3);1/0
except:0
try:import enum
except:print('3.3.3');1/0
try:eval('[*[1]]')
except:print(3.4);1/0
try:eval('f""')
except:print(3.5);1/0
print(3.6)

Alles Verdienst der erstaunlichen Antwort von Sp3000 . Der abschließende Zeilenumbruch ist erforderlich.

Whee, das hat Spaß gemacht, Golf zu spielen. Dies sollte funktionieren (ja, ich habe jede dieser Versionen installiert), aber möglicherweise habe ich versehentlich etwas kaputtgemacht. Wenn jemand einen Fehler findet, lassen Sie es mich bitte wissen.

C ++ 14.11.17, Score = 147/3 = 49

Zur Unterscheidung zwischen C ++ 11 und C ++ const14/17 wird die Änderung der Standardeinstellung der Elementfunktionen constexprin C ++ 14 verwendet (das Beispiel hierzu finden Sie unter https://stackoverflow.com/questions/23980929/). Was-ändert-in-c14-eingeführt-kann-möglicherweise-ein-in-c1 ) geschriebenes-Programm-brechen . Zur Unterscheidung zwischen C ++ 14 und C ++ 17 wird die Tatsache verwendet, dass C ++ 17 Trigraphen deaktiviert hat.

#include<iostream>
#define c constexpr int v
struct A{c(int){return 0;}c(float)const{return*"??="/10;}};int main(){const A a;std::cout<<11+a.v(0);}

Ungolfed:

struct A {
    constexpr int v(int) { return 0; }
    constexpr int v(float) const {
        // with trigraphs, *"??=" == '#' == 35, v() returns 3
        // without trigraphs, *"??" == '?' == 63, v() returns 6
        return *("??=") / 10;
    }
};

int main() {
    const A a;
    std::cout << 11 + a.v(0);
}

(Getestet mit Debian gcc 7.1.0 unter -std=c++{11,14,17}.)

EcmaScript 3/5/2015/2016/2017 im Browser, 59 Bytes / 5 Versionen = 11,8 Punkte

alert(2017-2*![].map-2010*![].fill-![].includes-!"".padEnd)

1 Byte sparen dank GOTO 0

JavaScript (ES5 & ES6), 14 Byte / 2 Versionen = 7

alert(5^"0o3")

0o-Stil-Oktalkonstanten sind neu in ES6; ES5 wandelt den String um, auf NaNden sich das Ergebnis des bitweisen XOR nicht auswirkt.

JavaScript (ES 2, 3 & 5 - 8 9), 59/6 = 9,833 75/7 = 10,714

Kann die Lösung auch mit mehr Versionen einreichen, auch wenn sie etwas höher ist als die Lösung mit zwei Versionen.

alert(9-(/./.dotAll!=0)-!"".padEnd-![].includes-![].keys-2*![].map-![].pop)

Probieren Sie es online aus

Überprüft das Vorhandensein verschiedener Methoden in den Array-, RegExp- und String-Prototypen, negiert sie mit einem Booleschen Wert und subtrahiert diesen Booleschen Wert von einem Anfangswert von 9. Die Multiplikation der ![].mapKonten für die Tatsache, dass ES4 aufgegeben wurde.

• Die dotAllEigenschaft (und das zugehörige sFlag) für reguläre Ausdrücke wurde in ES2018 (v9) eingeführt.
• Die padEndString-Methode wurde in ES2017 (v8) eingeführt.
• Die includesArray-Methode wurde in ES2016 (v7) eingeführt.
• Die keysArray-Methode wurde in ES2015 (v6) eingeführt.
• Das mapArray - Verfahren wurde eingeführt ES5.1 (v5).
• Die popArray-Methode wurde in ES3 (v3) eingeführt.

PHP 5/7, Score 5.5

<?=7-"0x2";

3V4L es online!

PHP 5.3.9 / 5.3.11, Punktzahl 10

<?='5.3.'.(9-0x0+2);

3V4L es online!

Die Online-Version ist länger, da in alten PHP-Versionen auf der Sandbox keine kurzen Tags aktiviert sind.

Befunge: 15 11 Bytes / 2 Versionen = 5.5

4 Bytes von @ Pietu1998 abgeschnitten

"89",;5-;,@  

Probieren Sie es online aus:
Befunge 93
Befunge 98
Verwendet den Befunge 98-exklusiven Semikolon-Operator ("zum nächsten Semikolon springen"), um Versionen zu unterscheiden. Beide geben "9" aus. Befunge 93 ignoriert die Semikolons, subtrahiert 5 von "8" (Wert links oben auf dem Stapel), gibt die resultierende "3" aus und beendet den Vorgang. Befunge 98 hingegen überspringt, druckt "8" und beendet.

Pyth 4/5 - 6 Bytes / 2 Versionen = 3

  5 ;4

In Pyth 5 wird eine gerade Anzahl von Leerzeichen am Zeilenanfang beim Einrücken ignoriert, während sie in Pyth 4 nur wie ein einzelnes Leerzeichen fungiert und das Drucken der Zeichen verhindert 5. In Pyth 4 beenden Semikolons nur Anweisungen, die das 4Drucken ermöglichen, während in Pyth 5 ein Leerzeichen und ein Semikolon den Rest der Zeile zu einem Kommentar machen.

Python 3 und Python 2.0, 18 Bytes, erzielen 18/2 = 9

print(3-round(.5))

Bankerrundung in Python 3, Standardrundung in Python 2.

Probieren Sie es online aus - Python 3!

Probieren Sie es online aus - Python 2!

Kubisch 4 Bytes, Punktzahl 4 / ∞

B3%0

Funktioniert in jeder Version, in der Ihr System über genügend Arbeitsspeicher verfügt. Wettbewerbsverbot, weil es lahm ist. Gültig für diesen Metapost .

Grundsätzlich dreht B3 eine Reihe von der linken Seite in die obere Seite. F3 würde genauso gut funktionieren wie F & sub1; & sub3; oder B & sub1; & sub3 ;. Da eine Reihe in Cubically 3x3x3 aus drei Würfeln pro Würfel besteht, werden drei Würfel 1in die obere Fläche eingefügt, sodass eine %0Flächensumme von 3 entsteht. Diese obere Flächensumme wird gedruckt, wobei 3 für Cubically 3 x3x3 gedruckt wird.

In Cubically 4x4x4 sind Zeilen 4x1 Cubies. Setzt 4 Einsen auf die Oberseite und ergibt eine Summe von 4.

x86 16/32/64-Bit-Computercode: 11 Byte, Score = 3,66

Diese Funktion gibt den aktuellen Modus (Standardoperandengröße) als Ganzzahl in AL zurück. Nennen Sie es von C mit Unterschriftuint8_t modedetect(void);

NASM-Maschinencode + Quellenliste (zeigt, wie es im 16-Bit-Modus funktioniert, da BITS 16NASM angewiesen wird, die Quellmnemoniken für den 16-Bit-Modus zusammenzustellen.)

 1          machine      global modedetect
 2          code         modedetect:
 3 addr     hex          BITS 16

 5 00000000 B040             mov    al, 64
 6 00000002 B90000           mov    cx, 0       ; 3B in 16-bit.  5B in 32/64, consuming 2 more bytes as the immediate
 7 00000005 FEC1             inc    cl          ; always 2 bytes.  The 2B encoding of inc cx would work, too.
 8                       
 9                           ; want: 16-bit cl=1.   32-bit: cl=0
10 00000007 41               inc    cx       ; 64-bit: REX prefix
11 00000008 D2E8             shr    al, cl   ; 64-bit: shr r8b, cl doesn't affect AL at all.  32-bit cl=1.  16-bit cl=2
12 0000000A C3               ret
# end-of-function address is 0xB, length = 0xB = 11

Begründung :

Der x86-Maschinencode hat offiziell keine Versionsnummern, aber ich denke, dies befriedigt die Absicht der Frage, indem bestimmte Nummern erzeugt werden müssen, anstatt zu wählen, was am bequemsten ist (das dauert nur 7 Bytes, siehe unten).

Die ursprüngliche x86-CPU, Intels 8086, unterstützte nur 16-Bit-Maschinencode. 80386 führte den 32-Bit-Maschinencode ein (verwendbar im geschützten 32-Bit-Modus und später im Kompatibilitätsmodus unter einem 64-Bit-Betriebssystem). AMD hat 64-Bit-Maschinencode eingeführt, der im Langzeitmodus verwendet werden kann. Hierbei handelt es sich um Versionen der x86-Maschinensprache in demselben Sinne wie bei Python2 und Python3 um unterschiedliche Sprachversionen. Sie sind größtenteils kompatibel, aber mit absichtlichen Änderungen. Sie können ausführbare 32- oder 64-Bit-Dateien direkt unter einem 64-Bit-Betriebssystemkern ausführen, genauso wie Sie Python2- und Python3-Programme ausführen können.

Wie es funktioniert:

Beginnen Sie mit al=64. Verschieben Sie ihn um 1 (32-Bit-Modus) oder 2 (16-Bit-Modus) nach rechts.

• 16/32 vs. 64-Bit: Die 1-Byte inc/ decCodierungen sind REX-Präfixe in 64-Bit ( http://wiki.osdev.org/X86-64_Instruction_Encoding#REX_prefix ). REX.W beeinflusst einige Anweisungen überhaupt nicht (z. B. ein jmpoder jcc), aber in diesem Fall wollte ich, um 16/32/64 zu erhalten, eher inc oder dec ecxals eax. Das setzt auch REX.B, was das Zielregister ändert. Aber zum Glück können wir das schaffen, aber die Einrichtung von 64-Bit muss nicht verschoben werden al.

  Die Anweisung (en), die nur im 16-Bit-Modus ausgeführt werden, können u. A. Enthalten ret, ich fand dies jedoch nicht erforderlich oder hilfreich. (Und würde es unmöglich machen, als Code-Fragment inline zu gehen, falls Sie das wollten). Es könnte auch eine jmpinnerhalb der Funktion sein.

• 16-Bit vs. 32/64: Sofort sind 16-Bit statt 32-Bit. Durch Ändern der Modi kann die Länge eines Befehls geändert werden. Daher decodieren 32/64-Bit-Modi die nächsten zwei Bytes als Teil des unmittelbaren Befehls und nicht als separater Befehl. Ich habe die Dinge einfach gehalten, indem ich hier einen 2-Byte-Befehl verwendet habe, anstatt die Dekodierung nicht synchron zu machen, damit der 16-Bit-Modus aus anderen Befehlsgrenzen als 32/64 dekodiert.

  Verwandte Themen: Das Präfix für die Operandengröße ändert die Länge des Direktzugriffs (sofern es sich nicht um einen vorzeichenerweiterten 8-Bit-Direktzugriff handelt), genau wie der Unterschied zwischen 16-Bit- und 32/64-Bit-Modus. Dies macht es schwierig, eine Befehlslängendecodierung parallel durchzuführen; Intel-CPUs haben LCP-Dekodierungsstopps .

Die meisten Aufrufkonventionen (einschließlich der x86-32- und x86-64-System-V-psABIs) ermöglichen enge Rückgabewerte, die in den hohen Bits des Registers fehlerhaft sind. Sie ermöglichen auch das Clobbern von CX / ECX / RCX (und R8 für 64-Bit). IDK, wenn das in 16-Bit-Aufrufkonventionen üblich war, aber das ist Codegolf, also kann ich immer sagen, dass es sowieso eine benutzerdefinierte Aufrufkonvention ist.

32-Bit-Demontage :

08048070 <modedetect>:
 8048070:       b0 40                   mov    al,0x40
 8048072:       b9 00 00 fe c1          mov    ecx,0xc1fe0000   # fe c1 is the inc cl
 8048077:       41                      inc    ecx         # cl=1
 8048078:       d2 e8                   shr    al,cl
 804807a:       c3                      ret    

64-Bit-Demontage ( Online ausprobieren! ):

0000000000400090 <modedetect>:
  400090:       b0 40                   mov    al,0x40
  400092:       b9 00 00 fe c1          mov    ecx,0xc1fe0000
  400097:       41 d2 e8                shr    r8b,cl      # cl=0, and doesn't affect al anyway!
  40009a:       c3                      ret    

Verwandte: meine x86-32 / x86-64 polyglotten Maschinencode Q & A auf SO.

Ein weiterer Unterschied zwischen 16-Bit und 32/64 besteht darin, dass die Adressierungsmodi unterschiedlich codiert sind. zB lea eax, [rax+2]( 8D 40 02) dekodiert wie lea ax, [bx+si+0x2]im 16-Bit-Modus. Dies ist offensichtlich schwierig für Code-Golf zu verwenden, zumal e/rbxund e/rsiin vielen Call-Konventionen die Call-Erhaltung gewährleistet ist.

Ich habe auch überlegt, das 10-Byte-Format zu verwenden mov r64, imm64, das REX + ist mov r32,imm32. Da ich aber bereits eine 11-Byte-Lösung hatte, wäre dies bestenfalls gleich (10 Byte + 1 für ret).

Testcode für 32- und 64-Bit-Modus. (Ich habe es noch nicht im 16-Bit-Modus ausgeführt, aber die Disassembly gibt an, wie es dekodiert wird. Ich habe keinen 16-Bit-Emulator eingerichtet.)

; CPU p6   ;  YASM directive to make the ALIGN padding tidier
global _start
_start:
    call   modedetect
    movzx  ebx, al
    mov    eax, 1
    int    0x80        ; sys_exit(modedetect());

align 16
modedetect:
BITS 16
    mov    al, 64
    mov    cx, 0       ; 3B in 16-bit.  5B in 32/64, consuming 2 more bytes as the immediate
    inc    cl          ; always 2 bytes.  The 2B encoding of inc cx would work, too.

    ; want: 16-bit cl=1.   32-bit: cl=0
    inc    cx       ; 64-bit: REX prefix
    shr    al, cl   ; 64-bit: shr r8b, cl doesn't affect AL at all.  32-bit cl=1.  16-bit cl=2
    ret

Dieses Linux-Programm wird mit exit-status = beendet modedetect(). Führen Sie es also aus als ./a.out; echo $?. Bauen Sie es zusammen und verknüpfen Sie es in eine statische Binärdatei, z

$ asm-link -m32 x86-modedetect-polyglot.asm && ./x86-modedetect-polyglot; echo $?
+ yasm -felf32 -Worphan-labels -gdwarf2 x86-modedetect-polyglot.asm
+ ld -melf_i386 -o x86-modedetect-polyglot x86-modedetect-polyglot.o
32
$ asm-link -m64 x86-modedetect-polyglot.asm && ./x86-modedetect-polyglot; echo $?
+ yasm -felf64 -Worphan-labels -gdwarf2 x86-modedetect-polyglot.asm
+ ld -o x86-modedetect-polyglot x86-modedetect-polyglot.o
64

## maybe test 16-bit with BOCHS somehow if you really want to.

7 Bytes (Punktzahl = 2,33), wenn ich die Versionen 1, 2, 3 nummerieren kann

Es gibt keine offiziellen Versionsnummern für verschiedene x86-Modi. Ich schreibe einfach gerne asm Antworten. Ich denke, es würde die Absicht der Frage verletzen, wenn ich nur die Modi 1,2,3 oder 0,1,2 nenne, weil der Punkt darin besteht, Sie zu zwingen, eine unbequeme Zahl zu erzeugen. Aber wenn das erlaubt war:

 # 16-bit mode:
42                                  detect123:
43 00000020 B80300                      mov ax,3
44 00000023 FEC8                        dec al
45                                  
46 00000025 48                          dec ax
47 00000026 C3                          ret

Welches dekodiert im 32-Bit-Modus als

08048080 <detect123>:
 8048080:       b8 03 00 fe c8          mov    eax,0xc8fe0003
 8048085:       48                      dec    eax
 8048086:       c3                      ret    

und 64-Bit als

00000000004000a0 <detect123>:
  4000a0:       b8 03 00 fe c8          mov    eax,0xc8fe0003
  4000a5:       48 c3                   rex.W ret 

Brachylog / Brachylog v1 , 5/2 = 2,5

2,1hw

Probieren Sie es online! (Brachylog)

Probieren Sie es online! (Brachylog v1)

Erklärung für Brachylog:

?2,1hw.
?2      Unify ? (input) with 2 (no input so it succeeds)
  ,1    Append 1 (21)
    h   First element/head (2)
     w. Write to STDOUT and unify with output (not displayed)

Erklärung für Brachylog v1:

?2,1hw.
?2      Unify ? (input) with 2 (no input so it succeeds)
  ,     Break implicit unification/logical AND
   1h   Take first element/head of 1 (1)
     w. Write to STDOUT and unify with output (not displayed)

C89 / C99, 25 Bytes, 2 Versionen, Score = 12,5

#include <stdio.h>

int main() {
    int v = 11 //**/ 11
            + 88;
    printf("C%d\n", v);
    return 0;
}

// Stilkommentare werden in C89 nicht erkannt.

Golf Version:

v(){return 20//**/2
+79;}

Versuchen Sie es online: C89 , C99

Perl 5 und Perl 6, 23 Bytes, 19 Bytes, Punktzahl 9,5

print 6-grep '.',''

Perl 5 grepfirst op wird immer als regulärer Ausdruck behandelt, nicht so in Perl 6.

Bash, alle 4 Versionen, 72 71 32 Bytes ⇒ Score = 8

s=$'\ua\xa\n';expr 5 - ${#s} / 2

In diesem Codeteil werden $'...'in jeder Version von Bash unterschiedliche Interpretationen von Zeichenfolgen verwendet.
Gibt die Hauptversionsnummer aus - und das wars.

Doc hier gefunden .

Ungolfed:

s=$'\ua\xa\n';
expr 5 - ${#s} / 2
# Bash v4 sees three linefeeds => length of 3 => 5 - 3 / 2 = 4
# Bash v3 sees the literal '\ua' + two linefeeds: 5 chars in length
#    => 5 - 5 / 2 = 3
# Bash v2 sees '\ua\xa' + linefeed, 7 chars: 5 - 7 / 2 = 2
# Bash v1 does not even interpret $'..' strings, and sees literally '$\ua\xa\n' of length 9 => 5 - 9 / 2 = 1

Diese Antwort ist zur Hälfte eine Vermutung; Ich habe es nur in Bash 4 und 3 getestet, aber es sollte auch in anderen Versionen funktionieren.

Lassen Sie mich wissen, wenn dies nicht der Fall ist. Ich werde es mit anderen Versionen versuchen, sobald sie verfügbar sind.

-1 char danke an Jens.
-29 Bytes dank Digital Trauma (die ganze exprIdee)!

R, Version 2 und 3, Punktzahl: 10,5 Punkte

cat(exists("cite")+2)

Dieser Befehl wird 2für R 2.xx und 3R 3.xx zurückgegeben. Die Funktion citewurde in R Version 3.0.0 hinzugefügt. Daher exists("cite")kehrt der Befehl FALSEfür R 2.xx und TRUEfür R 3.xx zurück

R, alle Versionen (1, 2 und 3), Punktzahl: 12⅓ Punkte

e=exists;cat(e("cite")+e("eapply")+1)

Die Funktion eapplywurde in R 2.0.0 eingeführt.

Python , 196 Bytes / 16 Versionen = Punktzahl 12,25

Die Versionen sind 1.5, 1.6, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 3.0, 3.1, 3.2, 3.3, 3.4, 3.5 und 3.6.
Leider musste ich 2.7 weglassen, da keine Module enthalten sind es ist (soweit ich das beurteilen kann) nicht in 2.6 sondern in 3.0.

i=15
try:
 for m in'os.atexit.os.os.os.warnings.cgitb.heapq.collections._ast.abc.queue.os.os.os.importlib.argparse.lzma.asyncio.zipapp.secrets.'.split('.'):__import__(m);i=i+1
except:print(i/10.)

Wir durchlaufen eine Reihe von Modulen, die in verschiedenen Versionen von Python eingeführt wurden, und beim ersten Fehler beenden wir die Version und geben sie zurück. Die Lücken zwischen den Hauptversionen werden durch wiederholtes Importieren geschlossen os. Der Test für Python 1.5 basiert darauf string.split, dass er erst ab 1.6 verfügbar ist.

Dank an Olivier Grégoire für die Idee, neue Klassen / Module in einer Schleife zu testen.

Ich habe jetzt endlich alle relevanten Versionen von Python getestet ... was das Bearbeiten des 1.5-Quellcodes erforderte, um es zu kompilieren ...

Windows-Batchdatei , 35 Byte / 2 Versionen = Punktzahl 17,5

@if /i Z==z @echo NT&exit
@echo DOS

Druckt DOSunter MS-DOS ^(duh) und NTWindows NT. ^(duh)

Nun zur Erklärung.

Windows verwendet seit MS-DOS-Zeiten Batch-Skripte und hat sich seitdem kaum verändert. Als Windows NT hinzukam, änderte Microsoft jedoch den Standardinterpreter für Stapelskripte von COMMAND.COMauf cmd.exe(und erlaubte nun auch die Erweiterung .cmdals Alternative zum Original .bat).

Damit haben sie auch einige Änderungen implementiert , wie z. B. das /iFlag zum Ignorieren von Groß- und Kleinschreibung bei Bedingungen. Das heißt, während Z==zes falsch ist, /i Z==zist es wahr.

Wir nutzen aus, dass DOS keine Unterscheidung zwischen Groß- Zund Kleinschreibung aufwies, und vergleichen Groß- und Kleinschreibung z. Durch die Verwendung des /iFlags erhalten wir eine Z==z(falsche) Bedingung für DOS und z==z(true) für NT.

Jetzt ist mir klar, dass die Herausforderung angibt, dass eine Versionsnummer gedruckt werden soll. Soweit ich weiß, gibt es jedoch keine 'Versionsnummer' für Batch-Skripte. Dies ist also die nächstgelegene, die ich bekommen könnte.

Getestet unter Windows 10, DOSBox und vDos:

Windows 10:

(mit cmd /kausführen, um das Schließen des Fensters zu verhindern exit)

DOSBox:

vDos:

Wolfram Language / Mathematica 10/11, 37 Bytes / 2 Versionen = 18.5

Betrachten Sie (Length@DateRange[{1},{1}][[1]]+27)/3, bei 37 Bytes und der Arbeit mit 2 Versionen, gibt mir eine Punktzahl von 18,5.

In[1]:= $Version

Out[1]= "10.4.1 for Microsoft Windows (64-bit) (April 11, 2016)"

In[2]:= (Length@DateRange[{1}, {1}][[1]] + 27)/3

Out[2]= 10

und

In[1]:= $Version

Out[1]= "11.1.1 for Microsoft Windows (64-bit) (April 18, 2017)"

In[2]:= (Length@DateRange[{1}, {1}][[1]] + 27)/3

Out[2]= 11

Ich bin mir sicher, dass es einen effizienteren Weg gibt, aber die Diskrepanz zwischen der DateRange-Ausgabe hat mich kürzlich in den Hintern gebissen, also war ich entschlossen, das zu verwenden.

In der Folge könnte wahrscheinlich jemand die Vorteile einer Length@DateRange[{1}, {1}][[1]]Evaluierung 1in Mathematica-Versionen 1 bis 8 nutzen, aber ich hatte keine Zeit, dies zu berücksichtigen .

Ruby 1.x und 2.x, 20 Bytes, 10 Punkte

p [].to_h&&2rescue 1

Basierend auf der to_hMethode, die Arrayin Ruby 2 für die Klasse eingeführt wurde .

Erlang, 180 Bytes, 11 Versionen, 16,36 Punkte

20-length([A||A<-[schedulers,c_compiler_used,cpu_topology,snifs,dynamic_trace,port_count,nif_version,end_time,max_heap_size,atom_count],{'EXIT',_}<-[catch erlang:system_info(A)]]).

Mit Einrückung und Zeilenumbrüchen:

20-length([A||A<-
                  [schedulers,
                   c_compiler_used,
                   cpu_topology,
                   snifs,
                   dynamic_trace,
                   port_count,
                   nif_version,
                   end_time,
                   max_heap_size,
                   atom_count],
              {'EXIT',_}<-[catch erlang:system_info(A)]]).

Getestet auf einer Nebenversion jeder Hauptversion seit 10:

• R10B-9
• R11B-5
• R12B-5
• R13B04
• R14B04
• R15B03
• R16B03
• 17.5.6.2
• 18.2.1
• 19.2
• 20,0

Die Idee ist, dass jede Hauptversion mindestens ein neues zulässiges Argument für die Funktion hinzugefügt hat. Probieren Sie erlang:system_infoalso die in der Liste aufgeführten aus, zählen Sie, wie viele von ihnen fehlschlagen, und subtrahieren Sie die Anzahl der Fehler von 20, der aktuellen Version.

Julia 0,4, 0,5, 46 Bytes, Punktzahl 22

f(::ASCIIString)=.4
f(::String)=.5
f()=f("")

Julia hat den Typnamen der konkreten und abstrakten String-Typen in vielen Versionen geändert.

Dieser Code bietet insbesondere folgende Vorteile:

Julia 0.4 :

• Beton ist ASCIIString,
• Zusammenfassung ist offiziell AbstractString,
• Abstract hat den Alias ​​für veraltet String.
• Beton ist am spezifischsten als abstrakt, daher gewinnt er den Versand

Julia 0.5 :

• Beton ist offiziell String,
• Beton hat Alias ​​veraltet ASCIIString,
• Abstrakt ist AbstractString(obwohl das hier keine Rolle spielt)
• Da für den konkreten String-Typ zwei Methoden definiert wurden, überschreibt die letztere die erstere.

Siehe auch meine neuere effektivere Lösung, die auf verschiedenen Prinzipien basiert

Japt (1 & 2), 8 6/2 = 4 3

'1r\S2

Test v1  |   Test v2

• 2 Bytes gespart dank Oliver

Erläuterung

Vor Version 2 verwendete Japt eine angepasste RegEx-Syntax, sodass wir diese nutzen können.

'1

Die Nummer 1 als Zeichenfolge.

 r  2

Ersetzen Sie ( r) das unten stehende durch a 2.

\S

Japt 2 sieht dies als den RegEx an /\S/g, der dem entspricht 1. Japt 1 ignoriert das \Escape-Zeichen und sieht nur das S, was die Japt-Konstante für ein Leerzeichen ist und offensichtlich nicht mit dem übereinstimmt 1.

Befunge, score = 3.5

7 Bytes, 2 Versionen

"]"'b.@

Versuchen Sie es online in Befunge-93
Versuchen Sie es online in Befunge-98

"]"ist in beiden Versionen ein String-Literal, das 93 (den ASCII-Wert von [) auf den Stack schiebt . 'bist ein Zeichenliteral in Befunge-98, das 98 (den ASCII-Wert von b) drückt , aber dies sind ungültige Anweisungen in Befunge-93, sodass sie einfach ignoriert werden. Wir beenden also mit 93 oben auf dem Stapel in Befunge-93 und 98 in Befunge-98. .@Schreibt den Wert oben auf den Stapel und beendet ihn dann.

Ruby 1.x (<1,9) und 2.x, 10 8 Bytes, Score = 4

$><<?2%7

Versuch es:

• Ruby 1.8.7
• Ruby 2.0.0

Dies funktioniert, indem die unterschiedlichen Verhaltensweisen von ?xRuby 1.x und 2.x ausgenutzt werden . In Ruby 1.x wird ?A(zum Beispiel) 65der ASCII-Wert des Zeichens zurückgegeben A, in Ruby 2.0 jedoch die Zeichenfolge mit einem Zeichen "A".

Der obige Code ist äquivalent dazu:

val = ?2
$> << val % 7

In Ruby 1.x (<1,9), der Wert valist 50(der ASCII - Wert des Zeichens 2), ein Fixnum. Fixnum#%ist der Modulo-Operator, also 50 % 7kehrt er zurück 1.

In Ruby 2.x valist die Zeichenfolge "2". String#%ist eine Infix-Version von sprintf, "2" % 7entspricht also sprintf("2", 7), wo "2"ist der Format-String. Da der Formatstring keine Formatsequenzen enthält (z. B. %d), werden nachfolgende Argumente verworfen und "2"zurückgegeben.

Ist schließlich $>ein Alias ​​für $stdout, so wird $> << ...das Ergebnis gedruckt.

Python 2 und Python 3 , 36 34 Bytes, Punktzahl 18 17

print(str(hash(float('-inf')))[1])

In Python 2 ist der Hash mit der negativen Unendlichkeit -271828, in Python 3 -314159. Bearbeiten: 2 Bytes, 1 Punkt, dank @ArBo gespeichert.

Python 3 , Python 2 , Punktzahl 17,5

(35 Bytes, 2 Versionen)

try:exec("print 2")
except:print(3)

Python 2 , 35 Bytes

Probieren Sie es online!

Python 3 , 35 Bytes

Probieren Sie es online!

5 Bytes gespart dank ETHproductions

Keine gute Code Golf Antwort, aber eine massive Veränderung!