युगों के माध्यम से मान्य

24

एसओ के इस सवाल से प्रेरित होकर , आपका काम एक ऐसे प्रोग्राम का निर्माण करना है जो आपकी चुनी हुई भाषा के दो प्रमुख संस्करणों में मान्य है (जो कम से कम अलग-अलग आउटपुट का उत्पादन करते हैं।

नियम

  • किसी भी भाषा में एक से अधिक प्रमुख संस्करण का उपयोग किया जा सकता है।
    • इस चुनौती के प्रयोजनों के लिए, मैं एक "प्रमुख संस्करण" सुझाऊंगा जहां संस्करण संख्या परिवर्तन में पहला नंबर है।
      • PHP 4 और PHP 5 अलग हैं, PHP 5.3 और PHP 5.4 नहीं हैं।
    • हालाँकि, जब से मैं सभी भाषाओं के लिए संस्करण योजना नहीं जानता, यदि आप अपने मामले को अच्छी तरह से बहस कर सकते हैं, तो मुझे यकीन है कि समुदाय निर्धारित करेगा कि क्या आप "प्रमुख संस्करण" का निर्धारण करने में निष्पक्ष हैं।
  • कोड को हर बार एक ही झंडे और इनपुट के साथ संकलित और चलाया जाना चाहिए
    • यदि यह उचित है तो भाषा के संस्करण को छोड़कर
  • त्रुटियां आउटपुट के रूप में नहीं गिनी जाती हैं और त्रुटियों का उत्पादन करने वाले उत्तरों को अयोग्य घोषित किया जाता है (बजाय त्रुटि आउटपुट को अनदेखा किए)
  • कार्यक्रम को चलाने के लिए आवश्यक इनपुट के अलावा कोई अन्य इनपुट नहीं लेना चाहिए।
  • प्रत्येक दिए गए संस्करण के लिए, आउटपुट हमेशा समान होना चाहिए
  • अभिप्राय यह है कि परिवर्तन वीएम युक्ति या पर्यावरण मेटाडेटा के बजाय भाषा युक्ति में परिवर्तन का परिणाम होना चाहिए

स्कोरिंग

  • लंबाई के लिए कोड-गोल्फ प्रकार स्कोरिंग, इसलिए +1प्रत्येक चार / बाइट के लिए
  • -1आउटपुट की लंबाई में प्रत्येक वर्ण अंतर के लिए।
    • उदाहरण के लिए संस्करण 1 आउटपुट abcde(5 वर्ण), संस्करण 2 आउटपुट 123abc(6 वर्ण) =-1

अन्य नियम

  • मानक अपवाद लागू होते हैं - कोई बाहरी कार्यक्रम, वेब अनुरोध आदि।
  • आपका कार्यक्रम समाप्त होना चाहिए (2 सेकंड के भीतर)
  • सबसे कम स्कोर जीतता है।

"बेहतर" स्कोरिंग

अपने मूल उत्तर रखें, निष्पक्षता के हित में, मैं मूल नियमों के आधार पर विजेता को चिह्नित करूंगा।

चूँकि मेरा मूल स्कोरिंग मूल रूप से टूटा हुआ है, इसलिए निम्न स्कोरिंग प्रणाली के साथ पुन: स्कोर / पुनः प्रयास नहीं करना चाहिए:

  • लंबाई के लिए कोड-गोल्फ प्रकार स्कोरिंग, इसलिए +1प्रत्येक चार / बाइट के लिए
  • +1आउटपुट की लंबाई में प्रत्येक वर्ण अंतर के लिए
    • abcdeऔर 123456->+1
  • -1आउटपुट में प्रत्येक अद्वितीय वर्ण अंतर के लिए (कम से कम उत्पादन की लंबाई तक छाया हुआ)
    • abcdeऔर 123456->-5
    • 12345और 123456->-1
    • 12345और 123455->0
  • शून्य जीत के निकटतम स्कोर
  • दूसरे टाई ब्रेक की स्थिति में, सरल कोड-गोल्फ स्कोर जीत जाता है।
code-challenge 
— जेम्स वेबस्टर
स्रोत
नोट: रूबी में, पहला नंबर युग है , यह रूबी के इतिहास की प्रमुख घटनाओं को दर्शाता है, न कि संस्करण संख्या (0-> 1 प्रारंभिक रिलीज़, 1-> 2 रूबी का 20 वां जन्मदिन था)। प्रमुख संख्या दूसरी संख्या है। तो, रूबी 1.8-> 1.9 एक बड़ी रिलीज को पार कर जाएगा।
— जॉर्ग डब्ल्यू मित्तग
1
मुझे लगता है कि नया स्कोरिंग मूल से बहुत अलग है, यह व्यावहारिक रूप से एक नया सवाल है
— ताल
मैं कहूंगा कि PHP का उदाहरण यकीनन अच्छा है, 5.4 में कुछ बुनियादी विशेषताएं हैं जो 5.3 (लक्षण, सारणी, सरणी डीफ्रेंसिंग) पर टूट जाएंगी। यह PHP6 होने जा रहा था, लेकिन फिर डिफ़ॉल्ट IIRC द्वारा यूनिकोड स्ट्रिंग्स के रूप में 6 को कुछ और अधिक कट्टरपंथी को बचाने का फैसला किया गया
— Einacio
2
अद्वितीय चरित्र अंतर क्या है? अगर मैं आउटपुट देता हूं zzzzऔर aaaaक्या वह मुझे देता है -4? यही मेरे जैसा लगता है।
— जस्टिन
1
इसलिए, यह मानते हुए कि कार्यक्रम यह पता लगा सकता है कि यह किस संस्करण में चलता है, विजेता वह है जो दो सेकंड में सबसे अधिक वर्णों का उत्पादन कर सकता है? मुझे लगता है कि यह सवाल एक लोकप्रियता-प्रतियोगिता के रूप में बेहतर होगा कि लोगों को दिलचस्प और सूक्ष्म भाषा कीड़े खोजने के लिए प्रोत्साहित किया जाए।
— सेफालोपॉड

जवाबों:

39

"बेहतर" स्कोरिंग प्रणाली के लिए संशोधित उत्तर

C89 / C99, स्कोर: 0

मेरा कार्यक्रम 52 वर्ण लंबा है और विभिन्न आउटपुट को प्राप्त करने के लिए मेरे मूल उत्तर में उसी तंत्र का उपयोग करता है। यह काम करता है क्योंकि C89 //टिप्पणी के रूप में व्यवहार नहीं करता है :

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

परिणाम:

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

पुराना उत्तर:

C89 / C99, स्कोर: -इनफिनिटी?

मुझे पूरी तरह से यकीन नहीं है कि यह कार्यक्रम नियमों को तोड़ता नहीं है, लेकिन कभी भी बुरा नहीं मानता। यह कार्यक्रम इस तथ्य का शोषण करता है कि C89 //में एक वैध टिप्पणी नहीं /* ... */है, लेकिन है।

कमेंट ट्रिक का उपयोग करके किसी अन्य फ़ंक्शन को निष्पादित किया जाता है। C89 में फ़ंक्शन "trolololol..."स्टैक ओवरफ्लो तक प्रिंट करता है (इसलिए यह 2 सेकंड के भीतर समाप्त हो सकता है)।

f1(){printf("ol");f1();}
f2(){printf("oll");}
main(){
    printf("tr");
    void (*f[])() = {f1,f2};
    f[0 //* trollololol */
      +1]();
}

C99

$ ./diffc99
troll

C89

$ ./diffc89
trolololololololololololololololololololololololololololololololololololololololololo
lolololololololololololololololololololololololololololololololololololololololololol
ololololololololololololololololololololololololol ....
— MarcDefiant
स्रोत
1
मुझे यकीन नहीं है कि यह नियमों के खिलाफ है या नहीं, लेकिन मुझे यह पसंद है :)
— ताल
9
"बेहतर नियम" के अनुसार, Scores closest to zero winइसलिए यह वास्तव में शून्य से बहुत दूर है।
— user80551
1
फंक्शन पॉइंटर्स की एक सरणी को या तो विभाजन या इसके अलावा C मानक टिप्पणियों की परिभाषा के आधार पर ... सुंदर।
— डेस्टी
16

पायथन - अगले सर्वश्रेष्ठ उत्तर से 10 अंक कम

print(range(100))

पायथन 2 में, यह पूर्णांकों की पूरी सूची को 0 से 99 तक प्रिंट करेगा।

पायथन 3 में, rangeएक जनरेटर है और इसलिए यह केवल "रेंज (0,100)" प्रिंट करेगा।

यह देखते हुए कि मैंने पायथन में संख्याओं पर एक आकार सीमा में कभी नहीं चलाया, मैं उस 100 को बहुत बड़ी संख्या (2 ** 1000, उदाहरण के लिए) से बदल सकता हूं और आउटपुट में लगभग अनंत अंतर के साथ समाप्त कर सकता हूं।

इस तथ्य को प्रतिबिंबित करने के लिए संपादित किया गया है कि, जबकि मैं एक अंक प्राप्त कर सकता हूं जो किसी भी व्यावहारिक उद्देश्य के लिए असीम रूप से कम है, मैं एक प्रोग्राम के साथ वास्तविक अनंत तक नहीं पहुंच सकता हूं जो 2 सेकंड के तहत समाप्त होता है

अद्यतन टाई-ब्रेकर स्कोरिंग प्रणाली के लिए, मैं प्रस्तुत करूंगा:

print(range(4))

आउटपुट:

अजगर 2: [0, 1, 2, 3]

अजगर 3: range(0, 4)

पहले प्रिंट में 5 अद्वितीय वर्ण हैं ( [123]), दूसरे प्रिंट में 8 अद्वितीय वर्ण हैं ( range(4)), आउटपुट की लंबाई में अंतर 1 है, कोड में 15 वर्ण हैं, सबसे कम आउटपुट 11 वर्ण हैं ... ये नियम बहुत भ्रामक हैं लेकिन मुझे लगता है कि यह मुझे 15 + 1-मिनट (11,5 + 8) = 5 के अंतिम स्कोर तक लाता है।

— ताल
स्रोत
हालांकि, "आपका कार्यक्रम समाप्त होना चाहिए", यहां तक ​​कि बहुत (सूक्ष्म रूप से) तेज मशीन पर भी, आपका "बहुत बड़ा" (परिमित) संख्या अभी भी कहीं नहीं है-इसलिए मैं आपके स्कोर (देने या लेने;) का विवाद करता हूं
— जेम्स वेबस्टर
@JamesWebster इस भयानक तकनीकी गलती को मेरे ध्यान में लाने के लिए धन्यवाद, मैंने अपने उत्तर को उसी के अनुसार संपादित किया है;)
— ताल
इसी तरह के अन्य उत्तर निश्चित रूप से आएंगे। मुझे लगता है कि इन उत्तरों के लिए स्कोरिंग की गणना की जानी चाहिए कि वे कितनी तेजी से अनंत तक पहुंचते हैं।
— वेरेस
@Vereos मुझे उम्मीद है कि, यदि इस प्रकार के अन्य उत्तर दिखाई देते हैं, तो प्रश्न को अतिरिक्त स्कोरिंग विवरण के साथ संपादित किया जाएगा।
— ताल
1
@ मुझे लगता है कि हर कोई जो स्कोरिंग नियमों को पढ़ता है, वह एक ऐसा समाधान बनाएगा जो नकारात्मक स्कोर उत्पन्न कर सकता है, केवल समस्या के किसी भी जवाब को पढ़ने से पहले, भाषा या हार्डवेयर द्वारा सीमित;) स्कोरिंग केवल डिज़ाइन द्वारा तोड़ा गया है ...
— फोब्बर
13

पायथन - 0 अंक

पता नहीं यह कैसे काम करता है: पी बस यादृच्छिक कोड की कोशिश करते समय उस पर ठोकर खाई।

int

पायथन 3 पर, यह <class 'int'>और पायथन 2 पर है, यह <type 'int'>(इंटरेक्टिव कंसोल का उपयोग करके)
"बेहतर" स्कोर: 3 (लंबाई) + 1 (चार अंतर) - 4 (अद्वितीय वर्ण)

पुराने पायथन 1 - 7 अंक

print()

इस संस्करण के लिए @grc का बड़ा धन्यवाद और मुझे चार अंकों को घटाने में मदद मिली!

पायथन 2 में, इस कथन की व्याख्या की गई है print ()जो खाली टपल को प्रिंट करता है ()।
पायथन 3 में, printएक फ़ंक्शन है और जिसके परिणामस्वरूप कुछ भी मुद्रित नहीं किया जाता है।
"बेहतर" स्कोर: 7 (लंबाई) + 2 (चार अंतर) - 2 (अद्वितीय आकर्षण)

पुराने पायथन 2 - 13 अंक:

print(1,2)

"बेहतर" स्कोर: 12 (लंबाई) + 2 (चार अंतर। ओ / पी) - 1 (अद्वितीय आकर्षण ओ / पी)

मुझे पता है कि यह जीतने वाला नहीं है, लेकिन फिर भी उसने जवाब दिया, क्योंकि यह मेरी पहली पायथन कोशिश है :)

— गौरांग टंडन
स्रोत
मुझे लगता है कि इसे छोटा किया जा सकता है print()।
— grc
@grc सलाह के लिए बहुत बहुत धन्यवाद! अपने संकलक को देखते हुए, मैं देखता हूं कि मैंने इसे आज़माया था, लेकिन डॉक्स में इतना खो गया था, कि मैंने इसे आजमाने के लिए इसे हटा दिया dict.itertools(): P
— गौरांग टंडन
12

सी#

मैंने C # 2, 3 और 4 के बीच जेनेरिक विधि प्रकार के अनुमान एल्गोरिदम भी बदले। उदाहरण के लिए:

using System;
class C
{
  static int M<T>(T x, T y) { return 1; }
  static int M(object x, object y) { return 2; }
  static void Main() 
  {
    Console.WriteLine(M(1, new int?()));
  }
}

C # 2 विधि प्रकार के निष्कर्ष में कहा गया है कि T दोनों intऔर नहीं हो सकता है int?, और इसलिए उत्पादन करता है 2। सी में # 3 विधि प्रकार निष्कर्ष कहते हैं, "के बीच सर्वश्रेष्ठ संतुलन intऔर int?है int?और चुनता तो" M<int?>और 1 पैदा करता है।

— एरिक लिपर्ट
स्रोत
9
> मैंने भी बदल दिया है आपका क्या मतलब है आपने बदल दिया है ... ओह। ओह।
— बॉब
9

रूबी, 4 वर्ण + 0 चार लंबाई का अंतर - 3 अद्वितीय चार अंतर = 1 का स्कोर

p ?d

रूबी 1.9 पर, यह प्रिंट करेगा "d"। 1.8 पर, यह प्रिंट करता है 100।

स्पष्टीकरण: ?dहै "d"1.9 में और 1001.8 में (घ के लिए ASCII कोड)। p xके बराबर है puts x.inspect। *स्ट्रिंग पुनरावृत्ति और गुणा दोनों है।

पुराने स्कोरिंग के लिए "अनुकूलित" संस्करण:

रूबी, 8 अक्षर - 999999989 वर्ण अंतर = -999999981 का स्कोर

p ?!*1e9

33000000000.01.8 के लिए प्रिंट और "!!!!!!... !!!"1.9 के लिए। ( ?!है 331.8 में और "!"1.9 में, और *दोनों स्ट्रिंग पुनरावृत्ति और गुणा है।)

वास्तव में, आप गुणा के साथ जहाँ तक चाहें जा सकते थे, यह सिर्फ इस बात पर निर्भर करता है कि आपका कंप्यूटर कितना तेज है।

— Doorknob
स्रोत
क्या आप बता सकते हैं कि वास्तव में उस दूसरी पंक्ति में क्या हो रहा है?
— ताल
@Tal ठीक है, संपादित
— दरवाज़े
8

बैश - -∞ (व्यावहारिक सीमा तक)

प्रभावी रूप से, हालांकि आपके पास बहुत अधिक स्मृति है। जैसे लगभग 10GB:

echo {0..999999999}

बैश 2: ब्रेस विस्तार में पर्वतमाला का समर्थन नहीं करता है, इसलिए प्रिंट करता है {0..999999999}।

बैश 3:

कोई भी भाषा - -∞ (व्यावहारिक सीमा तक)

यह बहुत अधिक किसी भी भाषा में होगा, भले ही यह थोड़ा और अधिक जटिल हो। जैसे ही आप दो अलग-अलग मूल्य बना सकते हैं, आप कोड लिख सकते हैं जो मनमाने ढंग से अलग-अलग आउटपुट का उत्पादन करता है। एक बेहतर स्कोरिंग पद्धति आउटपुट में अंतरों की अनदेखी करेगी।

version = … # some arbitrarily weird stuff
if version = 2:
    while not timed_out():
        print "version2"
— गिल्स 'SO- बुराई होना बंद करो'
स्रोत
@foobar …"किसी भी भाषा" संस्करण में आपके प्रोग्राम को बनाने के लिए जो भी तरकीबें इस्तेमाल की जाती हैं, वह भाषा की कल्पना में एस्कॉन्ग पर निर्भर करती हैं। यह संस्करण का पता लगाना है, चाहे आप करें if $version >= 3या if isinstance(range(0),list)।
— गाइल्स का SO- बुराई से दूर रहना '
4

सी#

निम्नलिखित कोड C # 5.0 और C # के पिछले संस्करणों के लिए अलग आउटपुट का उत्पादन करेगा

using System;
using System.Collections.Generic;

namespace TestConsoleAppClosure
{
    class Program
    {
        static void Main(string[] args)
        {
            var actions = new List<Action>();
            List<int> list = new List<int> { 10, 20, 30, 40 };
            foreach (var item in list)
            {
                  actions.Add(() => Console.WriteLine(item));
            }
            foreach (var act in actions) act();
        }
    }
}

आउटपुट: C # 5.0

10
20
30
40

आउटपुट: C # 4.0

40
40
40
40

इसका कारण एरिक लिपर्ट द्वारा ब्लॉग पोस्ट में बताया गया है

लूप चर पर बंद हानिकारक माना जाता है

— हबीब
स्रोत
4

अजगर, -14 अंक (3 - 17 चार लंबाई का अंतर = -14)

2/3

पायथन 2 आउटपुट: 0

पायथन 3 आउटपुट: 0.6666666666666666

बेहतर स्कोरिंग संस्करण, 5 अंक (3 + 2 चार लंबाई का अंतर = 5)

3/2

पायथन 2 आउटपुट: 1

पायथन 3 आउटपुट: 1.5

— Rynant
स्रोत
4

सी#

मैंने C # 4 में सहसंयोजक और विरोधाभासी जोड़ा, इसलिए फ़ॉर्म के कार्यक्रम:

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

falseC # 2 और 3 में और trueC # 4 में उत्पादन करेगा ।

हालाँकि, कोई यह तर्क दे सकता है कि यह गिनती नहीं करता है क्योंकि पुस्तकालय की परिभाषा को IEnumerable<T>भी बदलना होगा।

— एरिक लिपर्ट
स्रोत
3

C ++ 98/11 - "बेहतर" स्कोरिंग (115 वर्ण - उत्पादन में 115 अद्वितीय वर्ण अंतर = 0 का स्कोर)

नए स्कोरिंग नियमों का पालन करने के लिए थोड़ा संपादित संस्करण

golfed:

#include<cstdio>
#define u8 "\x0B"
int main(){int i=116;char c[i];c[--i]=0;while(i-->0)c[i]=u8"\x7E"[0]+i;puts(c);}

Ungolfed संस्करण:

#include <cstdio>
#define u8 "\x0B"
int main() {
    int i = 116;
    char c[i];
    c[--i] = 0;

    while(i-- > 0)
        c[i] = u8"\x7E"[0] + i;

    puts(c);
}

नया समाधान पुराने वाले से बहुत अलग नहीं है। नए समाधान में C ++ 11 और C ++ 98 दोनों में आउटपुट 116 वर्णों के साथ समान रूप से लंबा है, लेकिन उनमें जो एकमात्र चरित्र है वह पुट फ़ंक्शन द्वारा जोड़ा गया नया लाइन वर्ण है।

सी ++ 98 के लिए u8में u8"\x7E"[0]अभी भी बदल दिया जाएगा, लेकिन अब के साथ "\x0B"। तो प्रीप्रोसेसिंग के बाद परिणामी मूल्य होगा "\x0B""\x7E"[0]। दो तारों को समतल किया जाएगा "\x0B\x7E"और सबस्क्रिप्ट ऑपरेटर पहले तत्व तक पहुंच जाएगा, इस मामले में चरित्र एन्कोडिंग में मान 11 के साथ चरित्र। इसके अतिरिक्त मूल्य को iजोड़ा जाएगा, जो कि 114 है। इसलिए मान 125 के साथ वर्ण परिणामी सरणी में लिखा जाएगा। जैसा कि i125 से 11 तक के सभी मान शून्य हो जाएंगे, सरणी पर लिखा putsजाएगा और 11 से 125 तक के मान के साथ सभी वर्णों को प्रिंट करेगा, साथ ही अनुगामी नई पंक्ति।

C ++ 11 u8"\x7E"[0]में एक UTF-8 स्ट्रिंग के साथ हेक्साडेसिमल मान 7E के साथ एकल वर्ण के रूप में व्याख्या की जाएगी। सबस्क्रिप्ट ऑपरेटर अब इस चरित्र तक पहुंच जाएगा और इसके मूल्य iको इसमें जोड़ा जाता है, जिसके परिणामस्वरूप पहली पुनरावृत्ति के दौरान दशमलव मान 241 है। iशून्य पर जाते समय , सभी मान 126 से नीचे सरणी के लिए लिखे putsजाएंगे और 126 से 241 तक मानों के साथ वर्णों को प्रिंट करेंगे, साथ ही अनुगामी नई रेखा।

उपयोग किए गए वर्ण सेट के आधार पर, यह अलग-अलग परिणाम देगा, क्योंकि अधिकांश वर्ण सेट में केवल पहले 128 वर्ण हैं।

ISO-8859-2 के लिए आउटपुट निम्न होगा:

सी ++ 98: C ++ 98 के लिए आउटपुट

सी ++ 11: C ++ 11 के लिए आउटपुट

C ++ (106 अक्षर - आउटपुट में 107 अंतर = -1 का स्कोर) (पुराने नियम)

golfed:

#include<cstdio>
#define u8 "f"
int main(){int i=108;char c[i];c[--i]=0;while(i-->0)c[i]=u8""[0];puts(c);}

Ungolfed संस्करण:

#include <cstdio>
#define u8 "f"

int main() {
    int i = 108;
    char c[i];
    c[--i] = 0;

    while(i-- > 0)
            c[i] = u8""[0];

    puts(c);
}

के साथ संकलित g++ -std=c++98 main.cppऔर g++ -std=c++11 main.cpp।

वास्तव में आप 108नकारात्मक अंक प्राप्त करने के लिए पूर्णांक रेंज में किसी भी सकारात्मक संख्या के साथ बदल सकते हैं। जब तक यह 108 से बड़ा है;)

सी ++ 98 में #define u8 "f"पूर्वप्रक्रमक को बदलने के लिए कारण होगा u8""[0]साथ "f"""[0]। यह परिणाम देगा "f"[0], जो अंत में एकल चरित्र बन जाता है 'f', जो एक सरणी के लिए लिखा जाता है।

puts(c)i-1 से मिलकर परिणामी सरणी को प्रिंट करेगा 'f'।

C ++ 11 u8""[0]में खाली स्ट्रिंग को UTF-8 स्ट्रिंग के रूप में व्याख्या करने का कारण होगा, इसलिए कोई स्ट्रिंग संघनन नहीं किया जाता है। जैसा कि यह एक सी-स्ट्रिंग है, सबस्क्रिप्ट ऑपरेटर समाप्त होने वाले नल-बाइट तक पहुंच जाएगा और इसे एक सरणी में लिख देगा।

अंत puts(c)में परिणामी सरणी को प्रिंट करेंगे, जिसमें केवल नल-बाइट्स हैं। लेकिन जैसे putsही यह इनपुट को पढ़ना बंद कर देता है, जैसे ही यह एक शून्य-बाइट का सामना करता है, यह केवल एक नई लाइन प्रिंट करेगा और इससे अधिक कुछ नहीं।

— foobar
स्रोत
मुझे आपका स्कोर मिलता है। 1. दोनों c ++ 89 और c ++ 11 आउटपुट a ?(मेरे (Mac) सिस्टम पर कम से कम)
— जेम्स वेबस्टर
हालांकि मैं समाधान में केवल 115 वर्णों को गिनता हूं।
— जेम्स वेबस्टर
@ जेम्स वेबस्टर सच, wc -c ने मुझसे झूठ बोला;) मैं अपने समाधान के अंत में एक नई रूपरेखा प्रस्तुत करूँगा;) ... या बस इसे समायोजित करूँगा।
— फोब्बर
@ जेम्स वेबस्टर मुझे लगता है कि आप अपने टर्मिनल में UTF-8 एन्कोडिंग का उपयोग कर रहे हैं। जैसा कि एक बाइट में सबसे महत्वपूर्ण बिट UTF-8 में आरक्षित है, यह 128 से 232 की सीमा में कार्यक्रम के आउटपुट को मैप नहीं कर सकता है। तो आपको 104 तक देखना चाहिए? ' या बीच में बाइनरी कचरा के साथ कम। एक उदाहरण के रूप में WINDOWS-1256 एन्कोडिंग के साथ, आपका टर्मिनल इसे C ++ 11 संस्करण के लिए प्रदर्शित करेगा: tuvxyxyz {|} ~ € پ ‚-„… †-----'-• ”“ — •-™ ™- ¤ ¤ œ œ œ £ ¤ ھ ھ © ¬ © ¯®¯ ° ° ں ؛ · ± ں »¼½¾ ة ةابةتثجحخدذرزسصضصضصض × طظعغـفقك à ل â منهو
— foobar
C ++ 98 संस्करण के लिए यह संभव है कि आपका टर्मिनल प्रदर्शित हो? ' 32 से नीचे के मानों के लिए नियंत्रण वर्ण हैं। उदाहरण के लिए मेरा टर्मिनल उनमें से अधिकांश को एक वर्ग और उनके हेक्साडेसिमल मूल्य के साथ मुद्रित करता है। उदाहरण के रूप में नई लाइन और टैब वर्णों को छोड़कर। लेकिन अब जब मैं खुद इसका जिक्र करता हूं। सी ++ 98 संस्करण में दो बार नई लाइन शामिल है, लेकिन इसे ठीक करना आसान है;)
— फोबार
2

CSS2 बनाम CSS3 48 अंक

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

के रूप में प्रदान ABCDEFGHIJKLMNOPQRSTUVWXYZCSS3 के ब्राउज़रों पर (छोटे अक्षर)

के रूप में प्रदान abcdefghijklmnopqrstuvwxyzगैर CSS3 के ब्राउज़रों पर

74 वर्ण - 26 अद्वितीय वर्ण भेद = 48

— टोनी टोनी चोपर
स्रोत
लेकिन यह CSS2 में एक त्रुटि है। मुझे लगा कि त्रुटियों की गिनती नहीं हुई है।
— मिस्टर लिस्टर
@MrLister AFAIK font-सुविधा सेटिंग्स CSS3 में शुरू किया गया है dev.w3.org/csswg/css-fonts/#propdef-font-feature-settings
— टोनी टोनी चोपर
1

पर्ल, 24 वर्ण - (9 * (10 ^ 9)) - 1 चार अंतर = का स्कोर - ((9 * (10 ^ 9)) - 1) 768

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

a5 से नीचे के सभी संस्करणों के लिए 9e9-बार प्रिंट करता है, aऊपर के सभी संस्करणों के लिए प्रिंट 5. आप aदूसरे आउटपुट में अधिक एस जोड़कर स्कोर को असीम रूप से कम कर सकते हैं ।

— विन्स
स्रोत
2
सवाल में: "इरादा है कि परिवर्तन वीएम कल्पना या पर्यावरण मेटाडाटा भाषा कल्पना के बजाय में एक परिवर्तन का एक परिणाम होना चाहिए कि"
— दरवाज़े
मैं किसी वीएम युक्ति या पर्यावरण मेटाडेटा का उपयोग नहीं कर रहा हूं। बस स्थापित संस्करण।
— विंस
1

बेफ़ुंज, 36 - 378 = -342; 164 - 2576 = -2412

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

Befunge 93 में, यह होगा उत्पादन 3 रिक्त स्थान, द्वारा पीछा किया <v, 76 रिक्त स्थान के द्वारा पीछा किया, जिसके बाद <v, फिर 76 स्पेस दें, फिर <v, तो 76 रिक्त स्थान है, तो <v77 रिक्त स्थान के द्वारा पीछा किया, तो v78 रिक्त स्थान के द्वारा पीछा किया। लंबाई: 3 + 2 + 76 + 2 + 76 + 2 + 76 + 2 + 77 + 1 + 78 = 395यह पहली 5 लाइनों के समान अतिरिक्त लाइनें जोड़कर तुच्छ रूप से विस्तार योग्य है।

Befunge 98 में, यह आउटपुट होगा <v <v <v <v v।

लंबाई में अंतर 395 - 17 = 378:। तो स्कोर (पुराने नियमों के अनुसार) होगा:-342

नोट: अगर मैं .इसके बजाय इस्तेमाल करता तो मुझे और भी बड़ा अंतर मिल सकता था ,; फर्क होता-684

नियम परिवर्तन:

यह थोड़ा और मुश्किल है।

"  "-v>"Befunge 93 very long strings"v>"F"0g" "1-`!#v_   "F"0g1-"F"0pvz
     _^p0"F"-1g0"F"_v#    `-1" "g0"F"<^"j++a81zzzzzz]zzzzzzzzzzzzzzz"<
             _@#`0:,<

Befunge 93 आउटपुट:

sgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeB

Befunge 98 आउटपुट:

j++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzz

लंबाई: 2576। तार के बीच कोई भी चरित्र समान नहीं है, इसलिए अगर मैं चुनौती को सही ढंग से समझ पाया, तो मेरा स्कोर है 164 - 2576 = -2412(हां, मुझे लक्ष्य बनाना चाहिए था 0, लेकिन यह अधिक मजेदार था)। यदि मुझे इसे बनाने की आवश्यकता है ताकि प्रत्येक स्ट्रिंग में प्रत्येक चरित्र अद्वितीय और एक दूसरे से अलग हो, तो मैं ऐसा कर सकता हूं, कृपया मुझे बताएं।

— जस्टिन
स्रोत
1

पॉवर्सशेल, "बेटर" स्कोरिंग, -163 (15 - 178 चार अंतर = -163)

$PSVersionTable

Powershell V2

Name                           Value                                                                   
----                           -----                                                                   
CLRVersion                     2.0.50727.5477                                                          
BuildVersion                   6.1.7601.17514                                                          
PSVersion                      2.0                                                                     
WSManStackVersion              2.0                                                                     
PSCompatibleVersions           {1.0, 2.0}                                                              
SerializationVersion           1.1.0.1                                                                 
PSRemotingProtocolVersion      2.1

पवरशेल V3

Name                           Value                                                                   
----                           -----                                                                   
WSManStackVersion              3.0                                                                     
PSCompatibleVersions           {1.0, 2.0, 3.0}                                                         
SerializationVersion           1.1.0.1                                                                 
BuildVersion                   6.2.9200.16398                                                          
PSVersion                      3.0                                                                     
CLRVersion                     4.0.30319.1022                                                          
PSRemotingProtocolVersion      2.2
— Rynant
स्रोत
1

PHP, स्कोर: 0 (सबसे अच्छा मामला) 

srand(2);echo rand();

वाह, यह समझाने में मज़ा आने वाला है।

इस वेबसाइट के अनुसार , srand()फ़ंक्शन PHP 5.1.5 से PHP 5.3.14 तक टूटा हुआ प्रतीत होता है । इसलिए, हम PHP 4.4.9 पर विचार करने जा रहे हैं और PHP 5 का एक यादृच्छिक संस्करण जो ऊपर दिए गए संस्करण अंतराल में आता है।

PHP 4.4.9 आउटपुट: 1505335290

मुझे नहीं लगता कि यह नियम-तोड़ने वाला है; चूंकि यह एक बग प्रतीत होता है, आउटपुट समान होना चाहिए , लेकिन यह नहीं है। हमारे अन्य PHP संस्करण केवल srand()फ़ंक्शन को छोड़ देंगे और एक यादृच्छिक संख्या को आउटपुट करेंगे ।

— Vereos
स्रोत
1

जावा (लगभग -2.000.000.000)

जावा संस्करण को कभी-कभी 1.x कहा जाता है, लेकिन मुझे लगता है कि यह अभी भी नियमों के भीतर है।

आसान तरीका यह जांचना है कि क्या एक वर्ग मौजूद है जो एक विशिष्ट संस्करण में पेश किया गया था।

try {
    Class.forName("java.lang.AutoCloseable");
    // Java 7 or later
    char[] text = new char[Integer.MAX_VALUE];
    Arrays.fill(text, 'a');
    System.out.println(new String(text));
} catch (Exception e) {
    // Java 6 or earlier
    System.out.println("-");
}

(अपने टर्मिनल पर थोड़ा निर्भर करता है कि क्या दो सेकंड में 2 बिलियन अक्षरों का उत्पादन करना संभव है / नए स्कोरिंग के लिए, Integer.MAX_VALUEकार्यक्रम के बाइट काउंट को सही शून्य स्कोर प्राप्त करने के लिए बदलें ।)

यह कोड उपयोग किए जाने वाले VM / JDK के संस्करण पर निर्भर करता है (क्या वह गणना करता है?)

import java.lang.reflect.Field;
import java.util.Arrays;

{
    Field fValue = null;
    for (Field f: String.class.getDeclaredFields()) {
            if (f.getName().equals("value")) {
                    fValue = f;
            }
    }
    char[] text = new char[10];
    Arrays.fill(text, 'a');
    String s1 = new String(text);
    String s2 = s1.substring(1);
    fValue.setAccessible(true);
    text = (char[]) fValue.get(s2);
    Arrays.fill(text, 'z');
    System.out.println(s1);
}

यह zजावा 6 और पहले के जेडीके के लिए और aहाल के संस्करणों के लिए प्रिंट करता है।

— सेफ़ालोपोड
स्रोत
1

जावास्क्रिप्ट (ईएस 3 बनाम ईएस 5) - 9 अंक

लंबाई 10 + लंबाई अंतर 0 - आउटपुट अंतर1

[].map?1:0

1आधुनिक ब्राउज़रों के लिए आउटपुट जो Array.prototype.map का समर्थन करते हैं। आउटपुट0पुराने ब्राउज़रों पर । मैंने IE8 के साथ इसका परीक्षण किया।

पुराने नियमों के साथ: 0 अंक

लंबाई 26 - लंबाई का अंतर26

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

00000000000000000000000000आधुनिक ब्राउज़रों पर आउटपुट । और पुराने पर खाली स्ट्रिंग।

— nderscore
स्रोत
IE8 वास्तव में ES4 का समर्थन करता है ???
— बर्गी
मैं बल्कि हैरान था कि उन्होंने एक गैर-मौजूदा मानक कैसे लागू किया ...
— बर्गी
ओह! फिक्स्ड :)
— अंडरस्कोर
1

अजगर - ०

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

पायथन 2 एक क्वीन प्रिंट करता है, जबकि पायथन 3 प्रिंट कुछ भी नहीं करता है।

संपादित करें: अपडेट किया गया, ठीक किया गया।

— cjfaure
स्रोत
क्या आपका कंप्यूटर वास्तव में 2 सेकंड में ~ 9 बिलियन अंक प्रिंट कर सकता है?
— जेम्स वेबस्टर
@JamesWebster यह वास्तव में एक फ़ंक्शन का रिटर्न वैल्यू है - इस प्रकार, यह केवल प्रोग्राम को समाप्त करने के लिए मेमोरी में मौजूद होना चाहिए। इसके लिए एक बहुत / RAM की आवश्यकता होती है, लेकिन यह एक अच्छी तरह से-निर्देशित कंप्यूटर पर 2 सेकंड के भीतर समाप्त हो जाएगा।
— cjfaure
0

एपीएल (5 - (1988894 - 1) = -1988888)

पुरानी शैली के एपीएल में (जैसे डियालॉग अगर ⎕ML=0*), का ↑अर्थ है मिश्रण , जो 1-आयामी वेक्टर पर कुछ भी नहीं करता है। APL2- शैली के APL में, जैसे GNU APL, (या Dyalog if ⎕ML=3) का ↑अर्थ है , पहला , जो वेक्टर का पहला आइटम लेता है।

इस प्रकार, निम्नलिखित 5बाइट्स (एपीएल चारसेट करता है एक बाइट में फिट),

↑⍳3e5

1988894पुरानी शैली के एपीएल बोलियों में बाइट्स (1 से 3e5 तक संख्याओं की अलग-अलग सूची) का उत्पादन करेगा ,

और एपीएल 2-शैली एपीएल बोलियों में 1बाइट (उक्त सूची में पहला नंबर, जो 1लंबाई का है और इसलिए 1) है।

टिप्पणियाँ:

  • ⎕MLसाधन स्तर प्रवासन । Dyalog APL में, आप जितना अधिक सेट करते हैं ⎕ML, उतना ही APL2- शैली की विशेषताएं सक्षम होती हैं। यह करने के लिए चूक 0। (और यह एक वैश्विक चर है! मज़ा!)
  • 3e5उच्चतम 3-वर्ण मान Dyalog APL के साथ स्वीकार करेगा ⍳। 4e5मुझे दिया LIMIT ERROR। यह प्रतिबंध संभवतः दुभाषिया-निर्भर है। (GNU APL को उच्च मूल्यों से कोई परेशानी नहीं थी।)
— मारीनस
स्रोत
0

बैश 7 (14 बाइट्स प्रोग्राम की लंबाई + आउटपुट लंबाई में 0 अंतर - आउटपुट में अद्वितीय वर्णों में 7 अंतर)

@ गाइल्स उत्तर से संबंधित है, लेकिन एक अलग विस्तार सुविधा और विभिन्न संस्करण। संपादित प्रश्न के अनुसार स्कोरिंग:

echo {1..9..2}

बकवास 3.x के लिए आउटपुट:

{1..9..2}

बकवास 4.x के लिए आउटपुट:

1 3 5 7 9
— डिजिटल आघात
स्रोत
0

PHP: 42134217684 (43 - 134217727)

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

उपयोग: 

time php -r 'echo str_pad("",ip2long("")&0x7ffffff,"a");' > /tmp/test
1.61user 0.17system 0:01.79elapsed 99%CPU (0avgtext+0avgdata 142272maxresident)k
0inputs+0outputs (0major+35922minor)pagefaults 0swaps

PHP5 + में यह कुछ भी नहीं छापेगा क्योंकि ip2long अमान्य तर्क के साथ झूठे में बदल जाता है जो शून्य तक जाता है। PHP4 मेंip2long("") -1 देता है और हम खाली स्ट्रिंग को 128MB og के साथ पैड करते हैं a।

मास्क को फिट किया जाता है ताकि वह मेरी मशीन पर 2 सेकंड से पहले लौटे। यदि आप इसे 2s में नहीं बना सकते हैं तो बेहतर हार्डवेयर खरीदें!

नए नियमों के साथ: 0 (40 - 40. आप शून्य के करीब नहीं पहुंच सकते।)

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

आउटपुट: 

In PHP4: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 
In PHP5: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
— Sylwester
स्रोत
नए स्कोरिंग नियमों के साथ आपका स्कोर 39 है। दोनों आउटपुट समान रूप से लंबे हैं, इसलिए उसके लिए कोई जुर्माना नहीं है। लेकिन केवल एक अद्वितीय चरित्र अंतर है। a, b के बराबर नहीं है, इसलिए आपको अपने स्कोर से -1 घटाने की अनुमति है।
— फोब्बर
0

C89 / C99 टिप्पणी शोषण, 45 चरित्र, 0 स्कोर

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

c89 आउटपुट

QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|} - 45 चार।

c99 आउटपुट

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

— जॉनी केज
स्रोत
यह वास्तव में अन्य सी उत्तर के समान ही तर्क का उपयोग करता है ।
— user12205
मेरा मतलब है, इस तथ्य पर विचार करते हुए कि पहले से ही एक ही भाषा और सटीक एक ही तर्क का उपयोग करके इस प्रश्न का उत्तर है, यह उत्तर बहुत दिलचस्प नहीं है।
— user12205
यह प्रविष्टि कई स्तरों पर प्रारंभिक 'अन्य C उत्तर' से बेहतर है। यह छोटा है, स्कोर एकदम सही है, दो सेकंड के भीतर पूरा होता है, और दुर्घटना या गर्भपात नहीं करता है। जहाँ तक अद्यतन संस्करण ... निष्पक्षता में आपको शायद इस कोड को जोड़ने वाली टिप्पणी छोड़ देनी चाहिए।
— जॉनी केज
आपका उत्तर "प्रारंभिक" अन्य C उत्तर से बेहतर है क्योंकि अन्य C उत्तर को नियम परिवर्तन से पहले प्रस्तुत किया गया था।
— user12205
हो सकता है, लेकिन अपडेट किया गया संस्करण मेरे कार्यान्वयन को काटता है। न केवल यह एक ही ऑफसेट का उपयोग करता है और से स्विच printfकरता है putchar; सबसे ज्यादा नुकसान यह है कि r5 के लिए मैंने नियमों को गलत तरीके से फैलाया और गलती से नए और पुराने स्कोरिंग को जोड़ दिया। [R5, r6] के लिए आउटपुट एक त्रुटि है। अन्य C उत्तर में r3 में ठीक वही त्रुटि है। यदि आप टाइमस्टैम्प को देखते हैं, तो आप देखेंगे कि यह r5 था जिसे यहां पोस्ट किया गया था जब अन्य उत्तर अपडेट किया गया था। ऐसा नहीं है कि यह मायने रखता है, क्योंकि यह कोड गोल्फ है , और यह प्रविष्टि कम पात्रों, अवधि में चुनौती को संतुष्ट करती है।
— जॉनी केज
0

सी ++ 98 / सी ++ 11

#include <iostream>

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

C ++ 98 संकलक के अनुरूप मानक के लिए, यह 'x' अक्षर के 199711 गुणा का आउटपुट देता है, जबकि C ++ 11 संकलक के अनुरूप मानक के लिए, यह '103 'अक्षर के 201103 गुणा का आउटपुट देता है। इसलिए आउटपुट का लंबाई अंतर 1392 वर्ण है। इसका मतलब यह है कि वास्तव में स्रोत कोड को गोल्फ करना सार्थक नहीं है, क्योंकि बहुत अधिक प्रभाव केवल "x"लंबी स्ट्रिंग के साथ प्रतिस्थापित करके, या __cplusplusकुछ संख्या के साथ गुणा करके प्राप्त किया जा सकता है ।

— celtschk
स्रोत
0

SmileBASIC 3 / SmileBASIC 2, स्कोर: -5 (मूल स्कोरिंग)

?1E9

एसबी के आधुनिक संस्करणों में, यह 1000000000उम्मीद के अनुसार प्रिंट करता है, लेकिन संस्करण 2 में और पहले यह 10एक बग के कारण मुद्रित हुआ।

— 12Me21
स्रोत
0

टीआई-बेसिक 83 प्लस बनाम 84 प्लस, स्कोर 5-1 = 4

length("setTime(

2TI-83 प्लस पर आउटपुट , जहां एक ही प्रोग्राम को कुछ के रूप में पार्स किया जाता है जो दिखता है length("?►DMSक्योंकि setTime(कमांड अभी तक पेश नहीं किया गया था। तो स्ट्रिंग में दो 1-बाइट टोकन हैं, इसकी लंबाई 2 है।

1TI-84 प्लस पर आउटपुट , क्योंकि एक स्ट्रिंग जिसमें 2-बाइट टोकन के साथ लंबाई 1 है।

— मिशा लावरोव
स्रोत
0

जाओ 1.9-> 1.10। स्कोर = 1 - 1 = 0

से 1.10 नोट्स :

GOMAXPROCS सेटिंग पर अब कोई सीमा नहीं है। (गो 1.9 में सीमा 1024 थी।)

package main 
import (r"runtime")
var g=r.GOMAXPROCS
func main() {g(10340)
print(g(0))}

1.8: 256

1.9: 1024

1.10: 10340

— captncraig
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.