आपकी चुनौती एक बहुभाषाविद लिखना है जो आपकी भाषा के विभिन्न संस्करणों में काम करता है। जब चलाया जाता है, तो यह हमेशा भाषा संस्करण का उत्पादन करेगा।

नियम

आपके कार्यक्रम को आपकी भाषा के कम से कम दो संस्करणों में काम करना चाहिए।
आपके प्रोग्राम का आउटपुट केवल संस्करण संख्या होना चाहिए । कोई बाहरी डेटा नहीं।
आपका प्रोग्राम संस्करण संख्या निर्धारित करने के लिए आपको जो भी विधि पसंद है, उसका उपयोग कर सकता है। हालाँकि, आउटपुट को नियम 2 का पालन करना चाहिए; हालाँकि आप संस्करण संख्या निर्धारित करते हैं, लेकिन आउटपुट केवल संख्या होना चाहिए।
आपके कार्यक्रम को केवल भाषा के प्रमुख संस्करण का उत्पादन करने की आवश्यकता है। उदाहरण के लिए, फूबर 12.3.456789-बीटा में, आपके प्रोग्राम को केवल 12 आउटपुट करने की आवश्यकता होगी।
यदि आपकी भाषा संस्करण संख्या से पहले या बाद में शब्द या प्रतीक रखती है, तो आपको उन और केवल संख्या के आउटपुट की आवश्यकता नहीं है। उदाहरण के लिए, C89 में, आपके प्रोग्राम को केवल प्रिंट करने की आवश्यकता है 89, और C ++ 0x में, आपके प्रोग्राम को केवल प्रिंट करने की आवश्यकता है 0।
यदि आप पूर्ण नाम या लघु संस्करण संख्याएँ मुद्रित करना चुनते हैं, जैसे C89 C99 के विपरीत, तो इसे केवल नाम प्रिंट करना होगा । C89 build 32मान्य है, जबकि error in C89 build 32: foo barनहीं है।
भाषा संस्करण को निर्धारित करने के लिए आपका प्रोग्राम बिल्ट, मैक्रो या कस्टम कंपाइलर झंडे का उपयोग नहीं कर सकता है।

स्कोरिंग

आपका स्कोर उन संस्करणों की संख्या से विभाजित किया जाएगा जो इसमें काम करने वाले संस्करणों की संख्या से विभाजित हैं। सबसे कम स्कोर जीतता है, अच्छी किस्मत!

code-golf code-challenge polyglot

— एमडी एक्सएफ
स्रोत

4

भाषा संस्करण संख्या क्या है? इसे कौन निर्धारित करता है?

— गेहूं जादूगर

9

मुझे लगता है कि संस्करण की संख्या में उलटा-रैखिक उच्च संख्या वाले संस्करणों के साथ उत्तर का स्वागत नहीं करता है।

— user202729

6

@ user202729 मैं सहमत हूं। वर्सटाइल इंटेगर प्रिंटर ने अच्छा प्रदर्शन किया (number of languages)^3 / (byte count)।

— Mego

6

किसी भाषा के लिए संस्करण क्या है ? क्या हम किसी भाषा को उसके व्याख्याताओं / संकलक के रूप में परिभाषित नहीं कर रहे हैं? हम कहते हैं, gcc का एक संस्करण है, जिसमें एक बग है जो कुछ C89 कोड के साथ एक निष्पादन योग्य उत्पादन करता है जो व्यवहार C89 विनिर्देश का उल्लंघन करता है, और यह gcc के अगले संस्करण पर तय किया गया था। यदि हम इस बग व्यवहार पर कोड बेस का एक टुकड़ा लिखते हैं, तो यह बताने के लिए कि क्या gcc संस्करण का उपयोग किया जा रहा है, इसे एक वैध समाधान गिना जाना चाहिए? यह संकलक के विभिन्न संस्करण को लक्षित करता है , लेकिन भाषा के विभिन्न संस्करण को नहीं ।

— tsh

6

मुझे यह नहीं मिलता। पहले आप कहते हैं "आपके प्रोग्राम का आउटपुट केवल संस्करण संख्या होना चाहिए।" । फिर आप कहते हैं "यदि आप पूर्ण नाम या लघु संस्करण संख्याएँ मुद्रित करना चाहते हैं, जैसे C89 C99 के विपरीत, तो यह केवल नाम मुद्रित करना चाहिए।" तो पहला नियम वास्तव में एक आवश्यकता नहीं है?

— पाइप

16

गंभीरता से और वास्तव में , 3 बाइट्स, स्कोर 1.5

'1u

इसे ऑनलाइन आज़माएं: वास्तव में , गंभीरता से

स्पष्टीकरण:

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

uऔर Dस्ट्रिंग्स पर कार्यक्षमता होना केवल वास्तव में जोड़ा गया था (जो गंभीरता से v2 है)।

— मेगो
स्रोत

3

दरअसल README.md का कहना है कि वास्तव में सीरियसली आध्यात्मिक उत्तराधिकारी है। मेरे लिए एक मात्र संस्करण परिवर्तन की तरह ध्वनि नहीं है।

— अदम

7

@ Adám यदि आप भंडार में शाखाओं को देखते हैं, तो गंभीरता से v1शाखा में रहते हैं । गंभीर रूप से अपदस्थ होने से पहले, वास्तव में v2शाखा में रहते थे । इसके अतिरिक्त, गंभीर रूप से रिलीज़1.x में संस्करण संख्याओं का उपयोग किया जाता है , जबकि वास्तव में (वहां और PyPI पर ) दोनों का उपयोग होता है । 2.x

— मेगो

115

पायथन 3.0 और पायथन 2, स्कोर 6

(12 बाइट्स, 2 संस्करण)

print(3/2*2)

इसे ऑनलाइन आज़माएँ:

इस तथ्य पर निर्भर करता है कि पायथन 3+ पाइथन 2 के विपरीत, डिफ़ॉल्ट रूप से फ्लोट डिवीजन का उपयोग करता है, जो फ्लोर डिवीजन का उपयोग करता है।

— fireflame241
स्रोत

@MaltySen Your program should work in at least two versions of your language.यह कम से कम-दो संस्करणों 2.7 और 3.0 में काम करता है। मैंने चुना to print the full name or minor version numbers।

— फायरफ्लेम 241

ओह, मैं देख रहा हूँ, मेरा बुरा।

— माल्टीसेन

4

हे भगवान! गरीब अजगर डेवलपर्स

— रेजिस पोर्टेलेज़

4

@RegisPortalez from __future__ import division, समस्या हल :)

— Rogalski

62

जावा, 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;}}

इसे जावा 8 पर
चलाएं इसे जावा 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;) को जावा 1.0 और जावा 1.3 के बीच किसी भी संस्करण के खिलाफ जांचने की आवश्यकता है। मेरे पास वास्तव में इस सिंटैक्स का परीक्षण करने के लिए मेरे निपटान में कोई जावा 1.3 या पहले की स्थापना नहीं है।

परिचय

जावा संस्करण में एक विशेष इतिहास है। सभी संस्करणों को ऐतिहासिक रूप से 1.xशामिल किया गया है 1.0। लेकिन ... जावा 9 पर और JEP223 से , वर्जन स्कीमिंग का उपयोग 1.xकरने से बदल गया है x। वह संस्करण है जिसे आंतरिक रूप से जाना जाता है। तो हमारे पास निम्न तालिका है (जावदोक और विकिपीडिया के साथ मिलकर ):

 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"।

व्याख्या

लक्ष्य यह जांचना है कि जावा किस संस्करण से अस्तित्व में है, क्योंकि जावा कोड को हटाता है लेकिन इसे कभी नहीं हटाता है। कोड को विशेष रूप से जावा 1.0 में सभी संस्करणों के साथ संगत होने के लिए फिर से लिखा गया है, क्योंकि JDK (ज्यादातर) स्रोत संगत है ।

कार्यान्वयन सबसे छोटे वर्ग के नामों को खोजने की कोशिश करता है जो प्रत्येक संस्करण को पेश करता है। हालांकि, बाइट्स हासिल करने के लिए, एक सामान्य उप-पैकेज की कोशिश करना और लेना आवश्यक है। अब तक मुझे सबसे कुशल पैकेज मिला, java.utilक्योंकि इसमें जावा के सभी संस्करणों में फैले कई वास्तव में अल्प-नामित वर्ग शामिल हैं।

अब, वास्तविक संस्करण संख्या को खोजने के लिए, वर्ग नाम को संस्करण की शुरुआत करके क्रमबद्ध किया जाता है। फिर मैं क्रम से प्रत्येक वर्ग को क्रमबद्ध करने की कोशिश करता हूं, और सरणी सूचकांक में वृद्धि करता हूं। यदि वर्ग मौजूद है, तो हम अगले पर जाते हैं, अन्यथा हम अपवाद को try-ब्लॉक द्वारा पकड़े जाने देते हैं। जब किया जाता है, तो एक और अपवाद फेंक दिया जाता है क्योंकि कोई और वर्ग नहीं हैं जिनके अस्तित्व की हमें जांच करने की आवश्यकता है।

किसी भी स्थिति में, थ्रेड tryअपवाद के साथ छोड़ देगा । यही कारण है कि अपवाद पकड़ा नहीं है, लेकिन बस को पकड़ धन्यवाद पर डाल finally-block, जो बारी में वास्तव में एक मूल्य है जो वापस लौट कर ऑन-पकड़ अपवाद को ओवरराइड करता है "1."+vजहां vसे पहले इस्तेमाल सूचकांक है। यह भी होता है कि हमने इस इंडेक्स को जावा के लघु संस्करण की संख्या से मिला दिया।

गोल्फ का एक महत्वपूर्ण हिस्सा 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 बाइट्स ने केविन क्रूज़सेन के लिए धन्यवाद बचाया (हालांकि मैं उनकी टिप्पणी पढ़ने से पहले यह कर रहा था, मैं वादा करता हूँ!)।
26 आगे बाइट्स ने नील को धन्यवाद दिया (नहीं, मैं ऐसा करने के बारे में नहीं सोच रहा था)
12 बाइट्स नेवय और अच्छे आउट-ऑफ-द- ~~बॉक्स~~ -थ्री-थिंक सोच के लिए धन्यवाद !
नील द्वारा 11 और बाइट्स फिर से और अच्छी पोर्टेबल finallyचाल।
केविन क्रुजसेन के return(i<9?"1.":"")+i;साथ 2 बाइट्स की जगह के लिए धन्यवाद return i<9?"1."+i:i;(यह 1.0 के खिलाफ या सबसे अधिक 1.3 के लिए मान्य होने की आवश्यकता है क्योंकि कोई सिंटैक्स परिवर्तन 1.4 से पहले नहीं हुआ)

बिल्डिंस के साथ

यदि निर्माण की अनुमति थी:

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

13 संस्करणों के लिए 54 बाइट्स (1.0 से 12 तक), इसलिए स्कोर 4.1538 होगा।

— ओलिवियर ग्रेजायर
स्रोत

1

@KevinCruijssen मैंने 1 से 1 नाम से javadoc और कक्षाएं चलायीं। लेकिन ... मुझे इस पृष्ठ से थोड़ी मदद मिली: docs.oracle.com/javase/8/docs/technotes/guides/lang/…

— ओलिवियर Grégoire

1

260 बाइट्स या शायद 1 और, return"...सभी संस्करणों tbh में स्थान के बिना संभव नहीं है, पता नहीं ।)

— केविन क्रूज़सेन

1

235 बाइट्स:

String v(){return "1."+(e("time.Year")+e("nio.file.Path")+e("io.Console")+e("util.UUID")+e("text.Bidi")+e("util.Timer")+e("sql.Ref")+e("lang.Void"));}int e(String c){try{Class.forName("java."+c);return 1;}catch(Exception e){return 0;}}

— नील

3

216 बाइट्स:

String v(){int i=0;try{for(String[]s={"lang.Void","sql.Ref","util.Timer","net.URI","util.UUID","net.IDN","nio.file.Path","time.Year","lang.Module"};;i++)Class.forName("java."+s[i]);}catch(Exception e){}return"1."+i;}

— नेवई

1

ओह, मैंने एक सरणी को पुनरावृत्त करने और एक अपवाद को पकड़ने के बारे में आश्चर्य किया था, लेकिन आप एक के साथ बेहतर कर सकते हैं finally{return"1."+i;}।

— नील

22

पायथन , 606 बाइट्स / 15 संस्करण = 40.4 स्कोर

-67 बाइट्स (योग्य) 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.4, 3.5 aaand 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 के अद्भुत जवाब के लिए सभी क्रेडिट । अनुगामी न्यूलाइन आवश्यक है।

व्ही, कि गोल्फ के लिए मजेदार था। यह काम करना चाहिए (हाँ, मैंने इनमें से हर एक संस्करण को स्थापित किया है), लेकिन मैं गलती से किसी चीज को काट सकता हूं। अगर किसी को कोई बग मिले तो कृपया मुझे बताएं।

— totallyhuman
स्रोत

print'0.9.1'अमान्य सिंटैक्स होने के कारण पायथन 3 (TIO पर कम से कम) पर नहीं चलता है ।

— पुरकाकूदरी

... ओह, कोई आश्चर्य नहीं। मैं सोच रहा था कि Sp3000 ने हर printकॉल में कोष्ठक क्यों रखा है ... मुझे बताने के लिए धन्यवाद!

— 14 अक्टूबर को पूरी तरह से अमानवीय

2

आप विशिष्ट प्रकार की त्रुटियों को हटाकर 68 बाइट्स बचा सकते हैं (सभी excepts को बदलें except:)।

— NoOneIsHere

क्या यह अभी भी काम करेगा यदि आपने x=<string inside eval>कोड को मैन्युअल रूप से निकालने के बजाय किया ?

— ब्लू

@NoOneIsHere मैंने सोचा, पहले, कि आप सभी के कारण नहीं कर सके 1/0, लेकिन तब मुझे एहसास हुआ। धन्यवाद!

— 15:38 पर पूरी तरह से अमानवीय

21

C ++ 11/14/17, स्कोर = 147/3 = 49

C ++ 11 और C ++ 14/17 के बीच अंतर करने के लिए, यह C ++ 14 में सदस्य कार्यों के डिफ़ॉल्ट constनेस में परिवर्तन का उपयोग करता है constexpr(उदाहरण के लिए https://stackoverflow.com/questions/23980929/ पर क्रेडिट के साथ) क्या-परिवर्तन-शुरू-सी-14-कैन-संभावित-ब्रेक-ए-प्रोग्राम-लिखित-सी -1 )। C ++ 14 और C ++ 17 के बीच अंतर करने के लिए, यह इस तथ्य का उपयोग करता है कि C ++ 17 अक्षम ट्रिग्राफ।

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

(डेबियन जीसीसी 7.1.0 का उपयोग करके परीक्षण किया गया -std=c++{11,14,17}।)

— डैनियल शेपलर
स्रोत

1

शानदार पहला जवाब! ध्यान दें कि आप गोल्फ कर सकते हैं कि के बीच रिक्त स्थान includeऔर <शामिल बयानों में, उदाहरण के लिए #include<iostream>।

— एमडी एक्सएफ

1

हम्म ... अगर नियमों को मानक पुस्तकालय मतभेदों का उपयोग करने से मना करने के लिए संशोधित किया गया था (जो इस मामले में अप्रत्यक्ष रूप से __cplusplusमैक्रो का उपयोग करता है ) - तो सी ++ 14 से सी ++ 14 को भेद करने के लिए मैं रेंज-आधारित परिवर्तन का उपयोग करने की ओर झुकूंगा। शब्दार्थ के लिए। हो सकता है boost::integer_iteratorकि इस तरह की तर्ज पर न्यूनतम इट्रेटर / सेंटिनल कक्षाएं बनाएं जो प्रहरी को पुनरावृत्त में परिवर्तित कर "आश्चर्यजनक" व्यवहार करते हैं।

— डैनियल शेपलर

4

return 0;इसके लिए निहित है mainताकि आप वहां 9 बाइट्स बचा सकें। इसके अलावा wc -cआपके समाधान के अनुसार 251 बाइट्स का उपयोग किया जा रहा है और 252 का उपयोग नहीं किया गया है (आपके संपादक ने अंत में एक नई पंक्ति डाली हो सकती है)।

— nwp

1

संभवतः c ++ 17 को c ++ 14 से अलग करने के लिए ट्रिग्राफ की कमी का उपयोग करना कम है

— Potato44

1

क्या यह काम करेगा? return *=>return*

— ज़ाचारि

19

EcmaScript 3/5/2015/2016/2017 ब्राउज़र में, 59 बाइट्स / 5 संस्करण = 11.8 अंक

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

स्निपेट का विस्तार करें

गोटो 0 के लिए 1 बाइट धन्यवाद सहेजें

— TSH
स्रोत

1

नौनिहाल ! ;)

— झबरा

नेटस्केप 7 ने केवल ES3 का समर्थन किया है? वाह, यह मेरे विचार से पुराना है ...

— नील

1

आप -!इसके बजाय कुछ बाइट्स बचा सकते हैं +!!जहां यह समझ में आता है (और तदनुसार संख्यात्मक स्थिरांक को बदल दें)।

— गोटो 0

3

शायद कुछ स्पष्टीकरण? :)

— डेरेक 會會 D

@ डेरेक: स्पष्टीकरण के लिए मेरा समाधान (ऊपर लिंक) देखें।

— झबरा

18

जावास्क्रिप्ट (ईएस 5 और ईएस 6), 14 बाइट्स / 2 संस्करण = 7

alert(5^"0o3")

0oईएस 6 में -स्टाइल ऑक्टल कॉन्स्टेंट नए हैं; ES5 स्ट्रिंग को काटता है, NaNजो बिटवाइज़ XOR के परिणाम को प्रभावित नहीं करता है।

— नील
स्रोत

13

जावास्क्रिप्ट (ईएस 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 प्रोटोटाइप में विभिन्न तरीकों की उपस्थिति के लिए जाँच करता है, उनकी उपेक्षा करता है, एक बूलियन देता है, और उस बूलियन को 9 के प्रारंभिक मूल्य से घटाता है ![].map। तथ्य यह है कि ES4 को छोड़ दिया गया था।

dotAllसंपत्ति (और संबंधित sझंडा) रेगुलर एक्सप्रेशन के लिए में पेश किया गया था ES2018 (v9)।
padEndस्ट्रिंग विधि में पेश किया गया था ES2017 (V8)।
includesसरणी विधि में पेश किया गया था ES2016 (v7)।
keysसरणी विधि में पेश किया गया था ES2015 (v6)।
mapसरणी विधि में पेश किया गया था ES5.1 (v5)।
popसरणी विधि में पेश किया गया था ES3 (v3)।

— झबरा
स्रोत

ES 7 या ES 8 एक वैध संस्करण संख्या है? शायद इसे ES 201x कहा जाना चाहिए?

— tsh

1

@tsh: हाँ, वे अभी भी संस्करण संख्या का उपयोग करते हैं; वे सिर्फ वर्षों के लिए वास्तविक नामों का उपयोग करते हैं ।

— झबरा

9

PHP 5/7, स्कोर 5.5

<?=7-"0x2";

ऑनलाइन यह 3V4L!

PHP 5.3.9 / 5.3.11, स्कोर 10

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

ऑनलाइन यह 3V4L!

ऑनलाइन संस्करण लंबा है क्योंकि सैंडबॉक्स पर पुराने PHP संस्करणों में छोटे टैग सक्षम नहीं हैं।

— Sisyphus
स्रोत

9

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" प्रिंट करेगा और समाप्त करेगा।

— karhell
स्रोत

"89",;5-;,@11 बाइट्स के लिए

— पुरकाकूदरी

@ Pietu1998 अच्छा लगा! यदि आप एक उत्तर के रूप में पोस्ट करना चाहते हैं, तो मैं ख़ुशी से

— बढ़ जाऊंगा

आगे बढ़ो और अगर तुम चाहो तो ले लो, तुम ;भाग का पता लगा लिया।

— पुरकाकूदरी

@ Pietu1998 में संपादित। बहुत धन्यवाद!

— करहल

FYI करें, मैं इसे 7 बाइट्स तक ले जाने में कामयाब रहा, एक अलग दृष्टिकोण लेकर। लिंक

— जेम्स होल्डरनेस

7

पायथ 4/5 - 6 बाइट्स / 2 संस्करण = 3

  5 ;4

Pyth 5 में, रेखा के शुरू में रिक्त स्थान की एक समान मात्रा को इंडेंट करने में उपयोग के लिए अनदेखा किया जाता है, जबकि Pyth 4 में, यह केवल एक ही स्थान की तरह कार्य करता है और मुद्रण को रोकता है 5। Pyth 4 में, अर्धविराम केवल बयानों को समाप्त करता है, जो 4मुद्रित करने की अनुमति देता है , जबकि Pyth 5 में, एक स्थान और अर्धविराम शेष पंक्ति को टिप्पणी करता है।

— Maltysen
स्रोत

11

कौन जानता था कि पायथ के पास संस्करण थे?

— 13

7

पायथन 3 और पायथन 2.0, 18 बाइट्स, स्कोर 18/2 = 9

print(3-round(.5))

पायथन 3 में बैंकर की गोलाई, पायथन 2 में मानक गोलाई।

इसे ऑनलाइन आज़माएं - पायथन 3!

इसे ऑनलाइन आज़माएं - पायथन 2!

— स्टीफन
स्रोत

वाह, मैंने हमेशा लोगों को अजगर 2 और 3 को विभाजन द्वारा देखा है

— phuclv

@ LưuV LnhPhúc अच्छी तरह से विभाजन गोल्फ खिलाड़ी है, इसलिए यही कारण है कि: पी

— स्टीफन

7

मूल रूप से, 4 बाइट्स, स्कोर 4 / tes

B3%0

हर संस्करण में काम करता है आपके सिस्टम में चलाने के लिए पर्याप्त मेमोरी है। गैर-प्रतिस्पर्धा क्योंकि यह लंगड़ा है। इस मेटा पोस्ट के अनुसार मान्य ।

मूल रूप से, बी 3 बाएं चेहरे से एक पंक्ति को शीर्ष चेहरे में घुमाता है। F3 ठीक वैसे ही काम करेगा, जैसे F would3 या B .3। क्यूबिकली 3x3x3 में एक पंक्ति के रूप में एक क्यूबलेट द्वारा तीन क्यूबलेट्स होते हैं, यह तीन 1चेहरे में शीर्ष पर रखता है, यह 3. फेस योग देता है 3. %0शीर्ष अंकित राशि, जो क्यूबिक 3 x3x3 के लिए 3 प्रिंट करता है।

मूल रूप से 4x4x4 में, पंक्तियाँ 4x1 घन होती हैं। शीर्ष 4 में 4 1 का योग डालता है, 4 की राशि प्राप्त करता है।

— एमडी एक्सएफ
स्रोत

9

स्कोर ४ / 4 नहीं होना चाहिए?

— nwp

7

x86 16/32/64-बिट मशीन कोड: 11 बाइट्स, स्कोर = 3.66

यह फ़ंक्शन AL में पूर्णांक के रूप में वर्तमान मोड (डिफ़ॉल्ट ऑपरेंड-आकार) लौटाता है। हस्ताक्षर के साथ सी से बुलाओuint8_t modedetect(void);

NASM मशीन-कोड + स्रोत लिस्टिंग (यह दिखाता है कि यह 16-बिट मोड में कैसे काम करता है, क्योंकि BITS 16NASM 16-बिट मोड के लिए स्रोत mnemonics को इकट्ठा करने के लिए कहता है।)

 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 CPU, Intel का 8086, केवल 16-बिट मशीन कोड का समर्थन करता है। 80386 ने 32-बिट मशीन कोड (32-बिट संरक्षित मोड में प्रयोग करने योग्य, और बाद में 64-बिट ओएस के तहत कॉम्पिटिटर मोड में पेश किया)। एएमडी ने 64-बिट मशीन कोड पेश किया, जो लंबे मोड में प्रयोग करने योग्य है। ये उसी अर्थ में x86 मशीन भाषा के संस्करण हैं, जो Python2 और Python3 विभिन्न भाषा संस्करण हैं। वे ज्यादातर संगत हैं, लेकिन जानबूझकर परिवर्तन के साथ। आप 64-बिट OS कर्नेल के तहत 32 या 64-बिट निष्पादन योग्य को सीधे चला सकते हैं, ठीक उसी तरह जैसे आप Python2 और Python3 प्रोग्राम चला सकते हैं।

यह काम किस प्रकार करता है:

से शुरू करें al=64। इसे 1 (32-बिट मोड) या 2 (16-बिट मोड) द्वारा दाईं ओर शिफ्ट करें।

16/32 बनाम 64-बिट: 1-बाइट inc/ decएनकोडिंग 64-बिट ( http://wiki.osdev.org/X86-64_Instruction_Encoding#REX_prefix ) में REX उपसर्ग हैं । REX.W कुछ निर्देशों को प्रभावित नहीं करता है (जैसे a jmpया jcc), लेकिन इस मामले में 16/32/64 प्राप्त करने के लिए मैं ecxइसके बजाय inc या dec चाहता था eax। वह भी सेट करता है REX.B, जो गंतव्य रजिस्टर को बदलता है। लेकिन सौभाग्य से हम वह काम कर सकते हैं लेकिन 64-बिट की चीजों को सेट करना शिफ्ट करने की जरूरत नहीं है al।

केवल 16-बिट मोड में चलने वाले अनुदेश में एक शामिल हो सकता है ret, लेकिन मुझे वह आवश्यक या सहायक नहीं मिला। (और यदि आप ऐसा करना चाहते हैं, तो कोड-खंड के रूप में इनलाइन को असंभव बनाना संभव होगा)। यह jmpफ़ंक्शन के भीतर भी हो सकता है ।
16-बिट बनाम 32/64: तुरंत 32-बिट के बजाय 16-बिट हैं। बदलते मोड एक निर्देश की लंबाई को बदल सकते हैं, इसलिए 32/64 बिट मोड एक अलग निर्देश के बजाय तत्काल के भाग के रूप में अगले दो बाइट्स को डिकोड करते हैं। मैंने यहां 2-बाइट अनुदेश का उपयोग करके चीजों को सरल रखा, सिंक के बाहर डिकोड होने के बजाय 16-बिट मोड 32/64 की तुलना में अलग-अलग निर्देश सीमाओं से डिकोड हो जाएगा।

संबंधित: ऑपरेंड-आकार का उपसर्ग तत्काल की लंबाई बदलता है (जब तक कि यह एक संकेत-विस्तारित 8-बिट तत्काल नहीं है), ठीक 16-बिट और 32/64-बिट मोड के बीच के अंतर की तरह। यह निर्देश-लंबाई डिकोडिंग को समानांतर में करना मुश्किल बनाता है; इंटेल CPU में LCP डिकोडिंग स्टॉल हैं ।

अधिकांश कॉलिंग कन्वेंशन (x86-32 और x86-64 सिस्टम V psABI सहित) संकीर्ण वापसी मानों को रजिस्टर के उच्च बिट्स में कचरा रखने की अनुमति देते हैं। वे clobbering CX / ECX / RCX (और 64-बिट के लिए R8) की भी अनुमति देते हैं। आईडीके अगर वह 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

६४-बिट डिस्सेक्शन ( यह ऑनलाइन प्रयास करें! ):

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 पर SO।

16-बिट और 32/64 के बीच एक और अंतर यह है कि एड्रेसिंग मोड अलग-अलग तरीके से एन्कोड किए जाते हैं। जैसे lea eax, [rax+2]( 8D 40 02) lea ax, [bx+si+0x2]16-बिट मोड में डिकोड होता है। यह स्पष्ट रूप से कोड-गोल्फ के लिए उपयोग करना मुश्किल है, खासकर तब से e/rbxऔर e/rsiकई कॉलिंग सम्मेलनों में कॉल-संरक्षित हैं।

मैंने 10-बाइट का उपयोग करने पर भी विचार किया mov r64, imm64, जो आरईएक्स + है mov r32,imm32। लेकिन जब से मेरे पास पहले से ही 11 बाइट समाधान था, यह सबसे अच्छा बराबर (10 बाइट्स + 1 के लिए ret) होगा।

32 और 64-बिट मोड के लिए टेस्ट कोड। (मैंने वास्तव में इसे 16-बिट मोड में निष्पादित नहीं किया है, लेकिन disassembly आपको बताता है कि यह कैसे डिकोड होगा। मेरे पास 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

— पीटर कॉर्डेस
स्रोत

मुझे यकीन नहीं है कि ये अलग-अलग संस्करण हैं । क्या वे सिर्फ अलग-अलग सिस्टम कॉन्फ़िगरेशन से संबंधित नहीं हैं।

— उरईल

1

@ यूरील: 16-बिट मोड, 32-बिट मोड या 64-बिट मोड में सीपीयू के साथ मशीन कोड का एक ब्लॉक चलाना एक ही पायथन प्रोग्राम पर python2बनाम python3दुभाषियों को चलाने के बराबर मशीन-कोड है । नई x86 सीपीयू में हमेशा पुराने सीपीयू के साथ संगत एक मोड शामिल होता है (यह इस तरह के एक कठिन हार्ड-टू-डिकोड मशीन-कोड प्रारूप का उपयोग करने के लिए उनका एकमात्र बहाना है!), लेकिन 386 का 32-बिट संरक्षित मोड और x86-64 का लंबा मोड वास्तव में हैं! x86 मशीन कोड के नए संस्करण। लॉन्ग मोड ने कुछ ऑपकोड को हटा दिया, जिससे वे अमान्य हो गए।

— पीटर कॉर्डेस

5

Brachylog / Brachylog v1 , 5/2 = 2.5

2,1hw

इसे ऑनलाइन आज़माएं! (Brachylog)

इसे ऑनलाइन आज़माएं! (ब्रेकीलॉग v1)

ब्रेजलॉग के लिए स्पष्टीकरण:

?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)

— आउटगोल्फर को एरिक करें
स्रोत

महान! Sidenote के रूप में, 2,1Brachylog v2 में सूची [2,1](है 2;1) का निर्माण नहीं करता है , बल्कि संख्या 21(जो आपके काम करने के लिए आपके उत्तर के तरीके को नहीं बदलती है)।

— घातक

@ फेटीज ऊह धन्यवाद मैंने भ्रमित किया कि जेली के साथ ...

— एरिक आउटगॉल्फ

@Fatalize BTW 2;1ने Brachylog v1 में काम नहीं किया होगा जैसा ;कि तार्किक या वहाँ है।

— एरिक आउटगॉल्फ

5

C89 / C99, 25 बाइट्स, 2 संस्करण, स्कोर = 12.5

#include <stdio.h>

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

// शैली टिप्पणियाँ C89 में मान्यता प्राप्त नहीं हैं।

गोल्फ संस्करण:

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

इसे ऑनलाइन आज़माएं: C89 , C99

— nwellnhof
स्रोत

के int v()साथ बदलें main(), यह छोटा है और वास्तव में एक संपूर्ण कार्यक्रम के रूप में संकलित करेगा!

— एंड्रिया

@ और धन्यवाद। AFAIK, इसे या तो फ़ंक्शन या पूरे कार्यक्रम पोस्ट करने की अनुमति है।

— nwellnhof

तुम सही हो।

— एंड्रिया

5

पर्ल 5 और पर्ल 6, 23 बाइट्स 19 बाइट्स, स्कोर 9.5

print 6-grep '.',''

पर्ल 5 grepपहली ऑप को हमेशा रेगेक्स के रूप में माना जाता है, पर्ल 6 में ऐसा नहीं है।

— यहोशू
स्रोत

स्कोर

— 19/2

5

बैश, सभी 4 संस्करण, 72 71 32 बाइट्स ⇒ स्कोर = 8

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

कोड का यह टुकड़ा $'...'बैश के प्रत्येक संस्करण में तार की विभिन्न व्याख्याओं का उपयोग करता है ।
प्रमुख संस्करण संख्या को आउटपुट करता है - और यह बात है।

यहां डॉक्टर मिले ।

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

यह उत्तर आधा अनुमान है; मैंने इसे केवल बैश 4 और 3 में परीक्षण किया, लेकिन इसे अन्य संस्करणों पर भी काम करना चाहिए।

मुझे पता है कि यह करता है / नहीं करता है, मैं अन्य संस्करणों के साथ कोशिश करूंगा जैसे ही मेरे पास उपलब्ध है।

-1 जेन्स के लिए धन्यवाद।
-29 बाइट्स डिजिटल ट्रॉमा (संपूर्ण exprविचार) के लिए धन्यवाद !

— joH1
स्रोत

शेल व्याकरण ;;को अंतिम विकल्प में एक की आवश्यकता नहीं होती है । ;एक बाइट को शेव करने के लिए उपयोग करें ।

— जेन्स

1

मैंने बस इसे bash-2.05a (साइगविन के लिए अभी संकलित) पर आज़माया है, और यह "3", "2" नहीं, बल्कि गलत तरीके से रिपोर्ट करता है :(

— जेसन मुसग्रोव

1

व्याख्या- $'\xNफ़ीचर 2.01.1 में जोड़ा गया लगता है ... मुझे अपना उत्तर अपडेट करना होगा। इस पर कार्य करना

— joH1

क्या मैं आपसे यह कोशिश करने के लिए कह सकता हूं? s="$'\ua\xa\n'";case ${#s} in 3)echo 4;;5)echo 3;;7)echo 2;;9)echo 1;esac

— joH1

1

आप इसे कुछ इस तरह से कर सकते हैं s=$'\ua\xa\n';expr 5 - ${#s} / 2। यह v3 और v4 पर काम करता है। मेरे पास अभी प्रयास करने के लिए पुराने संस्करण नहीं हैं।

— डिजिटल ट्रामा

4

आर, संस्करण 2 और 3, स्कोर: 10.5 अंक

cat(exists("cite")+2)

यह कमांड 2R 2.xx के लिए और 3R 3.xx के लिए फ़ंक्शन देता है। फ़ंक्शन citeको R संस्करण 3.0.0 में जोड़ा गया था। इसलिए, आदेश exists("cite")रिटर्न FALSEआर 2.xx के लिए और TRUEआर 3.xx के लिए

आर, सभी संस्करण (1, 2 और 3), स्कोर: 12। अंक

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

समारोह eapplyआर 2.0.0 में पेश किया गया था।

— स्वेन होहेंस्टीन
स्रोत

R.version$major। 15 अक्षर। जब से यह मौजूद है तब से मैं नहीं।

— रुई बरदास

@RuiBarradas मुझे ओपी का हवाला देते हैं: " आपका प्रोग्राम भाषा के संस्करण को निर्धारित करने के लिए एक बिलिन, मैक्रो या कस्टम कंपाइलर झंडे का उपयोग नहीं कर सकता है। "

— स्वेन होइनस्टीन

ठीक है, माफ करना, मैंने वह हिस्सा मिस कर दिया है। क्या मुझे टिप्पणी को हटाना चाहिए?

— रुई बरदास

@RuiBarradas कोई समस्या नहीं। आपको टिप्पणी को हटाने की आवश्यकता नहीं है।

— स्वेन हॉन्स्टीन

आपको परिणाम को प्रिंट करना चाहिए। वर्तमान में, जब एक पूर्ण कार्यक्रम के रूप में चलाया जाता है तो यह कुछ भी प्रिंट नहीं करता है।

— JAD

4

पायथन , 196 बाइट्स / 16 संस्करण = स्कोर 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। अजगर 1.5 के लिए परीक्षण string.split1.6 तक मौजूद नहीं होने पर निर्भर करता है ।

लूप में नए वर्गों / मॉड्यूल के परीक्षण के विचार के लिए ओलिवियर ग्रेजायर के जवाब का श्रेय ।

मैंने अब आखिरकार अजगर के सभी प्रासंगिक संस्करणों पर परीक्षण किया है ... जो इसे संकलित करने के लिए 1.5 स्रोत कोड के संपादन की आवश्यकता है ...

— g.rocket
स्रोत

4

विंडोज 'बैच फ़ाइल , 35 बाइट्स / 2 संस्करण = स्कोर 17.5

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

DOSMS-DOS ^(duh) और NTWindows NT पर प्रिंट । ^(डुह)

अब, कुछ स्पष्टीकरण के लिए।

MS-DOS समय से Windows की बैच स्क्रिप्टिंग हुई है और तब से इसमें बहुत बदलाव नहीं आया है। हालाँकि, जब Windows NT साथ आया, तो Microsoft ने बैच लिपियों के लिए डिफ़ॉल्ट दुभाषिया COMMAND.COMको cmd.exe(अब .cmdमूल के विकल्प के रूप में भी विस्तार की अनुमति देता है .bat) को बदल दिया।

इसके साथ, उन्होंने कुछ बदलावों को भी लागू किया , जैसे कि /iसशर्त मामलों में स्ट्रिंग मामले की अनदेखी के लिए ध्वज। जो कि Z==zझूठा है, /i Z==zसच है।

हम इस बात का फायदा उठाते हैं कि डॉस के पास असंवेदनशीलता नहीं है और ऊपरवाले के Zसाथ तुलना करें z। /iध्वज का उपयोग करके , हम Z==zडॉस पर एक (गलत) सशर्त और z==zएनटी पर (सत्य) समाप्त होते हैं ।

अब, मुझे एहसास हुआ कि चुनौती निर्दिष्ट करती है कि एक संस्करण संख्या मुद्रित की जानी चाहिए। लेकिन, जहां तक मुझे पता है, बैच स्क्रिप्टिंग के लिए कोई 'वर्जन नंबर' नहीं है, इसलिए यह मेरे द्वारा प्राप्त किया जा सकने वाला निकटतम है।

Windows 10, DOSBox और vDos पर परीक्षण किया गया:

विंडोज 10:

( cmd /kविंडो बंद करने के लिए चलाएं exit)

DOSBox:

vDos:

— माथियस एवलर
स्रोत

विंडोज विंडोज 7से छोटा है NT।

— user202729

2

@ user202729 मुझे लगता है, लेकिन फिर, 7वास्तव में एक भाषा संस्करण नहीं है, यह 3.1 के बाद से सभी विंडोज पर समान है। इसलिए मैंने नहीं सोचा था कि इसे तब बुलाना उचित होगा 7जब यह शायद हो भी जाए3.1

— मैथ्यूस एवलर

3

वोल्फ्राम भाषा / गणितज्ञ १०/११, ३ / बाइट्स / २ संस्करण = १hem.५

(Length@DateRange[{1},{1}][[1]]+27)/337 बाइट्स पर विचार करें और 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 आउटपुट के बीच विसंगति मुझे हाल ही में बट में है, इसलिए मुझे इसका उपयोग करने पर सेट किया गया था।

एक अनुवर्ती के रूप में, कोई शायद गणितज्ञ संस्करणों 1- ~ 8 में Length@DateRange[{1}, {1}][[1]]मूल्यांकन का लाभ उठा सकता है 1, लेकिन मेरे पास इसे शामिल करने का समय नहीं था।

— user6014
स्रोत

2

यह निश्चित रूप से सुनिश्चित करें कि आपका उत्तर प्रॉम्प्ट की आवश्यकताओं को पूरा नहीं करता है, अर्थात् अंतिम नियम आपके द्वारा उपयोग किए जाने के कारण $Version:Your program may not use a builtin, macro, or custom compiler flags to determine the language version.

— Amndeep7

7

मैं केवल $Versionयह प्रदर्शित करने के लिए उपयोग कर रहा हूं कि यह सही परिणाम को सही संस्करण में आउटपुट करता है, $Versionमेरे उत्तर का हिस्सा नहीं है ...

— user6014

सभी अच्छे दोस्त - बात यह है, आप कुछ का उपयोग कर रहे हैं $VersionNumber, लेकिन इसके बजाय आप इसे बुला रहे हैं $Version। मेरे दिमाग में, जबकि आपके कार्यक्रम का मांस Length@DateRangeसामान है, जो तब $Versionपूर्ण संस्करण की जानकारी प्रदान किए बिना काम नहीं करेगा जो आप तब प्रक्रिया करते हैं, जो इसलिए नियमों का उल्लंघन करता है।

— अमनदीप 7

4

@ अमनदीप 7 सबमिशन का पहला पैराग्राफ में 37 बाइट कोड है। कोड ब्लॉक केवल आउटपुट प्रदर्शन हैं।

— पुरकाकूदरी

3

स्पष्टीकरण: विभिन्न संस्करणों में समय के विभिन्न प्रारूप का उपयोग करना। यह {1} Tr[1^#&@@%~DateRange~%]/3+9(31 बाइट्स), या सम 7+Length@Now(12 बाइट्स) के लिए अधिक गोल्फ हो सकता है

— user202729

3

रूबी 1.x और 2.x, 20 बाइट्स, स्कोर 10

p [].to_h&&2rescue 1

रूबी 2 में वर्ग to_hपर पेश की गई विधि के आधार पर Array।

— फिलिप फ्रैंक
स्रोत

अच्छा पहला जवाब। मेरे पास परीक्षण करने के लिए कोई 1.x काम नहीं है, लेकिन p [].to_h&&2rescue 1थोड़ा छोटा है।

— मैनटवर्क

@manatwork Great, 3 बाइट्स बचाता है और एक आकर्षण की तरह काम करता है

— फिलिप फ्रैंक

3

एरलैंग, 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 से विफलताओं की संख्या घटाते हैं, जो वर्तमान संस्करण है।

— legoscia
स्रोत

3

जूलिया 0.4, 0.5, 46 बाइट्स, स्कोर 22

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

जूलिया ने कई संस्करणों में कंक्रीट और सार स्ट्रिंग के प्रकार का नाम बदल दिया है।

इस कोड का विशेष रूप से लाभ उठाएं:

जूलिया 0.4 :

कंक्रीट है ASCIIString,
सार आधिकारिक तौर पर है AbstractString,
सार के रूप में नामित का त्याग दिया है String।
कंक्रीट अमूर्त की तुलना में सबसे विशिष्ट है इसलिए यह प्रेषण जीतता है

जूलिया 0.5 :

कंक्रीट आधिकारिक तौर पर है String,
कंक्रीट ने उर्फ को हटा दिया है ASCIIString,
सार है AbstractString, (हालांकि यहां कोई फर्क नहीं पड़ता)
जैसा कि कंक्रीट स्ट्रिंग प्रकार के लिए दो तरीकों को परिभाषित किया गया है, बाद वाला पूर्व को लिखता है।

विभिन्न सिद्धांतों पर आधारित मेरे नए और अधिक प्रभावी समाधान भी देखें

— लिंडन व्हाइट
स्रोत

3

जाप (1 और 2), 8 6/2 = 4 3

'1r\S2

टेस्ट v1 | परीक्षण v2

2 बाइट्स ने ओलिवर को धन्यवाद दिया

व्याख्या

V2 से पहले, Japt ने एक अनुकूलित RegEx वाक्यविन्यास का उपयोग किया था, इसलिए हम इसका लाभ उठा सकते हैं।

'1

एक स्ट्रिंग के रूप में नंबर 1।

 r  2

rनीचे ( ) के साथ बदलें ( ) 2।

\S

Japt 2 इसे RegEx के रूप में देखता है /\S/g, जो से मेल खाता है 1। Japt 1 \एस्केप कैरेक्टर को नजरअंदाज करता है और बस देखता है S, जो एक स्पेस कैरेक्टर के लिए Japt स्थिर है और जाहिर है, यह मेल नहीं खाता है 1।

— झबरा
स्रोत

3

Befunge, स्कोर = 3.5

7 बाइट्स, 2 संस्करण

"]"'b.@

इसे Befunge-93
में ऑनलाइन आज़माएं Befunge-98 में इसे ऑनलाइन आज़माएं

"]"दोनों संस्करणों में एक स्ट्रिंग शाब्दिक है, [स्टैक पर 93 (ASCII मूल्य ) को धक्का । 'bBefunge-98 में एक चरित्र शाब्दिक है, जो 98 (ASCII मूल्य b) को धकेलता है, लेकिन वे Befunge-93 में अमान्य निर्देश हैं, इसलिए उन्हें बस अनदेखा कर दिया जाता है। इस प्रकार हम बेफ़ुंज -93 में 98 और बेफ़ुंज -98 में ढेर के शीर्ष पर 93 के साथ समाप्त होते हैं। .@स्टैक के शीर्ष पर मूल्य लिखता है और फिर बाहर निकलता है।

— जेम्स होल्डरनेस
स्रोत

]".@.b'या ]g.@.b'यह भी काम करते हैं

— MildlyMilquetoast

3

रूबी 1.x (<1.9) और 2.x, 10 8 बाइट्स, स्कोर = 4

$><<?2%7

कोशिश करो:

यह ?xरूबी 1.x और 2.x के बीच के विभिन्न व्यवहारों का शोषण करके काम करता है । रूबी में 1.x, ?A(उदाहरण के लिए) रिटर्न 65(चरित्र का ASCII मान A), लेकिन रूबी 2.0 में यह एक-वर्ण स्ट्रिंग लौटाता है "A"।

उपरोक्त कोड इसके बराबर है:

val = ?2
$> << val % 7

रूबी 1.x (<1.9) में, का मान valहै 50(चरित्र के ASCII मूल्य 2), एक Fixnum। Fixnum#%मोडुलो ऑपरेटर है, इसलिए 50 % 7रिटर्न करता है 1।

रूबी 2.x में, valस्ट्रिंग है "2"। String#%का एक इन्फ़िक्स संस्करण है sprintf, इसलिए "2" % 7इसके समतुल्य है sprintf("2", 7), जहाँ "2"प्रारूप स्ट्रिंग है। चूंकि प्रारूप स्ट्रिंग में कोई प्रारूप अनुक्रम (जैसे %d) शामिल नहीं है , बाद के तर्कों को छोड़ दिया जाता है और "2"वापस कर दिया जाता है।

अंत में, के $>लिए एक उपनाम है $stdout, इसलिए $> << ...परिणाम प्रिंट करता है।

— जॉर्डन
स्रोत

1

अरे वाह! ?A==66?1:2आपके उत्तर में आने से पहले मैं कुछ ऐसा करने की कोशिश कर रहा था

— पिकाको

3

पायथन 2 और पायथन 3 , 36 34 बाइट्स, स्कोर 18 17

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

में अजगर 2 , नकारात्मक अनन्तता के हैश -271,828 है, लेकिन में अजगर 3 यह -314,159 है। संपादित करें: सहेजे गए 2 बाइट्स, स्कोर का 1 अंक, @ArBo के लिए धन्यवाद।

— नील
स्रोत

squints यह एक जानबूझकर ई बनाम पाई बात है?

— जो राजा

@ जोकिंग हाँ; जाहिरा तौर पर जब hashपहली बार फ्लोटिंग-पॉइंट इन्फिनिटी पर काम करने के लिए तय किया गया था, तो प्रासंगिक डेवलपर ने हैश मूल्यों के रूप में pi * 1e5 और e * -1e5 का उपयोग किया था। पायथन 3 में कुछ बिंदु पर नकारात्मक अनंत के लिए मूल्य का मूल्य अनंत के लिए हैश मूल्य के नकार के रूप में बदल गया।

— नील

2

पायथन 3 , पायथन 2 , स्कोर 17.5

(35 बाइट्स, 2 संस्करण)

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

पायथन 2 , 35 बाइट्स

इसे ऑनलाइन आज़माएं!

पायथन 3 , 35 बाइट्स

इसे ऑनलाइन आज़माएं!

बच निकले 5 बाइट्स ETHproductions की बदौलत

एक अच्छा कोड गोल्फ जवाब नहीं है, लेकिन एक बड़े पैमाने पर परिवर्तन!

— jferard
स्रोत

हम्म, क्या आप प्रत्येक कथन को पिछली पंक्ति में रख सकते हैं? Ietry:exec("print 2")\nexcept:print(3)

— ETHproductions

@ETHproductions धन्यवाद! मुझे जीत की उम्मीद नहीं थी, इसलिए मैं थोड़ा विचलित था। मैं मुख्य रूप से करने पर ध्यान केंद्रित करना चाहता था अजगर 2 और 3 के बीच बड़े पैमाने पर परिवर्तन

— jferard

अपनी भाषा का संस्करण निर्धारित करें

नियम

स्कोरिंग

गंभीरता से और वास्तव में , 3 बाइट्स, स्कोर 1.5

पायथन 3.0 और पायथन 2, स्कोर 6

जावा, 189 बाइट्स, 10 संस्करण, स्कोर = 18.9

Ungolfed

परिचय

व्याख्या

क्रेडिट

बिल्डिंस के साथ

पायथन , 606 बाइट्स / 15 संस्करण = 40.4 स्कोर

C ++ 11/14/17, स्कोर = 147/3 = 49

EcmaScript 3/5/2015/2016/2017 ब्राउज़र में, 59 बाइट्स / 5 संस्करण = 11.8 अंक

जावास्क्रिप्ट (ईएस 5 और ईएस 6), 14 बाइट्स / 2 संस्करण = 7

जावास्क्रिप्ट (ईएस 2, 3 और 5 - 8 9), 59/6 = 9.833 75/7 = 10.714

PHP 5/7, स्कोर 5.5

PHP 5.3.9 / 5.3.11, स्कोर 10

Befunge: 15 11 बाइट्स / 2 वर्जन = 5.5

पायथ 4/5 - 6 बाइट्स / 2 संस्करण = 3

पायथन 3 और पायथन 2.0, 18 बाइट्स, स्कोर 18/2 = 9

मूल रूप से, 4 बाइट्स, स्कोर 4 / tes

x86 16/32/64-बिट मशीन कोड: 11 बाइट्स, स्कोर = 3.66

यह काम किस प्रकार करता है:

7 बाइट्स (स्कोर = 2.33) अगर मैं संस्करण 1, 2, 3 नंबर कर सकता हूं

Brachylog / Brachylog v1 , 5/2 = 2.5

C89 / C99, 25 बाइट्स, 2 संस्करण, स्कोर = 12.5

पर्ल 5 और पर्ल 6, 23 बाइट्स 19 बाइट्स, स्कोर 9.5

बैश, सभी 4 संस्करण, 72 71 32 बाइट्स ⇒ स्कोर = 8

Ungolfed:

आर, संस्करण 2 और 3, स्कोर: 10.5 अंक

आर, सभी संस्करण (1, 2 और 3), स्कोर: 12। अंक

पायथन , 196 बाइट्स / 16 संस्करण = स्कोर 12.25

विंडोज 'बैच फ़ाइल , 35 बाइट्स / 2 संस्करण = स्कोर 17.5

वोल्फ्राम भाषा / गणितज्ञ १०/११, ३ / बाइट्स / २ संस्करण = १hem.५

रूबी 1.x और 2.x, 20 बाइट्स, स्कोर 10

एरलैंग, 180 बाइट्स, 11 संस्करण, स्कोर 16.36

जूलिया 0.4, 0.5, 46 बाइट्स, स्कोर 22

जाप (1 और 2), 8 6/2 = 4 3

व्याख्या

Befunge, स्कोर = 3.5

रूबी 1.x (<1.9) और 2.x, 10 8 बाइट्स, स्कोर = 4

पायथन 2 और पायथन 3 , 36 34 बाइट्स, स्कोर 18 17

पायथन 3 , पायथन 2 , स्कोर 17.5

पायथन 2 , 35 बाइट्स

पायथन 3 , 35 बाइट्स