सांकेतिक गिनती

29

आपकी चुनौती कोड के एन स्निपेट्स को लिखना है, जैसे कि जब आप पहले के , 1 को एक साथ मिलाते हैं, तो वे संख्या K का उत्पादन करते हैं । उच्च एन , बेहतर। यहाँ पकड़ है: आप अपने स्निपेट्स में एक से अधिक बार किसी भी वर्ण का उपयोग नहीं कर सकते हैं।

नियम

  • आप एक ही (और केवल एक) स्निपेट में कई बार एक ही चरित्र का उपयोग कर सकते हैं।
  • इन स्निपेट्स को किसी भी लंघन के बिना, प्रस्तुत किए गए क्रम में संक्षिप्त किया जाना चाहिए ।
  • आपको कम से कम दो स्निपेट लिखना होगा।
  • सभी स्निपेट एक ही भाषा में होने चाहिए।
  • याद रखें: स्निपेट्स के लिए पूर्ण कार्यक्रम या फ़ंक्शन नहीं होते हैं, न ही उन्हें अपने आप से कार्य करना पड़ता है। -1जावा में एक वैध स्निपेट है, जैसे
  • सभी परिणामी निष्कर्षों को संबंधित K मान का उत्पादन करना चाहिए ।
  • विजेता सर्वोच्च एन मूल्य वाला व्यक्ति है । टाई-ब्रेकर बाइट्स में कम से कम समग्र कार्यक्रम की लंबाई है।

उदाहरण

मान लीजिए कि आपके के टुकड़े थे AD, xc, 123, और ;l। फिर:

  • AD उत्पादन करना चाहिए 1
  • ADxc उत्पादन करना चाहिए 2
  • ADxc123 उत्पादन करना चाहिए 3
  • और ADxc123;lउत्पादन करना चाहिए 4।

इस कार्यक्रम का स्कोर 4 होगा ।

number  code-challenge  source-layout 
— कोनोर ओ ब्रायन
स्रोत
4
चूंकि उन्हें स्निपेट बनना है, स्टैक-आधारित भाषा में, संख्याओं को केवल स्टैक पर धकेल दिया जा सकता है, है ना?
— 18
पूरी तरह से अमानवीय प्रश्न को जोड़ने के लिए, स्टैक-आधारित भाषा में केवल महत्वपूर्ण मान है जो मायने रखता है? यही है, क्या dc में पहले दो स्निपेट 1और `2` हो सकते हैं?
— ब्रुफ
@totallyhuman मैं नहीं कहूंगा - एक स्टैक आधारित वातावरण में, यदि आपके पास स्टैक पर कई मान हैं, तो आपने अनुरोधित एक पूर्णांक के बजाय एक से अधिक मूल्य का "उत्पादन" किया है।
— कॉनर ओ'ब्रायन
@brhfl ऊपर देखें
— कॉनर ओ'ब्रायन
@ ConorO'Brien क्या स्टैक के शीर्ष को आउटपुट माना जा सकता है? 'क्योंकि अन्यथा, यह बिना किसी निहित IO के साथ एक स्टैक-आधारित भाषा में व्यावहारिक रूप से असंभव है ...
— बिलकुल अमानवीय

जवाबों:

10

पायथन 3 , 1 112 056 स्निपेट, 4 383 854 बाइट्स

यह @ WheatWizard के पाइथन 2 उत्तर के समान है । मैंने इसे पोस्ट करने से कुछ समय पहले ही काम करना शुरू कर दिया था, लेकिन गैर-एएससीआईआई के पात्रों और लंबी लाइनों के बारे में अजगर के झगड़े को हल करने में कुछ समय लगा। मुझे पता चला कि पायथन एक समय में 8191 बाइट्स पढ़ता है, और जब उन 8191 बाइट्स में एक बहु-बाइट चरित्र का केवल एक हिस्सा होता है, तो पायथन एक सिंटैक्सएयर को फेंक देता है ।

पहला स्निपेट ट्यूरिंग कम्प्लीटनेस के लिए फ्यूवेस्ट (अलग) वर्णों से एन्कोडिंग का उपयोग करता है ।

exec('%c'%(111+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(111+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(111)+'%c'%(111+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1)+'%c'%(11+11+11+11+1+1+1+1+1)+'%c'%(11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11)+'%c'%(11+11+11+11+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1++++++++++1))

यह संकीर्णता बस निम्नलिखित तार का निर्माण करती है और इसे निष्पादित करती है।

print(len(open(__file__).read())-1260)

निम्नलिखित स्निपेट बिल्कुल एक वर्ण लंबे होते हैं। अगले तीन अक्षर हैं \n, \r, और #। सभी शेष यूनिकोड वर्ण (सरोगेट्स को छोड़कर) एक विशिष्ट क्रम में चलते हैं, इसलिए वे 8191-बाइट सीमा के साथ संरेखित होते हैं।

निम्न स्क्रिप्ट 1 और 1112056 के बीच इनपुट k के लिए उपयुक्त प्रोग्राम बनाता है ।

j = 4
s = "exec('%c'%(111+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(111+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(111)+'%c'%(111+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1)+'%c'%(11+11+11+11+1+1+1+1+1)+'%c'%(11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11)+'%c'%(11+11+11+11+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1++++++++++1))"
l = 1
c = \
        [
                None,
                [n for n in range(0x80) if chr(n) not in "\n\r#%'()+1cex"],
                [*range(0x80, 0x800)],
                [*range(0x800, 0xd800), *range(0xe000, 0x10000)],
                [*range(0x10000, 0x110000)]
        ]

k = int(input())
assert k in range(1, 1112057)
s += '\n\r#'[:k - 1]
k -= 4

while j:
                while k > 0 and c[j] and l + j < 8191:
                        s += chr(c[j].pop())
                        l += j
                        k -= 1
                if k < 1:
                        print(end = s)
                        break
                elif c[j] == []:
                        j -= 1
                else:
                        s += chr(c[8191 - l].pop())
                        print(end = s)
                        k -= 1
                        s = ''
                        l = 0
— डेनिस
स्रोत
4
क्या आप कभी हारते हैं?
— पैट्रिक रॉबर्ट्स
मैं असमंजस में हूँ कि आपने 256 से अधिक अंक कैसे बनाए हैं। क्या अलग-अलग यूनिकोड वर्ण अलग-अलग वर्ण हैं? यदि ऐसा है तो अनंत स्कोर प्राप्त करने के लिए डायक्टिक्स के संयोजन का उपयोग क्यों नहीं किया जाता है?
— गेहूं जादूगर
— डेनिस
ऐसा लगता है कि उस परिभाषा से आप उच्च स्कोर प्राप्त करने के लिए डायक्ट्रीक्स के संयोजन का उपयोग कर सकते हैं।
— गेहूं जादूगर
@WheatWizard नहीं, एक अक्षर प्लस एक संयोजन डियाक्रिटिक दो यूनिकोड वर्ण हैं।
— डेनिस
13

पर्ल 5, 50,091 151 स्निपेट

पहला स्निपेट:

use utf8; print length A

26 वें स्निपेट के माध्यम से 2: के Bमाध्यम सेZ

27 वें 46 वें स्निपेट के aमाध्यम से : z"लंबाई" में वर्णों को छोड़कर

47 वें 56 वें स्निपेट्स के 0माध्यम से : के माध्यम से9

57 वाँ स्निपेट: _

शेष स्निपेट्स 50,105 व्यक्तिगत यूनिकोड वर्ण हैं जो पर्ल किसी भी क्रम में प्रारंभिक स्निपेट में 14 अलग-अलग शब्द वर्णों को छोड़कर "शब्द" वर्णों के रूप में मानते हैं।

खैर, यह एक अच्छा विचार था, लेकिन यह पता चला है कि एक निश्चित लंबाई के बाद पर्ल आपको "पहचानकर्ता बहुत लंबा" त्रुटि देता है। यह सबसे लंबा संयुक्त कार्यक्रम है जिसे मैं पेल को पचाने में सक्षम था:

use utf8; print length A012345679BCDEFGHIJKLMNOPQRSTUVWXYZ_abcdjkmoqsvwxyzĀāĂ㥹ĆćĈĉĊċČčĎďĐđĒēĔĕĖėĘęĚěĜĝĞğĠġĢģĤĥĦħĨĩĪīĬĭĮįİıIJijĴĵĶķĸĹĺĻļĽľĿŀŁłŃńŅņŇňʼnŊŋŌōŎŏŐőŒœŔŕŖŗŘřŚśŜŝŞşŠšŢţ

पेर्लिगैग मैनुअल पेज का कहना है कि "पर्ल के भविष्य के संस्करण इन मनमानी सीमाओं को खत्म करने की संभावना है" लेकिन मेरे पर्ल 5.18 ने ऐसा नहीं किया है।

स्पष्टीकरण:

गैर-सख्त मोड में, पर्ल 5 "वर्णों" के रूप में शब्द वर्णों के रेखांकित तारों की व्याख्या करता है, अनिवार्य रूप से उन्हें स्वचालित रूप से आपको उद्धृत करता है। वे आमतौर पर सबसे अच्छा बचा रहे हैं, लेकिन वे यहाँ मदद सुनिश्चित करें!

— शॉन
स्रोत
4
आपके a-zस्निपेट आपके पहले स्निपेट के पात्रों का उपयोग करने की सबसे अधिक संभावना है।
— जोनाथन फ्रेच
हाँ, वास्तव में, धन्यवाद। फिक्स्ड।
— शॉन
मेरा सुझाव है कि आप एक "शोकेस" जैसा उत्तर दें, क्योंकि लगभग सभी (एक्सो) लंग्स - जेली, अजगर, आदि - यह व्यवहार है
— रॉड
मुझे नहीं पता कि "शोकेस जैसा जवाब" का क्या मतलब है।
— सीन
1
@ सीन प्लेंटी को esolangs.org पर पाया जा सकता है, और क्योंकि इस दृष्टिकोण को काम करने के लिए पूरी तरह से समझ की आवश्यकता नहीं है, आप सीख सकते हैं कि आपको साइट से क्या चाहिए। इसके अलावा, कई गैर-एसोलांग इस व्यवहार को प्रदर्शित करते हैं; उदाहरण के लिए, TI-BASIC का पहला स्निपेट होगा length("length(।
— खुल्द्रेसथ ना'बरिया
10

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

for r in range(32):locals()[''.join(map(chr,range(65,66+r)[:26]+range(117,92+r)))]=r+1
print A

बाद के टुकड़े के साथ B, C, D, ... Y, Z, u, v, w, x, y, z।

नाटकीय विडंबना के एक मोड़ में, पायथन 3 यूनिकोड पहचानकर्ताओं का समर्थन करता है, जो हमें इस चाल के साथ बहुत मूर्खतापूर्ण मिलेगा - लेकिन यह printबिना कोष्ठक के नहीं हो सकता । मैं पहचानकर्ता में भी अंकों को रट सकता हूं, लेकिन मुझे नहीं लगता कि इस दृष्टिकोण को अधिक से अधिक निचोड़ने के लिए बहुत मजेदार है।

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

पायथन 2 , स्कोर 18, कम धोखा-वाई

print 0x10-1&0x1
print 0x10-1&0x12
print 0x10-1&0x123
print 0x10-1&0x1234
print 0x10-1&0x12345
print 0x10-1&0x123456
print 0x10-1&0x1234567
print 0x10-1&0x12345678
print 0x10-1&0x123456789
print 0x10-1&0x123456789A
print 0x10-1&0x123456789Ab
print 0x10-1&0x123456789Abc
print 0x10-1&0x123456789Abcd
print 0x10-1&0x123456789AbcdE
print 0x10-1&0x123456789AbcdEf
print 0x10-1&0x123456789AbcdEf^((()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==()))
print 0x10-1&0x123456789AbcdEf^((()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==()))|[[[]]>[]][[]>[]]
print 0x10-1&0x123456789AbcdEf^((()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==()))|[[[]]>[]][[]>[]]<<False**False

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

— लिन
स्रोत
10

जावास्क्रिप्ट (ES6, वी 8 6.x), 52 50,298 119,526 119,638 119,683 128,781 टुकड़े, 88 149,147 575,179 575,631 576,121 612,789 बाइट्स

नीचे दिया गया ढेर एक स्टैक स्निपेट है जो पूरा कार्यक्रम बनाता है, उसका मूल्यांकन करता है, और फ़ाइल के लिए एक डाउनलोड लिंक बनाता है। यह स्निपेट बेहतर उत्तर उत्पन्न करना जारी रखेगा क्योंकि यूनिकोड के बाद के संस्करणों को जावास्क्रिप्ट के नए संस्करणों द्वारा समर्थित किया जाता है, जो भाषा में नए वैध पहचानकर्ताओं को जोड़ते हैं।

केवल ASCII का उपयोग करना

console.log(new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn$$00112233445566778899AABBCCDDEEFFGGHHIIJJKKLLMMNNOOQQRRSSTTUUVVWWXXYYZZ__aabbccddffiijjkkmmppqqssuuvvzz)
स्निपेट का विस्तार करें

व्याख्या

यह ऑब्जेक्ट पर Proxyएक हैंडलर जाल को सक्षम करने के लिए मेटाप्रोग्रामिंग तकनीक का उपयोग करता है और पहचानकर्ता के length / 2मान के रूप में वापस करते हुए, एक स्ट्रिंग के रूप में प्रॉपर्टी नाम तक पहुंचता है ।

पहले स्निपेट के रूप में शुरू होने के साथ new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn, प्रत्येक अतिरिक्त स्निपेट ने 2 बाइट utf-16 वर्णों के लिए संबंधित कोड बिंदु पर दो बार सुनिश्चित करके और 4 बाइट utf-16 वर्णों के लिए एक बार सुनिश्चित करके lengthपहचानकर्ता के स्ट्रिंग को बढ़ाया।2.repeat()

जावास्क्रिप्ट में पहचानकर्ता

में ECMAScript विशिष्टता , एक IdentifierNameनिम्नलिखित व्याकरण के साथ परिभाषित किया गया है:

IdentifierName::
  IdentifierStart
  IdentifierName IdentifierPart

IdentifierStart::
  UnicodeIDStart
  $
  _
  \UnicodeEscapeSequence

IdentifierPart::
  UnicodeIDContinue
  $
  _
  \UnicodeEscapeSequence
  <ZWNJ>
  <ZWJ>

UnicodeIDStart::
  any Unicode code point with the Unicode property “ID_Start”

UnicodeIDContinue::
  any Unicode code point with the Unicode property “ID_Continue”

उत्तर उत्पन्न करना

प्रारंभ में "ID_Continue" यूनिकोड संपत्ति का उपयोग करते हुए, मैंने एक Node.js स्क्रिप्ट लिखी जो पूर्ण उत्तर उत्पन्न करती है। अब यह सिर्फ एक क्लाइंट-साइड स्क्रिप्ट है जो eval()वैध पात्रों के लिए परीक्षण करने के लिए एक भोली का उपयोग करता है , इसके बजाय सभी यूनिकोड कोड बिंदुओं के माध्यम से पुनरावृत्ति करता है:

// first snippet
let answer = 'new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn'

const used = Array.from(
  answer,
  c => c.codePointAt(0)
).sort(
  (a, b) => a - b
)

// create a O(1) lookup table for used characters in first snippet
const usedSet = Array.from(
  { length: Math.max(...used) + 1 }
)

for (const codePoint of used) {
  usedSet[codePoint] = true
}

// equal to 1 for first snippet
let snippets = eval(answer)
let identifier = ''

for (let codePoint = 0, length = 0x110000; codePoint < length; codePoint++) {
  const character = String.fromCodePoint(codePoint)

  // if unused
  if (usedSet[codePoint] === undefined) {
    // if valid `IdentifierPart`
    try {
      eval(`{let _${character}$}`)
    } catch (error) {
      // console.log(character)
      continue
    }

    // repeat so that `snippet.length === 2`
    identifier += character.repeat(2 / character.length)
    snippets++
  }
}

// number of snippets generated
console.log(`snippets: ${snippets}`)

const program = `console.log(${answer + identifier})`

// output of program to validate with
eval(program)

// download link to check number of bytes used
dl.href = URL.createObjectURL(new Blob([program], { type: 'text/javascript' }))
<a id=dl download=answer.js>Click to Download</a>
स्निपेट का विस्तार करें

रनिंग stat -f%z answer.jsमें 612802 की बाइट गिनती होती है, लेकिन हम वास्तविक सबमिशन को लपेटने console.log(और )लपेटने के लिए 13 बाइट्स घटाते हैं ।

एन्कोडिंग

स्रोत को utf-8 के रूप में संग्रहीत किया जाता है, जो उत्तर की विशाल बाइट की संख्या में परिलक्षित होता है। ऐसा इसलिए किया जाता है क्योंकि Node.js केवल utf-8 में एन्कोड की गई स्रोत फ़ाइलों को चला सकते हैं।

जावास्क्रिप्ट आंतरिक रूप से utf-16 एन्कोडिंग के साथ तारों को संग्रहीत करता है, इसलिए स्ट्रिंग "चरित्र की लंबाई" जो कि जावास्क्रिप्ट में लौटी है वास्तव में utf-16 में एन्कोडेड स्ट्रिंग के बाइट्स की संख्या से आधी है।

— पैट्रिक रॉबर्ट्स
स्रोत
एक अतिरिक्त पहचानकर्ता चरित्र के रूप में इसे मुक्त xकरने के बजाय , इसका उपयोग क्यों करें $?
— नील
@ नील मुझे लगता है कि थोड़ी देर पहले। मैं वर्तमान में एक उत्तर पर काम कर रहा हूं जो ~ 119519 का स्कोर होना चाहिए। अभी मैं इसे ठीक से एन्कोडिंग ठीक करने के एक मामले के लिए मिल गया है।
— पैट्रिक रॉबर्ट्स
मैंने Spidermonkey JS शेल की एक प्रति की कोशिश की, जो कि मेरे आसपास पड़ा था। इसने केवल 50466 विभिन्न पहचानकर्ता पात्रों का समर्थन किया। (जब से आप अपने प्रारंभिक स्निपेट में 12 का उपयोग करते हैं, तो आपका स्कोर 50455 है।)
— नील
खैर, एक बड़ा ओवर किए बिना, ऐसा लग रहा है कि स्कोर 50297 होना चाहिए। अब जवाब लिखना। स्पष्ट होने के लिए, ES6 + में यूनिकोड 10.0.0 विनिर्देश का उपयोग करके वास्तव में 128,096 समर्थित पहचानकर्ता हैं, लेकिन उनमें से, केवल आपके द्वारा बताई गई संख्या की तार की लंबाई 1. है अन्यथा यह एक स्ट्रिंग वर्ण गणना प्राप्त करने के लिए बहुत अधिक कठिन है, और यही मैं पर लटका हुआ था।
— पैट्रिक रॉबर्ट्स
1
@PatrickRoberts क्षमा करें, मेरी गलती है, इसे पढ़ते हुए मैंने सभी पाठ को तब तक ग्रहण किया जब तक कि अंत में केवल पाठ को पार नहीं किया गया। मेरी आँखें उस हिस्से पर फिसल गई होंगी।
— कॉनर ओ'ब्रायन
6

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

+3 व्हीज़वॉडर के लिए pizzapants184
+1 के लिए धन्यवाद

4/4
*2
-~0
+1
|5
^3
&776%6
and 8
if[]else[9][9>9]
.__xor__((""=="").__xor__((""=="")<<(""=="")))

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

— छड़ी
स्रोत
यदि आप print int(True)बस में बदल जाते हैं 4/4, तो आप and 77 के लिए जोड़ सकते हैं , यह देखते हुए कि आपको संख्या को प्रिंट करने की ज़रूरत नहीं है, बस इसे 'उत्पादन' करें
— pizzapants184
— pizzapants184
जोड़ने &2से आपके स्कोर में एक वृद्धि होगी क्योंकि &इसकी पूर्वता अधिक है ^, लेकिन आपको किसी भी तरह संख्या 2 बनाने की आवश्यकता है। (आप उपयोग कर सकते हैं [[]==[]][[]<[]]<<[[]==[]][[]<[]])
— गेहूं जादूगर
1
@ pizzapants184 10 के
— गेहूं जादूगर
1
@ pizzapants184 ordके साथ संघर्ष कर andरहा था , लेकिन मैंने तय किया कि
— रॉड
6

TI-Basic (83 श्रृंखला, OS संस्करण 1.15 या उच्चतर), स्कोर: 17 18 19 24

(टाईब्रेकर: 53 बाइट्स)

आप हमेशा की तरह स्ट्रिंग की लंबाई को गाली देकर एक बहुत बड़ा स्कोर प्राप्त कर सकते हैं: (@Scrooble बिंदुओं के रूप में) के साथ शुरू करें और अंत तक एकल-टोकन स्निपेट को जोड़ते रहें। टीआई-बेसिक के पास 700 से अधिक हैं, ताकि वास्तव में बहुत अच्छी तरह से काम करता है। लेकिन यहाँ एक और दृष्टिकोण है:length("A length("length(

int(log(11
2
3
4
5
6
7
8
9
0
Xmax
Ymax
nMax
abs(Xmin
Ymin
ππ
eee
³
²
₁₀^(₁₀^(X
+e^(⁻e^(Y))))
/√(sub(Z!
°
randrandrand

ध्यान दें कि TI-बेसिक tokenized है, इसलिए (उदाहरण के लिए) e^(आदेश वर्णों के किसी भी उपयोग नहीं करता है e, ^, (।

sub(आदेश की एक अनैच्छिक सुविधा पर निर्भर करता है : सबस्ट्रिंग खोजने के अलावा, इसका उपयोग किसी संख्या को 100 से विभाजित करने के लिए भी किया जा सकता है।

यह काम करता है अगर यह एक ताजा कैलकुलेटर, जो देता है पर चल रहा है हमें लगता है कि X, Y, Zसब शून्य कर रहे हैं, उस खिड़की चर उनके मानक मूल्यों की तैयारी में हैं, कि कैलकुलेटर रेडियन मोड में है, और उस randके पहले तीन outputs के बारे में हो जाएगा 0.943, 0.908, 0.146।

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

पॉवरशेल , 25 बाइट्स, स्कोर 5

' '.count*2+!""-(-1)|%{5}

स्निपेट 1: ' '.countआउटपुट 1। यह .countएक स्ट्रिंग को ले कर ऐसा करता है , जो एक है क्योंकि केवल एक स्ट्रिंग है। इसे ऑनलाइन आज़माएं!

स्निपेट 2: *2आउटपुट 2क्योंकि हम 1पिछले स्निपेट से लेते हैं और इसे दो से गुणा करते हैं इसे ऑनलाइन आज़माएं!

स्निपेट 3: बूलियन को जोड़कर +!""आउटपुट देता 3है-खाली स्ट्रिंग का नहीं। यह स्पष्ट रूप से खाली स्ट्रिंग को $trueकास्ट करता है, जिसे फिर से अनुमानित रूप से डाला जाता है 1, इसलिए हम एक जोड़ रहे हैं इसे ऑनलाइन आज़माएं!

स्निपेट 4: केवल नकारात्मक घटाकर -(-1)आउटपुट ऑनलाइन प्रयास करें!4

स्निपेट 5: पिछले नंबर को एक लूप में ले जाकर |%{5}आउटपुट 5और उस लूप के प्रत्येक पुनरावृत्ति (केवल एक, क्योंकि केवल एक इनपुट नंबर है) आउटपुट 5 इसे ऑनलाइन आज़माएं!

जनवरी के साथ आने के वैकल्पिक साधनों 4और साथ आने के एक चालाक तरीके के लिए धन्यवाद 5।

— AdmBorkBork
स्रोत
' '.count*2+!""-(-1)|%{5}5 के स्कोर के लिए कैसे ?
— जनवरी
@ ओह, ठीक है, हाहा, आपको वास्तव में $_अंदर उपयोग करने की आवश्यकता नहीं है |%{ }। धन्यवाद!
— AdmBorkBork
4

सी, 10 स्निपेट, 45 बाइट्स

sizeof(char)              // sizeof(char) = 1
<<9/9                     // Multiply by two.
|1                        // 2 or 1 = 3
,4                        // Discard previous expression, return 4.
+!!8                      // Add one.
^3                        // 5 xor 3 = 6
&66                       // 3 and 66 = 2, 5 xor 2 = 7 (& has higher precedence)
??'0xF                    // Trigraph for '^'. 7 xor 15 = 8
-~-2                      // ~-2 = 1, 7 xor 14 = 9
*57%5                     // 1*57%5 = 2, 7 xor 13 = 10

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

— Steadybox
स्रोत
4

MATL , स्कोर 8 15, 64 123 बाइट्स

rg             % 1 Random number, make boolean (1)
Q              % 2 Increment
Yq             % 3 Nth prime
a,E]           % 4 any (convert to boolean 1. Do twice: Multiply by 2
T+             % 5 Add True
F~_-           % 6 Subtract negative (not(false)) = 6-(-1)
:sI/           % 7 Range 1:6, sum (21), divide by 3
A8*            % 8 All elements (True). Multiply by 8
d9             % 9 Clear stack, push 9
x10            % 10 Clear stack, push 10
WBPf           % 11 Raise 2^10. Convert to binary [1 0 ... 0], flip [0 0 ... 1]. Find
23ZP           % 12 Push 23, and calculate the distance between 11 and 23
yyyyyyyyyyyyyyyyyyyyyyyyhhhhhhhhhhhhhhhhhhhhhhhhz  % 13. Duplicate and count elements
tttttttttttttvvvvvvvvvvvn  % 14 Duplicate and count elements
OOOOOOOOOOOOOON&           % 15 Add bunch of zeros, output size of stack
  • लुइस मेंडो की मदद से 12 हो गया! स्निपेट 7 के लिए 11,23ZPबदलने के 3साथ , उसका विचार का उपयोग करना था I।
  • लुइस से अधिक मदद के साथ 15 को मिला। OO...N&उसका विचार था।

और भी आने को है। मैं MATL फ़ंक्शंस को दिल से नहीं जानता, इसलिए मुझे प्रलेखन में आगे और पीछे जाना पड़ा ... :)

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

— स्टीवी ग्रिफिन
स्रोत
ऊह, 5Yyअच्छा है! मैं पहले से ही Y3 का उपयोग दूसरा प्रधान पाने के लिए करता हूं :(
— स्टीवी ग्रिफिन
मुझे लगता है कि आप एक और के साथ मिल सकते हैं OOOOOOON&। यदि आप दूसरों को जोड़ते हैं, तो संभवतः यह आखिरी होना चाहिए, क्योंकि&
— लुइस मेंडो
धन्यवाद फिर से लुइस! इसके अलावा, मुझे कई सू की आवश्यकता क्यों थी yyyyyyyy...? मुझे संख्या दोगुनी करनी थी, 24 yइसे 12 बार दोहराया गया?
— स्टीवन ग्रिफिन
@Stewie मुझे लगता है कि यह इसलिए है क्योंकि आप जिन आधे तत्वों की नकल कर रहे हैं वे खाली सरणी द्वारा उत्पन्न होते हैं d। मैं अभी मोबाइल पर हूं, लेकिन X#स्टैक को डिबग-प्रिंट करने की कोशिश करता हूं
— लुइस मेंडो
2

जेली , 253 बाइट्स, स्कोर 250

L}“L

बाद में 1-चार स्निपेट:

¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑ×ØŒÞßæçðıȷñ÷øœþ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|~¶°¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḤỊḲḶṂṆỌṚṢṬỤṾẈỴẒȦḂĊḊĖḞĠḢİĿṀṄȮṖṘṠṪẆẊẎŻạḅḍẹḥịḳḷṃṇọṛṣṭụṿẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż

नोट: इन्हें भी बदला जा सकता है \n, वे जेली के कोडपेज में एक ही बाइट हैं।

जब आप उन सभी स्निपेट्स को जोड़ देंगे, तब आप 2-चार स्निपेट को जोड़ सकते हैं ”‘।

+1 डेनिस को धन्यवाद ।

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

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

पेंगुएज , 1 112 064 स्निपेट

N वें टुकड़ा के होते हैं 2 3n -1 की पुनरावृत्ति n वें गैर सरोगेट यूनिकोड वर्ण, अप करने के लिए और सहित 1 112 064 वें और वर्तमान यूनिकोड मानक के अंतिम गैर सरोगेट चरित्र।

आउटपुट सादगी के लिए एकात्मक (शून्य बाइट को अंक के रूप में उपयोग) में है। दशमलव संभव है, लेकिन यह कार्यक्रमों को और भी लंबा कर देगा। यूनीरी के साथ, हम पहले कार्यक्रमों का परीक्षण कर सकते हैं।

के लिए n = 1 , हम पाते हैं 4 की पुनरावृत्ति U + 0000 । यह ब्रेनफक प्रोग्राम के बराबर है ., जो एक नल बाइट प्रिंट करता है।

के लिए n = 2 पर हम पाते हैं 32 की पुनरावृत्ति U + 0001 , के लिए कुल 36 अक्षर। यह ब्रेनफक प्रोग्राम के बराबर है .., जो दो नल बाइट प्रिंट करता है।

के लिए n = 3 पर हम पाते हैं 256 की पुनरावृत्ति U + 0002 , के लिए कुल 292 अक्षर। यह ब्रेनफक प्रोग्राम के बराबर है ..., जो तीन नल बाइट प्रिंट करता है।

और आगे, n = 1 112 064 तक ।

— डेनिस
स्रोत
क्या आप दशमलव में समतुल्य प्रदर्शित या तर्क कर सकते हैं? मुझे एकतरफा आउटपुट पर सर्वसम्मति के बारे में यकीन नहीं है, लेकिन मेरा मानना ​​है कि यह उन भाषाओं के लिए है जिनमें दशमलव की अवधारणा का अभाव है- कम से कम, आखिरी बार मैंने जाँच की थी
— कॉनर ओ'ब्रायन
मेरा मानना ​​है कि यह उन भाषाओं के लिए है जिनमें दशमलव हाँ की अवधारणा का अभाव है , और चूंकि पेंग्वेज़ में दशमलव I / O नहीं है, मैंने माना कि यह ठीक था। वैसे भी, n के'+'*(48 + d) +'.>' प्रत्येक दशमलव अंक के लिए ब्रेनफक प्रोग्राम को एन्कोडिंग करने से समान स्कोर प्राप्त होगा। यह वर्णन करना बहुत कठिन है।
— डेनिस
समझा। एक ही बात बस लंबे समय तक।
— कॉनर ओ'ब्रायन
2

बेसिक (ZX स्पेक्ट्रम), स्कोर 244 (नया स्कोर 247) [क्या यह धोखा है?]

स्निपेट 1:

2356 PRINT PEEK (PEEK 23635+256*PEEK 23636+2)+256*PEEK (PEEK 23635+256*PEEK 23636+3)-56-66

स्निपेट 2: :

स्निपेट 3: REM

स्निपेट्स 4-244: सिंगल-कैरेक्टर स्निपेट्स, सभी पात्रों का उपयोग करके स्निपेट्स 1, 2 और 3 में नहीं।

व्याख्या

वर्ण

स्पेक्ट्रम पर, PRINTएक एकल वर्ण (कोड 245) है। 1 का उपयोग करता है झलकी 11 विभिन्न पात्रों: 2, 3, 5, 6, +, -, *, (, ), PRINTऔर PEEKआप क्या देखेंगे के रूप में अंतराल वर्णों का एक हिस्सा हैं PRINTऔर PEEK, इसलिए अंतरिक्ष में ही उपयोग नहीं किया गया। मैंने लाइन नंबर 2356 देने का फैसला किया क्योंकि ये कोड में मौजूद एकमात्र अंक हैं।

13 और 14 वर्णों की अनुमति नहीं है। इसका मतलब है कि स्निपेट्स 2-244 के लिए 243 वर्ण बचे हैं, जिससे शुरू होता है :और REMउस कोड से बचने के लिए जो त्रुटि पैदा करेगा या कुछ और करेगा।

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

यही कारण है कि मुझे यकीन नहीं है कि यह उत्तर पुस्तक द्वारा दिया गया है।

23635 16-बिट सिस्टम चर PROG के लिए स्मृति स्थान है, जिसे LH के रूप में संग्रहीत किया जाता है। (मान आमतौर पर 23755 है। लेकिन गलत परिणाम के अलावा अगर ऐसा नहीं होता है, तो इस संख्या का सीधे उपयोग करते हुए, भले ही यह कोड को छोटा कर दे, मुझे अतिरिक्त अंकों के पात्रों का खर्च करना होगा।) PROG का मान स्मृति स्थान है। जहां कार्यक्रम ही संग्रहीत है। पहले दो बाइट्स एचएल के रूप में संग्रहीत लाइन नंबर हैं, निम्नलिखित दो बाइट्स एलएच के रूप में संग्रहीत लाइन की लंबाई हैं। इस तरह से यह कार्यक्रम अपनी स्वयं की रेखा की लंबाई को देखता है, इसलिए कुछ उपयुक्त होने की जरूरत है

पात्रों को सहेजना

यह देखते हुए कि संख्याओं को कैसे संग्रहीत किया जाता है, -114 के साथ लाइन समाप्त हो सकती थी ताकि स्निपेट 1 का उत्पादन हो सके। लेकिन मैं अतिरिक्त अंकों का उपयोग नहीं करना चाहता था, इसलिए मैंने दो 2-अंकीय संख्याओं को निकाल लिया, जिसे तब जोड़ना था से 122; 56 और 66 ने अच्छा प्रदर्शन किया।

कोड सभी घोंसले के शिकार और PROG ( PEEK 23635+256*PEEK 23636) के दो बार गणना मूल्य के साथ थोड़ा बदसूरत है । लेकिन अगर मैं इसे संग्रहीत करता हूं और फिर संग्रहीत मूल्य का उपयोग करता हूं, तो इसके लिए अतिरिक्त वर्ण / स्निपेट खर्च होंगे - लाइन शुरू हो सकती है

2356 LET p=PEEK 23635+256*PEEK 23636: PRINT PEEK (s+2)...

जो 4 अतिरिक्त वर्ण का प्रयोग करेंगे: LET, p, =और :।

हो सकता है कि मैं इसे इंजीनियर करूं ताकि सभी संख्याओं की गणना उन अंकों से की जाए जो केवल 1 अंक का उपयोग करते हैं और 3 स्निपेट प्राप्त करते हैं।

संपादित करें:

यहां नया स्निपेट 1 दिया गया है (यह कि स्पेक्ट्रम पर एक लंबी सिंगल लाइन कैसे लपेटी जाती है, इसलिए यदि आप कोड का परीक्षण करना चाहते हैं, तो इससे आपको यह देखने में मदद मिलेगी कि आपने इसे सही तरीके से टाइप किया है):

1111 PRINT +PEEK (PEEK (11111+11
111+1111+(1+1+1)*(111-11)+1+1)+(
111+111+11+11+11+1)*PEEK (11111+
11111+1111+(1+1+1)*(111+1-11))+1
+1)+(111+111+11+11+11+1)*PEEK (P
EEK (11111+11111+1111+(1+1+1)*(1
11-11)+1+1)+(111+111+11+11+11+1)
*PEEK (11111+11111+1111+(1+1+1)*
(111+1-11))+1+1+1)-111-111-111-1
11-111-111

मैं से बचने के द्वारा एक और स्निपेट हासिल कर सकता था +और बस कर सकता था -। मैं इसे आज़माने नहीं जा रहा हूँ, यह एक परीक्षा के लिए पर्याप्त था।

— Heimdall
स्रोत
2

क्लेन 011 , 9 स्निपेट

स्निपेट 1

!@1!aaaaaaaaaaaaaaaaaaaaa/a

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

स्निपेट 2

2((2|bbb0b2bbbb4bbbbbbbb

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

स्निपेट 3


c\*3ccccccccccccccccccccc\ccccccccc3c6cccc9
c\

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

स्निपेट 4

ddddddddddddddddddddddd>$d:d:++-$:+:+++$:?:-$-+++

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

स्निपेट 5

ee

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

स्निपेट 6

fff

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

स्निपेट 7

ggggg

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

स्निपेट 8

hh

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

स्निपेट 9

iiiii

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

व्याख्या

यह क्लेन के लिए एक बहुत ही मजेदार चुनौती थी। क्लेन की अनूठी टोपोलॉजी बहुत सारे दिलचस्प सामानों के लिए अनुमति देती है। जैसा कि आप जवाब देख सकते हैं 5-9 बस भराव जोड़ रहे हैं (पत्र क्लेन में कुछ भी नहीं करते हैं, इसलिए मैंने बाउंडिंग बॉक्स को बाहर निकालने के लिए कोड के लिए उन्हें भराव के रूप में इस्तेमाल किया)। यह कोड को क्लेन के अद्वितीय टोपोलॉजी के कारण कोड के पूर्व भागों के माध्यम से एक अलग रास्ता लेने का कारण बनता है।

मैं बाद में एक पूरी व्याख्या करने जा रहा हूँ, लेकिन अब यहाँ प्रोग्राम को समझने के लिए सभी अक्षरों के साथ संस्करण को समझना आसान है .।

!@1!...................../.2((2|...0.2....4........
.\*3.....................\.........3.6....9
.\.......................>$.:.:++-$:+:+++$:?:-$-+++.................

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

— गेहूं का जादूगर
स्रोत
2

> <> , स्कोर: इन्फिनिटी 1,112,064-6 = 1,112,058

स्निपेट 1 (6 बाइट्स)

"l4-n;

इस स्निपेट के बाद वर्णों की मात्रा को आउटपुट करता है; एक और। यह प्रत्येक चरित्र के स्निपेट्स के अनंत बहुत बड़ी मात्रा में बढ़ाया जा सकता है । एक त्वरित Google मुझे बताता है कि 1,112,064 संभव यूनिकोड वर्ण हैं, माइनस 6 जो मैंने पहले ही उपयोग किया है।

यह ऑनलाइन की कोशिश करो

— मजाक कर रहा है
स्रोत
1

आर , स्कोर: 79

प्रेरणा के लिए शॉन के पर्ल जवाब का श्रेय ; यह आर दुभाषिया के कुछ quirks का दुरुपयोग करता है।

पहला स्निपेट:

nchar(scan(,""))
a

इसके बाद के स्निपेट इस प्रकार हैं:

bdefgijklmopqtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`~!@$%^&*_+|\[]{}:?><;

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

scanसमारोह फ़ाइल से डेटा पढ़ता है ""जो करने के लिए चूक stdin()।

stdin()इंगित करने के लिए डॉक्स :

जब R किसी फ़ाइल से स्क्रिप्ट पढ़ रहा होता है, तो फ़ाइल 'कंसोल' होती है: यह इन-लाइन डेटा (उदाहरण के लिए 'एन इंट्रोडक्शन टू आर' देखने की अनुमति देने के लिए पारंपरिक उपयोग है)।

इसलिए, बाद के डेटा फ़ाइल बन जाते हैं। यह तुच्छ रूप से विस्तारित किया जा सकता है, और कई अलग-अलग एन्कोडिंग के साथ काम कर सकता है।

— ग्यूसेप
स्रोत
1

पाइके , 256 बाइट्स, स्कोर 254

कृपया ध्यान दें कि ये वास्तविक बाइट्स के हेक्स कोड हैं, जिन्हें रिक्त स्थान द्वारा अलग किया गया है, क्योंकि इसमें नल बाइट ( \x00) शामिल है।

स्निपेट शुरू करना:

6C 22 00

बाद में 1-चार स्निपेट:

01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63 64 65 66 67 68 69 6A 6B 6D 6E 6F 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3 B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF

यहाँ यह कोशिश करो!

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

जावा 8, 7 स्निपेट (19 बाइट्स)

1
*2
-~0
>4?4:4
|5
^3
7%7

बस एक शुरुआत है, इस पर काम करना जारी रखेंगे।

इसे यहाँ आज़माएँ।

स्पष्टीकरण:

जब मैं कोष्ठक जोड़ता हूँ तो निष्पादन पूर्वता को स्पष्ट किया जाता है:

((1*2)-~0)>4?4:4|(5^(37%7))
  • a*b: के aसाथ गुणा करेंb
  • ~a: -a-1
  • a>b?x:y: if(a>b){ x }else{ y }
  • a|b: बिटवाइज़-या के aसाथb
  • a^b: बिटवाइज- XOR के aसाथb
  • a%b: aमोडुलो-b
— केविन क्रूज़सेन
स्रोत
1

अजगर 2 , 110 स्निपेट

यहाँ पूरा स्निपेट है:

print((((len(open(__file__).read())-44.))))

#	 !"$%&'*+,/012356789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^`bcghjkmqsuvwxyz{|}~

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

पहला स्निपेट है 

print((((len(open(__file__).read())-44.))))

और फिर अगले 109 स्निपेट्स अगले 109 बाइट्स हैं।

यह सुंदर "धोखा" है क्योंकि लिन इसे डालता है। पहला स्निपेट फ़ाइल को खोलता है और इसकी लंबाई से 44 घटाता है, फिर एक दूसरे के स्निपेट को प्रोग्राम के तर्क को पूरी तरह से बदले बिना फ़ाइल की लंबाई में 1 जोड़ देता है। इस प्रकार 1 से आउटपुट का परिणाम बढ़ रहा है।

— गेहूं का जादूगर
स्रोत
1

डीसी , स्कोर १३, ५c बाइट्स

I3%                   #I is the default input radix, 10, mod 3 yields 1
1+                    #Add one
2^2^2^Z               #2^8=256, Z pushes the number of digits to the stack
6*v                   #Square root of 18 = ~4.24, at precision 0 we get 4
c5                    #Start getting lazy, clear the stack and push 5
_F-E-                 #Subtract negative 15, then subtract 14
ss7                   #Lazy, 'drop' the value by storing it, push 7
SS8                   #Lazy, 'drop' the value by storing it, push 8
d::9                  #Lazy, 'drop' the value by storing it, push 9
;;kA                  #Recall element 9 from nonexistant array ; which is zero, set precision, push A (10)
iB                    #Set input radix to 10, push B (11)
oD                    #Set output radix to 11, push D (13, or 12 in base 11)
 4CCCCCCr/4C/CC/4/    #We have division and the digits 4 and C left, this might not be the optimal way to get us to 13 but it does the job

इसे ऑनलाइन आज़माएं! (ध्यान दें, टीआईओ संस्करण fप्रत्येक स्निपेट के बाद पूरे स्टैक को प्रिंट करने के लिए जोड़ता है , यह दर्शाता है कि प्रत्येक स्निपेट केवल स्टैक पर एक ही मूल्य छोड़ता है; मैं अंतिम स्निपेट पर अग्रणी स्थान भी भूल गया हूं जो जब वे कार्यात्मक रूप से मायने नहीं रखते हैं लाइन टूटने से टूट गया लेकिन मेरे चरित्र के उपयोग के लिए गिना जाता है)

प्रत्येक अतिरिक्त स्निपेट का संघनन वांछित मूल्य और केवल स्टैक पर वांछित मूल्य छोड़ देता है। 12 मारने के बाद, मैंने स्टैक खाने के लिए कई तरह के रन आउट किए। मैंने गणित के संचालन को जल्दी शुरू करने की कोशिश की, क्योंकि वे स्टैक को ऊपर उठाते थे और जैसे-जैसे हम बड़ी संख्या में आते जाते हैं, उस तरह से इसे प्रबंधित करना मुश्किल होता जाता है। जब सब कहा और किया जाता है, तो मेरे पास खेलने के लिए केवल अंक 0 बचा है और स्टैक-पॉपिंग के रास्ते में बहुत कम है, इसलिए मुझे लगता है कि 13 अधिकतम के करीब है। मुझे यकीन है कि डीसी में इसे पूरा करने के कई समान (और संभावित छोटे) तरीके हैं, यह सिर्फ एक तरह का स्थान है। ध्यान दें कि साइबरविन dc के अधिकांश संस्करणों से 0-9 को अलग-अलग तरीके से मिश्रित 44C4r/CC 4//करता है , साइबरविन में अंतिम स्निपेट के लिए काम करता है।

— brhfl
स्रोत
0

पायथ , 124 स्निपेट

l"x00x01x03x04x05x06x07x08
x0bx0c
x0ex0fx10x11x12x13x14x15x16x17x18x19x1ax1bx1cx1dx1ex1f !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkmnopqrstuvwxyz{|}~x7f

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

तीन प्रिंट करने योग्य वर्ण ( x..) का उपयोग करके बच गए, जहां अनपेक्षित वर्ण । पहला स्निपेट तीन बाइट्स लंबा होता है, उसके बाद हर स्निपेट लंबाई में एक से बढ़ता है।

— जोनाथन फ्रेच
स्रोत
0

बीटनिक , 22 बाइट्स, स्कोर 20

K A
E
I
L
N
O
R
S
T
U
a
e
i
l
n
o
r
s
t
u

"स्निपेट" शब्द को मानने से आप स्टैक पर मूल्य को धक्का दे सकते हैं।

0

ऑक्टेव, स्कोर 86

nnz n

के बाद:

!$&()*+./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmopqrstuvwxy{|}~

यह इस तथ्य का शोषण करता है कि ऑक्टेव एक फ़ंक्शन नाम के बाद सब कुछ एक स्ट्रिंग इनपुट के रूप में व्यवहार करता है। इसलिए nnz nस्ट्रिंग में गैर-शून्य तत्वों की संख्या लौटाता है 'n'। हम अन्य मुद्रण योग्य ASCII-वर्णों को जोड़कर 86 पर पहुंच जाते हैं। ',"%#काम नहीं करता है।

— स्टीवी ग्रिफिन
स्रोत
0

जूलिया 0.6, 111217

निम्नलिखित स्क्रिप्ट पूरा कार्यक्रम बनाता है:

A = "macro length(a);length(string(a))end;@length a"
B0 = join(([Char(x) for x in Iterators.flatten((0x000001:0x00d7ff, 0x00e000:0x10ffff)) if Base.isvalid(Char(x)) && Char(x) ∉ A && Base.isidentifier("a$(Char(x))") ]));
B = normalize_string(B0, stripmark=true, decompose=true);
B = join(unique(b for b in B))
while (n = search(B, '·')) > 0
    B = B[1:prevind(B,n)]*B[nextind(B,n):end]
end
while (n = search(B, '`')) > 0
    B = B[1:prevind(B,n)]*B[nextind(B,n):end]
end

open("concount.jl", "w") do f
    write(f, A)
    write(f, B)
end

व्याख्या

स्थूल

 macro length(a);length(string(a))
 end
 @length a

सभी अलग-अलग यूनिकोड वर्णों की पहचान करने वालों को अनुमति दी गई, जिसके साथ गणना की गई isidentifier। कुछ डिसक्रिटिकल मार्क्स काउंट करने में गड़बड़ी करते हैं इसलिए मैंने उन्हें हटा दिया।

— mschauer
स्रोत
0

TeX, स्कोर 61 (संभवतः 190)

पहला स्निपेट:

\def\len#1{\expandafter\glen\string#1=}
\def\glen#1{\tlen}
\def\tlen#1{\if#1=\let\tlen\end\number\count1\else\advance\count1by1\fi\tlen}
\count1=-1
\catcode33=11
\catcode34=11
\catcode36=11
\catcode37=11
\catcode'46=11
\catcode40=11
\catcode41=11
\catcode42=11
\catcode43=11
\catcode44=11
\catcode45=11
\catcode46=11
\catcode47=11
\catcode56=11
\catcode57=11
\catcode'72=11
\catcode'73=11
\catcode60=11
\catcode62=11
\catcode63=11
\catcode64=11
\catcode'133=11
\catcode'135=11
\catcode'136=11
\catcode'137=11
\catcode'140=11
\catcode124=11
\catcode126=11
\len\t

अन्य 60 स्निपेट: किसी भी क्रम में, प्रत्येक में एक वर्ण होता है

!"$%&()*+,-./:;<>?@[]^_`|~89ABCDEFGHIJKLMNOPQRSTUVWXYZhjkqwz

स्पष्टीकरण:, \lenजो अंत में आह्वान किया गया है, एक नियंत्रण अनुक्रम को एक स्ट्रिंग में परिवर्तित करता है, प्रत्येक वर्ण (सहित \) उस स्ट्रिंग का एक वर्ण टोकन है; इसके बाद \glenटोबैको टोकन\ , फिर \tlenशेष टोकन गिना जाता है। इसलिए यह उस नियंत्रण अनुक्रम की लंबाई को आउटपुट करता है (शामिल नहीं \)।

अन्य स्निपेट से वर्ण नियंत्रण अनुक्रम का विस्तार करते हैं जो शुरू में बस है \t । एक मल्टी-कैरेक्टर कंट्रोल सीक्वेंस केवल अक्षरों से बना होता है, लेकिन वे सभी अक्षरों के रूप में गिने जाते हैं क्योंकि उन्हें सभी को श्रेणी कोड 11 (एएससीआईआई कोड का उपयोग करके) सौंपा गया है ताकि पात्र खुद पहले स्निपेट में दिखाई न दें)।

मैंने कुछ पात्रों के लिए ऑक्टल कोड का उपयोग करने का फैसला किया, जो मुझे एक प्रतीक की कीमत देते थे, 'लेकिन मुझे दो अंक, 8 और 9 बचाए, इसलिए मैंने एक स्निपेट प्राप्त किया। अगर मुझे ज़रूरत नहीं होती तो शायद कुछ और हासिल किया जा सकता था\expandafter ।

उत्पादन

संभावित फेरबदल: आउटपुट \number\count1में लपेटें \message{}आउटपुट में नहीं जाते हैं, .dviबल्कि आउटपुट और कंसोल को सांत्वना देते हैं .log। यह किसी भी अतिरिक्त पत्र खर्च नहीं करता है।

190

दुर्भाग्य से TeX ASCII के साथ काम करता है और यूनिकोड (या अब ऐसा नहीं करता है?), लेकिन मेरे समाधान को संभवतः अधिक विस्तारित किया जा सकता है जिसमें 129 से अधिक एकल-चरित्र वाले स्निपेट शामिल हैं जिनमें कोड 127-255 हैं। हो सकता है 32 से पहले भी कुछ पात्र। चरित्र 32 (स्थान) ने काम नहीं किया, अन्यथा मैं इसे एक स्निपेट में डाल देता - पहले स्निपेट में इसकी आवश्यकता नहीं थी। बेशक, इन अतिरिक्त पात्रों में से प्रत्येक \catcodeको पहले स्निपेट में एक पत्र में घ होना होगा ।

— Heimdall
स्रोत
0

पिप, 57 बाइट्स, स्कोर = 16

!u
2
RT9
#m
5
(EX3Y8)
7
y
A'<tab>
t
11
+o
-v
PI@`\...`@`..$`
"F"FB:4*4
Ok=k6

ध्यान दें कि <tab>एक शाब्दिक टैब वर्ण (ASCII 9) का प्रतिनिधित्व करता है।इसे ऑनलाइन आज़माएं!

प्रत्येक स्निपेट एक पूर्ण प्रोग्राम है जो वांछित संख्या को आउटपुट करता है। उनमें से अधिकांश इस सिद्धांत पर काम करते हैं कि एक पिप प्रोग्राम में अंतिम अभिव्यक्ति स्वतः-प्रदर्शित की जाती है: उदाहरण के लिए, स्निपेट 5 में, पिछले कोड का मूल्यांकन किया जाता है, लेकिन केवल एक हिस्सा जो मायने रखता है5 । इसके अपवाद हैं:

  • स्निपेट 3 अलगाव में ठीक काम करता है RT9(9 के वर्गमूल) के रूप में, लेकिन स्निपेट 2 के बाद आने से यह वास्तव में पारस हो जाता है2RT9 (9 के 2 मूल) के - जो, निश्चित रूप से एक ही चीज़ के लिए होता है।
  • स्निपेट 6 को e ^ 3 का 8 वां वर्ण (0-अनुक्रमित) मिलता है, जो 6. होता है। लेकिन यह 8 नंबर को yचर में भी जमा देता है। स्निपेट 8 तब के मूल्य को आउटपुट करता हैy ।
  • स्निपेट 12 पिछली स्निपेट से 11 लेता है और जोड़ता है o(प्रीइंस्टिग्रेटेड 1 से)। स्निपेट 13 वह परिणाम लेता है और घटाता हैv (-1 के लिए प्रारंभिक)।
  • स्निपेट 16 1एक नई लाइन के बिना आउटपुट ( Ok=k, जहां k=k1 के डिफ़ॉल्ट सत्य मूल्य का मूल्यांकन करता है), और फिर ऑटोप्रीन 6।

अन्य दिलचस्प चीजें:

  • स्निपेट 14 पीजी 14के मूल्य से निकालने के लिए रेगेक्स संचालन का उपयोग करता है ।
  • स्निपेट 15 स्ट्रिंग "F"को हेक्साडेसिमल से परिवर्तित करता है ।
— DLosc
स्रोत
0

Zsh , स्कोर> 50 000 (1 112 046?), 16 + UT (UTF-8 कोडपॉइंट लंबाई) बाइट्स

exec echo   $((${#:-$(<$0)}-33))
#

Zsh डिफ़ॉल्ट रूप से मल्टीबाइट एन्कोडिंग को संभालता है। बेस स्निपेट में 18 अद्वितीय वर्ण हैं, कुल 34। इस पर हर दूसरे कोडपॉइंट (नल बाइट के लिए सेव) को जोड़ा जा सकता है। जैसा कि मैंने इसे लिखा है, मेरी स्क्रिप्ट का परीक्षण ये कोडपॉइंट ~ 50 000 पर है, कुल फ़ाइल आकार 150K, लगभग 30 स्निपेट / सेकंड पर जा रहा है। मेरी पूरी टेस्ट स्क्रिप्ट यहां खुद चलाओ। आप इसे बाद के कोडपॉइंट पर शुरू करने के लिए समायोजित करना चाह सकते हैं।

पहले 2000 स्निपेट ऑनलाइन आज़माएं!

इस तकनीक का उपयोग करके अधिक स्निपेट्स संभव हैं ।

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