ความท้าทายของคุณคือการเขียนรูปหลายภาษาที่ทำงานในภาษาของคุณในเวอร์ชันที่แตกต่างกัน เมื่อเรียกใช้มันจะส่งออกเวอร์ชันภาษาเสมอ

กฎระเบียบ

• โปรแกรมของคุณควรทำงานในภาษาของคุณอย่างน้อยสองเวอร์ชัน
• ผลลัพธ์ของโปรแกรมของคุณควรเพียงเป็นหมายเลขรุ่น ไม่มีข้อมูลภายนอก
• โปรแกรมของคุณอาจใช้วิธีการใดก็ได้ที่คุณต้องการกำหนดหมายเลขรุ่น อย่างไรก็ตามผลลัพธ์จะต้องเป็นไปตามกฎ 2 อย่างไรก็ตามคุณกำหนดหมายเลขเวอร์ชันผลลัพธ์จะต้องเป็นตัวเลขเท่านั้น
• โปรแกรมของคุณต้องการส่งออกเวอร์ชันภาษาหลักเท่านั้น ตัวอย่างเช่นใน FooBar 12.3.456789-beta โปรแกรมของคุณจะต้องให้ผลลัพธ์ 12 เท่านั้น
• หากภาษาของคุณใส่คำหรือสัญลักษณ์ไว้ข้างหน้าหรือหลังหมายเลขเวอร์ชั่นคุณไม่จำเป็นต้องส่งออกหมายเลขเหล่านั้น ตัวอย่างเช่นใน C89 โปรแกรมของคุณจำเป็นต้องพิมพ์89เท่านั้นและใน C ++ 0x โปรแกรมของคุณต้องพิมพ์0เท่านั้น
• หากคุณเลือกที่จะพิมพ์ชื่อเต็มหรือหมายเลขรุ่นรองเช่น C89 เมื่อเทียบกับ C99 นั้นจะต้องเพียงพิมพ์ชื่อ C89 build 32ถูกต้องในขณะที่error in C89 build 32: foo barไม่
• โปรแกรมของคุณไม่สามารถใช้แฟล็กคอมไพเลอร์ในตัวแมโครหรือกำหนดเองเพื่อกำหนดรุ่นภาษา

เกณฑ์การให้คะแนน

คะแนนของคุณจะเป็นความยาวของรหัสหารด้วยจำนวนรุ่นที่ใช้งานได้คะแนนต่ำสุดชนะได้โชคดี!

อย่างจริงจังและเป็นจริง 3 ไบต์คะแนน 1.5

'1u

ลองมันออนไลน์: ที่จริง , อย่างจริงจัง

คำอธิบาย:

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

uและDมีการเพิ่มฟังก์ชันการทำงานกับสตริงใน Actually (ซึ่งเป็น v2 อย่างจริงจัง)

Python 3.0 และ Python 2 คะแนน 6

(12 ไบต์, 2 เวอร์ชั่น)

print(3/2*2)

ลองออนไลน์:

• Python 2

• Python 3

อาศัยความจริงที่ว่า Python 3+ ใช้การแบ่งแบบลอยตามค่าเริ่มต้นซึ่งแตกต่างจาก Python 2 ซึ่งใช้การแบ่งชั้น

Java, 189 ไบต์, 10 เวอร์ชัน, คะแนน = 18.9

รุ่นที่รองรับ: 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8และ9

(สำหรับคะแนนก่อนหน้าตรวจสอบประวัติ !)

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

รันบน Java 8
รันบน Java 9 หรือใหม่กว่า

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

โปรดทราบว่าส่วนรหัสreturn v<9?"1."+v:v;(ก่อนหน้านี้return(v<9?"1.":"")+v;) จะต้องมีการตรวจสอบกับรุ่นใด ๆ ระหว่าง Java 1.0 และ Java 1.3 รวม ฉันไม่มีการติดตั้ง Java 1.3 หรือรุ่นก่อนหน้านี้เพื่อทดสอบไวยากรณ์นี้

บทนำ

การกำหนดเวอร์ชัน Java มีประวัติพิเศษ ทุกรุ่นได้รับในอดีตรวมทั้ง1.x 1.0แต่ ... จาก Java 9 เป็นต้นไปและJEP223รุ่นวางแผนที่มีการเปลี่ยนแปลงจากการใช้เพื่อ1.x xนั่นคือรุ่นที่รู้จักกันภายใน ดังนั้นเราจึงมีตารางต่อไปนี้ (รวบรวมพร้อมกับ Javadoc และ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

"java.version"รายการความท้าทายนี้ตรงกับคอลัมน์รุ่นในตารางข้างต้นซึ่งเป็นสิ่งที่มีอยู่ในสถานที่ให้บริการระบบ

คำอธิบาย

เป้าหมายคือการตรวจสอบว่าระดับเริ่มต้นของคลาสที่มีอยู่เนื่องจาก Java เลิกใช้รหัส แต่ไม่เคยลบออก รหัสที่ได้รับการเขียนโดยเฉพาะในชวา 1.0 เข้ากันได้กับทุกรุ่นอีกครั้งเพราะตั้ง JDK เป็น (ส่วนใหญ่) แหล่งที่มาคอยที่เข้ากันได้

การใช้งานพยายามค้นหาชื่อคลาสที่สั้นที่สุดที่แต่ละเวอร์ชันแนะนำ ถึงแม้ว่าจะได้รับ bytes ก็จำเป็นต้องลองและเลือก subpackage ทั่วไป จนถึงตอนนี้ฉันพบว่าแพ็คเกจที่มีประสิทธิภาพที่สุดคือjava.utilเพราะมันมีคลาสสั้น ๆ ที่มีชื่อจริง ๆ กระจายอยู่ทั่วทุกเวอร์ชั่นของ Java

ตอนนี้เพื่อค้นหาหมายเลขรุ่นจริงชื่อคลาสจะถูกจัดเรียงโดยแนะนำรุ่น จากนั้นฉันพยายามที่จะเริ่มต้นแต่ละชั้นตามลำดับและเพิ่มดัชนีอาร์เรย์ หากชั้นเรียนมีอยู่เราข้ามไปยังตำแหน่งถัดไปไม่เช่นนั้นเราจะปล่อยให้ข้อยกเว้นถูกtryบล็อก -block เมื่อดำเนินการเสร็จแล้วจะมีการโยนข้อยกเว้นอื่นเนื่องจากไม่มีคลาสเพิ่มเติมที่เราจำเป็นต้องตรวจสอบ

ไม่ว่าในกรณีใดเธรดจะปล่อยให้try-block มีข้อยกเว้น ข้อยกเว้นนั้นไม่ได้ถูกจับ แต่เพียงพักไว้ขอบคุณfinally-block ซึ่งจะแทนที่ข้อยกเว้นที่ถูกระงับโดยคืนค่าจริงซึ่งเป็น"1."+vที่ที่vดัชนีใช้ก่อนหน้านี้ นอกจากนี้ยังเกิดขึ้นเราทำดัชนีนี้ตรงกับหมายเลขเวอร์ชันรองของ Java

ส่วนสำคัญของสนามกอล์ฟคือการหาชื่อคลาสใหม่ที่สั้นที่สุดในแพ็คเกจjava.util(หรือชุดลูก ๆ ) สำหรับแต่ละรุ่น นี่คือตารางที่ฉันใช้คำนวณค่าใช้จ่ายนั้น

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

เครดิต

• บันทึก 30 ไบต์ขอบคุณ Kevin Cruijssen (แม้ว่าฉันจะทำก่อนที่จะอ่านความคิดเห็นของเขาฉันสัญญา!)
• 26 ไบต์ช่วยได้มากขึ้นขอบคุณ Neil (ไม่ฉันไม่ได้คิดที่จะทำ)
• 12 ไบต์ขอบคุณที่ Nevay และดีออกของ-boxลองจับความคิด!
• 11 ไบต์เพิ่มเติมโดย Neil อีกครั้งและfinallyเคล็ดลับพกพาที่ดี
• 2 ไบต์ขึ้นไปต้องขอบคุณ Kevin Cruijssen โดยแทนที่return(i<9?"1.":"")+i;ด้วยreturn i<9?"1."+i:i;(ต้องได้รับการตรวจสอบความถูกต้องกับ 1.0 หรือมากที่สุด 1.3 เนื่องจากไม่มีการเปลี่ยนแปลงไวยากรณ์เกิดขึ้นก่อน 1.4)

ด้วย builtins

หาก buildins ได้รับอนุญาต:

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

54 ไบต์สำหรับ 13 รุ่น (1.0 ถึง 12) ดังนั้นคะแนนจะเท่ากับ 4.1538

Python 606 ไบต์ / 15 เวอร์ชั่น = คะแนน 40.4

-67 ไบต์ (lol) ต้องขอบคุณ NoOneIsHere

รุ่นต่าง ๆ ได้แก่ 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.3, 3.4, 3.5 และ 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)

เครดิตทั้งหมดให้กับคำตอบที่น่าตื่นตาตื่นใจของ SP3000 ขึ้นบรรทัดใหม่ที่จำเป็น

นั่นมันสนุกกับการเล่นกอล์ฟ สิ่งนี้ควรใช้งานได้ (ใช่ฉันติดตั้งทุกเวอร์ชั่น) แต่ฉันอาจทำอะไรบางอย่างผิดปกติ หากใครพบข้อผิดพลาดโปรดแจ้งให้เราทราบ

C ++ 11/14/17 คะแนน = 147/3 = 49

เพื่อแยกความแตกต่างระหว่าง C ++ 11 และ C ++ 14/17 จะใช้การเปลี่ยนแปลงในconstness เริ่มต้นของconstexprฟังก์ชั่นสมาชิกใน C ++ 14 (ด้วยเครดิตกับตัวอย่างที่https://stackoverflow.com/questions/23980929/ what-เปลี่ยนแปลง -in-in-c14-can-break-a-program-write-in-c1 ) ในการแยกความแตกต่างระหว่าง C ++ 14 และ C ++ 17 จะใช้ข้อเท็จจริงว่า C ++ 17 ปิดใช้งาน trigraphs

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

(ทดสอบกับ Debian gcc 7.1.0 โดยใช้-std=c++{11,14,17})

EcmaScript 3/5/2015/2016/2017 ในเบราว์เซอร์ 59 ไบต์ / 5 รุ่น = 11.8 คะแนน

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

บันทึก 1 ไบต์ต้องขอบคุณ GOTO 0

JavaScript (ES5 & ES6), 14 ไบต์ / 2 เวอร์ชั่น = 7

alert(5^"0o3")

0oค่าคงที่ฐานแปดเป็นของใหม่ใน ES6; ES5 ปลดสตริงNaNที่ไม่ส่งผลต่อผลลัพธ์ของ bitor XOR

JavaScript (ES 2, 3 & 5 - 8 9), 59/6 = 9.833 75/7 = 10.714

อาจส่งโซลูชันที่มีเวอร์ชันมากกว่านี้เช่นกันแม้ว่าจะได้คะแนนสูงกว่าโซลูชันรุ่น 2 เล็กน้อย

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

ลองออนไลน์

ตรวจสอบการมีอยู่ของวิธีการต่าง ๆ ใน Array, RegExp & String prototypes, คัดค้าน, ให้บูลีน, และลบบูลีนจากค่าเริ่มต้นที่ 9 การคูณ![].mapบัญชีสำหรับข้อเท็จจริงที่ ES4 ถูกทอดทิ้ง

• dotAllคุณสมบัติ (และที่เกี่ยวข้องsธง) สำหรับนิพจน์ทั่วไปเป็นที่รู้จักในES2018 (V9)
• padEndวิธี String เป็นที่รู้จักในES2017 (V8)
• includesวิธีอาร์เรย์เป็นที่รู้จักในES2016 (v7)
• keysวิธีอาร์เรย์เป็นที่รู้จักในES2015 (v6)
• มีmapการแนะนำวิธีการ Array ในES5.1 (v5)
• มีpopการแนะนำวิธีการ Array ในES3 (v3)

PHP 5/7, คะแนน 5.5

<?=7-"0x2";

3V4L ออนไลน์!

PHP 5.3.9 / 5.3.11, คะแนน 10

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

3V4L ออนไลน์!

เวอร์ชันออนไลน์นั้นยาวกว่าเพราะ PHP เวอร์ชันเก่าบนแซนด์บ็อกซ์ไม่มีการเปิดใช้งานแท็กสั้น ๆ

Befunge: 15 11 ไบต์ / 2 เวอร์ชั่น = 5.5

4 ไบต์ถูกโกนออกโดย @ Pietu1998

"89",;5-;,@  

ลองใช้งานออนไลน์:
Befunge 93
Befunge 98
ใช้โอเปอเรเตอร์เครื่องหมายอัฒภาค Befunge 98 เอกสิทธิ์ ("ข้ามไปยังเครื่องหมายอัฒภาคถัดไป") เพื่อแยกความแตกต่างของรุ่น ทั้งสองจะพิมพ์ "9" Befunge 93 จะละเว้นเซมิโคลอนลบ 5 จาก "8" (ค่าที่เหลืออยู่ด้านบนของสแต็ค) พิมพ์ผลลัพธ์ "3" และยกเลิก Befunge 98 ในอีกทางหนึ่งจะข้ามไปพิมพ์ "8" และยุติ

Pyth 4/5 - 6 ไบต์ / 2 เวอร์ชั่น = 3

  5 ;4

ใน Pyth 5 ในจำนวนที่ช่องว่างในช่วงเริ่มต้นของเส้นจะถูกละเว้นสำหรับใช้ในการเยื้องในขณะที่ใน Pyth 4 5ก็แค่ทำหน้าที่เหมือนพื้นที่เดียวและป้องกันการพิมพ์ ใน Pyth 4 เครื่องหมายเซมิโคลอนเพิ่งจบประโยคซึ่งอนุญาตให้4พิมพ์ในขณะที่ใน Pyth 5 ช่องว่างและเครื่องหมายอัฒภาคทำให้ส่วนที่เหลือของบรรทัดแสดงความคิดเห็น

Python 3 และ Python 2.0, 18 ไบต์, คะแนน 18/2 = 9

print(3-round(.5))

การปัดเศษของ Banker ใน Python 3, การปัดเศษมาตรฐานใน Python 2

ลองออนไลน์ - Python 3!

ลองออนไลน์ - Python 2!

ในมุมกว้าง 4 ไบต์ให้คะแนน 4 /

B3%0

ทำงานได้ในทุกรุ่นที่ระบบของคุณมีหน่วยความจำเพียงพอที่จะเรียกใช้ ไม่ใช่การแข่งขันเพราะมันเป็นง่อย ใช้ได้ต่อเมตาโพสต์นี้นี้

โดยทั่วไป B3 จะหมุนหนึ่งแถวจากใบหน้าด้านซ้ายไปยังใบหน้าด้านบน F3 ก็ใช้ได้เช่นกันเช่นเดียวกับF₁3หรือB₁3 เนื่องจากหนึ่งแถวใน Cubically 3x3x3 คือสาม cubelets โดยหนึ่ง cubelet สิ่งนี้ทำให้สาม1's บนใบหน้าด้านบนให้ผลรวมใบหน้าของ 3. %0พิมพ์ที่ผลรวมใบหน้าด้านบนที่พิมพ์ 3 สำหรับ Cubically 3 x3x3

ในเชิง 4x4x4 แถวคือ 4x1 cubies วาง 4 1 ลงบนใบหน้าด้านบนโดยให้ผลรวมเป็น 4

x86 รหัสเครื่อง 16/32/64 บิต: 11 ไบต์, คะแนน = 3.66

ฟังก์ชันนี้จะคืนค่าโหมดปัจจุบัน (ขนาดตัวถูกดำเนินการเริ่มต้น) เป็นจำนวนเต็มใน AL โทรจาก C พร้อมลายเซ็นuint8_t modedetect(void);

รายการรหัสเครื่องจักร + แหล่งที่มาของ NASM (แสดงวิธีการทำงานในโหมด 16 บิตเนื่องจากBITS 16บอกให้ NASM รวบรวมข้อมูลช่วยจำแหล่งที่มาสำหรับโหมด 16 บิต)

 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

การให้เหตุผล :

รหัสเครื่อง x86 ไม่มีหมายเลขรุ่นเป็นทางการ แต่ฉันคิดว่านี่เป็นไปตามเจตนาของคำถามโดยต้องสร้างตัวเลขเฉพาะแทนที่จะเลือกสิ่งที่สะดวกที่สุด (ใช้เวลาเพียง 7 ไบต์ดูด้านล่าง)

ซีพียู x86 ดั้งเดิมของ Intel 8086 รองรับเฉพาะรหัสเครื่อง 16 บิต 80386 แนะนำรหัสเครื่อง 32 บิต (ใช้งานได้ในโหมดป้องกันแบบ 32 บิตและรุ่นที่ใหม่กว่าในโหมดที่เข้ากันได้ภายใต้ระบบปฏิบัติการ 64 บิต) AMD แนะนำรหัสเครื่อง 64 บิตซึ่งสามารถใช้งานได้ในโหมด Long เหล่านี้เป็นรุ่นของภาษาเครื่อง x86 ในลักษณะเดียวกับที่ Python2 และ Python3 เป็นรุ่นภาษาที่แตกต่างกัน พวกเขาส่วนใหญ่เข้ากันได้ แต่มีการเปลี่ยนแปลงโดยเจตนา คุณสามารถรันไฟล์ปฏิบัติการ 32 หรือ 64- บิตโดยตรงภายใต้เคอร์เนลระบบปฏิบัติการ 64 บิตในลักษณะเดียวกับที่คุณสามารถรันโปรแกรม Python2 และ Python3

มันทำงานอย่างไร:

al=64เริ่มต้นด้วย เลื่อนไปทางขวา 1 (โหมด 32 บิต) หรือ 2 (โหมด 16 บิต)

• 16/32 กับ 64- บิต: 1 ไบต์inc/ การdecเข้ารหัสเป็นส่วนนำหน้า REX ใน 64- บิต ( http://wiki.osdev.org/X86-64_Instruction_Encoding#REX_prefix ) REX.W ไม่ได้ส่งผลกระทบต่อคำแนะนำบางอย่างที่ทุกคน (เช่นjmpหรือjcc) แต่ในกรณีนี้จะได้รับ 16/32/64 ผมอยากจะ inc หรือธันวาคมมากกว่าecx eaxที่ยังกำหนดREX.Bซึ่งเปลี่ยนการลงทะเบียนปลายทาง แต่โชคดีที่เราสามารถทำให้การทำงานนั้น แต่การตั้งค่าสิ่งขึ้นดังนั้น 64 alบิตไม่จำเป็นต้องเปลี่ยน

  คำสั่งที่ทำงานเฉพาะในโหมด 16 บิตอาจรวมถึง a retแต่ฉันไม่พบว่าจำเป็นหรือมีประโยชน์ (และจะทำให้ไม่สามารถอินไลน์เป็นส่วนย่อยของโค้ดในกรณีที่คุณต้องการทำเช่นนั้น) มันอาจเป็นjmpฟังก์ชั่นภายใน

• 16 บิตเทียบกับ 32/64: เป็น 16 บิตทันทีแทนที่จะเป็น 32 บิต โหมดการเปลี่ยนสามารถเปลี่ยนความยาวของคำสั่งได้ดังนั้นโหมด 32/64 บิตจะถอดรหัสสองไบต์ถัดไปซึ่งเป็นส่วนหนึ่งของทันทีแทนที่จะเป็นคำสั่งแยกต่างหาก ฉันทำสิ่งต่าง ๆ ได้ง่าย ๆ โดยใช้คำสั่ง 2 ไบต์ที่นี่แทนการถอดรหัสออกจากการซิงค์ดังนั้นโหมด 16 บิตจะถอดรหัสจากขอบเขตการสอนที่แตกต่างกันกว่า 32/64

  ที่เกี่ยวข้อง: คำนำหน้าขนาดตัวถูกดำเนินการเปลี่ยนความยาวของทันที (เว้นแต่ว่ามันเป็นสัญญาณขยาย 8 บิตทันที) เช่นเดียวกับความแตกต่างระหว่างโหมด 16 บิตและ 32/64 บิต ทำให้การถอดรหัสความยาวคำสั่งทำได้ยากในแบบคู่ขนาน ซีพียู Intel มี LCP แผงลอยถอดรหัส

แบบแผนการโทรส่วนใหญ่ (รวมถึง x86-32 และ x86-64 System V psABIs) อนุญาตให้ค่าส่งคืนแคบลงเพื่อให้มีขยะในบิตสูงของการลงทะเบียน พวกเขายังอนุญาตให้ clobbering CX / ECX / RCX (และ R8 สำหรับ 64- บิต) IDK ถ้าเป็นเรื่องปกติในการประชุมแบบ 16 บิต แต่นี่คือรหัสกอล์ฟดังนั้นฉันสามารถบอกได้เลยว่ามันเป็นแบบแผนการโทรที่กำหนดเองอยู่แล้ว

การถอดแบบ 32 บิต :

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 บิต ( ลองออนไลน์! ):

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    

ที่เกี่ยวข้อง: โพลีกลอต x86-32 / x86-64ของฉัน- รหัส Q&A บนดังนั้น

ความแตกต่างระหว่าง 16 บิตและ 32/64 ก็คือโหมดการกำหนดแอดเดรสจะถูกเข้ารหัสแตกต่างกัน เช่นlea eax, [rax+2]( 8D 40 02) ถอดรหัสเช่นเดียวกับlea ax, [bx+si+0x2]ในโหมด 16 บิต นี้คือการใช้รหัสกอล์ฟยากอย่างเห็นได้ชัดโดยเฉพาะอย่างยิ่งตั้งแต่e/rbxและe/rsiถูกสงวนไว้ในการประชุมทางโทรศัพท์หลายครั้ง

ฉันยังพิจารณาใช้ 10 ไบต์mov r64, imm64ซึ่งเป็น REX mov r32,imm32+ แต่เนื่องจากฉันมีวิธีแก้ปัญหา 11 ไบต์อยู่แล้วนี่จึงเป็นวิธีที่ดีที่สุดเท่ากับ (10 ไบต์ +1 สำหรับret)

ทดสอบรหัสสำหรับโหมด 32 และ 64 บิต (ฉันไม่ได้ดำเนินการจริงในโหมด 16 บิต แต่การถอดแยกชิ้นส่วนจะบอกคุณว่ามันจะถอดรหัสอย่างไรฉันไม่ได้ติดตั้งตัวจำลอง 16 บิต)

; 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

โปรแกรมลินุกซ์นี้มีออกทางออกสถานะ = เพื่อเรียกใช้เป็นmodedetect() ./a.out; echo $?รวบรวมและเชื่อมโยงมันเข้ากับไบนารีคงที่เช่น

$ 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 ไบต์ (คะแนน = 2.33) ถ้าฉันสามารถหมายเลขรุ่น 1, 2, 3

ไม่มีหมายเลขรุ่นเป็นทางการสำหรับโหมด x86 ที่แตกต่างกัน ฉันชอบเขียนคำตอบ asm ฉันคิดว่ามันจะเป็นการละเมิดเจตนาของคำถามถ้าฉันเพิ่งเรียกโหมด 1,2,3 หรือ 0,1,2 เพราะประเด็นคือการบังคับให้คุณสร้างหมายเลขที่ไม่สะดวก แต่ถ้าได้รับอนุญาต:

 # 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

ซึ่งถอดรหัสในโหมด 32 บิตเป็น

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

และ 64 บิตเป็น

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

ลองออนไลน์!(Brachylog)

ลองออนไลน์!(Brachylog v1)

คำอธิบายสำหรับ 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)

คำอธิบายสำหรับ 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 ไบต์, 2 รุ่น, คะแนน = 12.5

#include <stdio.h>

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

// ความคิดเห็นสไตล์ไม่เป็นที่รู้จักใน C89

รุ่น Golfed:

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

ลองใช้งานออนไลน์: C89 , C99

Perl 5 และ Perl 6, 23 ไบต์ 19 ไบต์, คะแนน 9.5

print 6-grep '.',''

Perl 5 grepop แรกจะถือว่าเป็น regex ไม่ใช่ใน Perl 6

Bash ทั้งหมด 4 เวอร์ชัน72 71 32 ไบต์⇒คะแนน = 8

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

โค้ดส่วนนี้ใช้การตีความ$'...'สตริงที่แตกต่างกันใน Bash แต่ละเวอร์ชัน
ส่งออกหมายเลขรุ่นหลัก - และนั่นคือ

หมอพบที่นี่

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

คำตอบนี้เป็นการเดาครึ่ง ฉันทดสอบเฉพาะใน bash 4 และ 3 เท่านั้น แต่ควรใช้กับเวอร์ชันอื่นด้วย

แจ้งให้เราทราบหากมัน / ไม่ฉันจะลองกับรุ่นอื่น ๆ ทันทีที่ฉันมีให้

-1 ถ่านขอบคุณเจนส์
-29 ไบต์ขอบคุณ Digital Trauma ( exprความคิดทั้งหมด)!

R, รุ่น 2 และ 3, คะแนน: 10.5 คะแนน

cat(exists("cite")+2)

คำสั่งนี้ส่งคืน2สำหรับ R 2.xx และ3R 3.xx ฟังก์ชันciteถูกเพิ่มใน R เวอร์ชัน 3.0.0 ดังนั้นคำสั่งexists("cite")จะส่งคืนค่าFALSER 2.xx และTRUER 3.xx

R ทุกรุ่น (1, 2 และ 3) คะแนน: 12⅓คะแนน

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

ฟังก์ชั่นeapplyนี้ได้รับการแนะนำใน R 2.0.0

Python , 196 bytes / 16 version = คะแนน 12.25

รุ่นต่าง ๆ คือ 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 และ 3.6
แต่น่าเสียดายที่ฉันต้องปล่อย 2.7 เพราะไม่มีโมดูลใน มัน (เท่าที่ฉันสามารถบอกได้) ที่ไม่ได้อยู่ใน 2.6 แต่เป็น 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.)

เราวนลูปผ่านโมดูลจำนวนมากซึ่งถูกนำมาใช้ในเวอร์ชันที่แตกต่างกันของไพ ธ อนและที่ข้อผิดพลาดครั้งแรกที่เราออกและส่งคืนเวอร์ชัน osช่องว่างระหว่างรุ่นใหญ่ที่เต็มไปด้วยซ้ำในการนำเข้า การทดสอบของ python 1.5 ขึ้นอยู่กับstring.splitไม่มีอยู่จนถึง 1.6

ให้เครดิตกับคำตอบของ Olivier Grégoireสำหรับแนวคิดในการทดสอบคลาส / โมดูลใหม่ในลูป

ในที่สุดฉันก็ได้ทำการทดสอบกับไพ ธ อนทุกรุ่นที่เกี่ยวข้อง ... ซึ่งจำเป็นต้องแก้ไขซอร์สโค้ด 1.5 เพื่อให้คอมไพล์ ...

ไฟล์แบตช์ของ Windows , 35 ไบต์ / 2 เวอร์ชั่น = คะแนน 17.5

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

พิมพ์DOSบน MS-DOS ^(duh)และNTบน Windows NT^(duh)

ตอนนี้สำหรับคำอธิบายบางอย่าง

Windows มีการเขียนสคริปต์เป็นชุดตั้งแต่ MS-DOS ครั้งและมันก็ไม่ได้เปลี่ยนแปลงอะไรมากมายตั้งแต่นั้นมา แต่เมื่อWindows NTมาพร้อมไมโครซอฟท์เปลี่ยนล่ามเริ่มต้นสำหรับสคริปต์ชุดจากCOMMAND.COMไปcmd.exe(ตอนนี้ยังช่วยให้การขยาย.cmdเป็นทางเลือกที่เดิม.bat)

ด้วยสิ่งเหล่านี้พวกเขายังดำเนินการเปลี่ยนแปลงเล็กน้อยเช่นการ/iตั้งค่าสถานะเพื่อละเว้นตัวพิมพ์สตริงตามเงื่อนไข นั่นคือในขณะที่Z==zเป็นเท็จ/i Z==zก็เป็นจริง

เราใช้ประโยชน์จากที่ DOS ไม่ได้มีกรณี insensitivy และเปรียบเทียบตัวพิมพ์ใหญ่กับพิมพ์เล็กZ zโดยการใช้การ/iตั้งค่าสถานะเราท้ายด้วยZ==zเงื่อนไข (เท็จ) บน DOS และz==z (จริง) ใน NT

ตอนนี้ฉันรู้ว่าความท้าทายระบุว่าควรจะพิมพ์หมายเลขเวอร์ชัน แต่เท่าที่ฉันรู้ไม่มี 'หมายเลขรุ่น' สำหรับการเขียนสคริปต์ชุดดังนั้นนี่คือสิ่งที่ใกล้เคียงที่สุดที่ฉันจะได้รับ

ทดสอบบน Windows 10, DOSBox และ vDos:

Windows 10:

(เรียกใช้ด้วยcmd /kเพื่อปิดหน้าต่างก่อนหน้าบนexit)

DOSBox:

VDOs:

ภาษา Wolfram / Mathematica 10/11, 37 ไบต์ / 2 เวอร์ชั่น = 18.5

ลองพิจารณา(Length@DateRange[{1},{1}][[1]]+27)/3ที่ขนาด 37 ไบต์และทำงานกับ 2 เวอร์ชันให้คะแนน 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

และ

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

ฉันแน่ใจว่ามีวิธีที่มีประสิทธิภาพมากขึ้น แต่ความแตกต่างระหว่างผลลัพธ์ DateRange บิตฉันในชนเมื่อเร็ว ๆ นี้ดังนั้นฉันจึงตั้งค่าการใช้ที่

จากการติดตามบางคนอาจใช้ประโยชน์จากLength@DateRange[{1}, {1}][[1]]การประเมิน1ใน Mathematica เวอร์ชัน 1- ~ 8 แต่ฉันไม่มีเวลาที่จะรวมสิ่งนั้น

Ruby 1.x และ 2.x, 20 bytes, คะแนน 10

p [].to_h&&2rescue 1

ขึ้นอยู่กับto_hวิธีการที่ได้รับการแนะนำในArrayชั้นเรียนใน Ruby 2

Erlang, 180 ไบต์, 11 เวอร์ชัน, คะแนน 16.36

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)]]).

ด้วยการเยื้องและการขึ้นบรรทัดใหม่:

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)]]).

ทดสอบการเปิดตัวเล็กน้อยของรุ่นหลักแต่ละรุ่นตั้งแต่ 10:

• R10B-9
• R11B-5
• R12B-5
• R13B04
• R14B04
• R15B03
• R16B03
• 17.5.6.2
• 18.2.1
• 19.2
• 20.0

แนวคิดก็คือว่าทุกรุ่นใหญ่ได้เพิ่มอาร์กิวเมนต์ใหม่ที่อนุญาตอย่างน้อยหนึ่งรายการสำหรับฟังก์ชันerlang:system_infoดังนั้นให้ลองรายการในรายการนับจำนวนที่ล้มเหลวและลบจำนวนความล้มเหลวจาก 20 ซึ่งเป็นรุ่นปัจจุบัน

Julia 0.4, 0.5, 46 ไบต์, คะแนน 22

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

จูเลียได้เปลี่ยนชื่อประเภทของคอนกรีตและประเภทสตริงนามธรรมในหลายรุ่น

รหัสนี้ใช้ประโยชน์จาก:

จูเลีย 0.4 :

• คอนกรีตASCIIString,
• บทคัดย่ออย่างเป็นทางการAbstractString,
• บทคัดย่อได้เลิกใช้ชื่อแทนไปStringแล้ว
• คอนกรีตนั้นมีความเฉพาะเจาะจงกว่านามธรรมดังนั้นมันจึงเป็นผู้ชนะ

จูเลีย 0.5 :

• คอนกรีตอย่างเป็นทางการString,
• คอนกรีตได้เลิกใช้ชื่อแทนASCIIString,
• บทคัดย่อคือAbstractString(ถึงแม้ว่ามันจะไม่สำคัญก็ตาม)
• เนื่องจากมีการกำหนดสองวิธีสำหรับชนิดสตริงที่เป็นรูปธรรมวิธีหลังจะเขียนทับแบบเดิม

ดูโซลูชันที่มีประสิทธิภาพมากกว่าของฉันโดยยึดตามหลักการที่แตกต่าง

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

'1r\S2

ทดสอบ v1  |   ทดสอบ v2

• บันทึก 2 ไบต์ขอบคุณOliver

คำอธิบาย

ก่อนหน้า v2 Japt ใช้ไวยากรณ์ RegEx ที่กำหนดเองดังนั้นเราจึงสามารถใช้ประโยชน์จากสิ่งนั้นได้

'1

หมายเลข 1 เป็นสตริง

 r  2

แทนที่ ( r) 2ด้านล่างด้วย

\S

Japt 2 เห็นว่านี่เป็น RegEx ซึ่งตรงกับ/\S/g 1Japt 1 ละเว้น\ตัวหนีและเพียงแค่เห็นSซึ่งเป็นค่าคงที่ Japt 1สำหรับตัวละครของพื้นที่และเห็นได้ชัดว่าไม่ตรงกับ

Befunge คะแนน = 3.5

7 ไบต์, 2 รุ่น

"]"'b.@

ลองใช้งานออนไลน์ได้ที่ Befunge-93
ลองออนไลน์ได้ที่ Befunge-98

"]"เป็นสตริงตัวอักษรในทั้งสองเวอร์ชันผลัก 93 (ค่า ASCII ของ[) ไปยังสแต็ก 'bเป็นตัวอักษรตัวละครใน Befunge-98, ผลักดัน 98 (ค่า ASCII ของb) แต่พวกเขาเป็นคำแนะนำที่ไม่ถูกต้องใน Befunge-93 ดังนั้นพวกเขาจะถูกละเว้นเพียง เราจึงลงท้ายด้วย 93 ที่ด้านบนสุดของสแต็คใน Befunge-93 และ 98 ใน Befunge-98 .@เขียนค่าที่ด้านบนของสแต็กแล้วออก

ทับทิม 1.x (<1.9) และ 2.x, 10 8 ไบต์, คะแนน = 4

$><<?2%7

ลองมัน:

• ทับทิม 1.8.7
• ทับทิม 2.0.0

สิ่งนี้ทำงานโดยใช้ประโยชน์จากพฤติกรรมที่แตกต่างกันของ ?xระหว่าง Ruby 1.x และ 2.x ในทับทิม 1.x, ?A(ตัวอย่าง) ผลตอบแทน65(ค่า ASCII ของตัวละครA) แต่ในรูบี 2.0 "A"ก็จะส่งกลับสตริงหนึ่งตัวอักษร

รหัสข้างต้นเทียบเท่ากับสิ่งนี้:

val = ?2
$> << val % 7

ใน Ruby 1.x (<1.9) ค่าของvalคือ50 (ค่า ASCII ของตัวละคร2), Fixnum Fixnum#%เป็นผู้ดำเนินการแบบโมดูโลเพื่อให้ผลตอบแทน50 % 71

ในทับทิม 2.x, เป็นสตริงval เป็นรุ่นของ infix ดังนั้น"2"String#%sprintf"2" % 7เทียบเท่ากับsprintf("2", 7)โดยที่"2"สตริงรูปแบบอยู่ที่ไหน เนื่องจากสตริงรูปแบบไม่มีรูปแบบลำดับใด ๆ (เช่น%d) อาร์กิวเมนต์ที่ตามมาจึงถูกยกเลิกและ"2"ถูกส่งคืน

ในที่สุด$>เป็นนามแฝง$stdoutเพื่อ$> << ...พิมพ์ผลลัพธ์

Python 2และPython 3 , 36 34 bytes, คะแนน18 17

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

ในPython 2แฮชของอินฟินิตี้ลบคือ -271828 แต่ในPython 3นั่นคือ -314159 แก้ไข: บันทึก 2 ไบต์, 1 คะแนนคะแนน, ขอบคุณ @ArBo

Python 3 , Python 2 , คะแนน 17.5

(35 ไบต์ 2 เวอร์ชัน)

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

Python 2 , 35 ไบต์

ลองออนไลน์!

Python 3 , 35 ไบต์

ลองออนไลน์!

บันทึก 5 ไบต์ด้วย ETHproductions

ไม่ใช่คำตอบที่ดีสำหรับนักกอล์ฟ แต่เป็นการเปลี่ยนแปลงครั้งใหญ่!