9

बंद हो गया । इस प्रश्न के विवरण या स्पष्टता की आवश्यकता है । यह वर्तमान में उत्तर स्वीकार नहीं कर रहा है।

इस प्रश्न को सुधारना चाहते हैं? विवरण जोड़ें और इस पोस्ट को संपादित करके समस्या को स्पष्ट करें ।

3 साल पहले बंद हुआ ।

यह 2016 के ARML प्रतियोगिता टीम प्रॉब्लम # 6 के भाग से प्रेरित था।

यहाँ चुनौती है:

आपको एक "वाइल्डकार्ड अनुक्रम" दिया जाता है, जो अंकों और एक अन्य चरित्र का एक क्रम है। एक स्ट्रिंग निम्नलिखित वाइल्डकोड द्वारा इस वाइल्डकार्ड अनुक्रम से मेल खाता है:

w = wildcard
s = string
# s matches w iff
for all 0 >= i > wildcard.length, w[i] == '?' or s[i] == w[i]

कहाँ पे '?' अपनी पसंद का एक चरित्र है।

Regex के संदर्भ में, बस कल्पना '?'होने के लिए '.'।

चुनौती सभी वर्ग संख्याओं को खोजने की है (आवश्यकता 1 मिलियन तक है) जिनके दशमलव स्ट्रिंग निरूपण इस वाइल्डकार्ड अनुक्रम से मेल खाते हैं। "वाइल्डकार्ड वर्ण" आपकी पसंद का कोई भी ASCII वर्ण हो सकता है, जब तक कि यह एक अंक नहीं है, जाहिर है।

उदाहरण के लिए, 4096से मेल खाता है 4**6और 4*9*लेकिन 4114या तो मेल नहीं खाता।

इनपुट

इनपुट को रेगेक्स से मेल खाते हुए सीक्वेंस के रूप में दिया जाएगा [0-9?]+। यह ASCII में एक स्ट्रिंग, एक कैरेक्टर ऐरे, या कैरेक्टर्स की बाइट सरणी हो सकती है।

उत्पादन

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

मान्य इनपुट के उदाहरण:

1234567*90
1234567?90
1234567u90
['1', '2', '3', '4', '5', '6', '7', '*', '9', '0']
[49, 50, 51, 52, 53, 54, 55, 42, 57, 48]
[1, 2, 3, 4, 5, 6, 7, '*', 9, 0]

मान्य आउटपुट के उदाहरण:

[1, 4, 9]
1 4 9
1, 4, 9
1-4-9

आदि।

विशेष विवरण

आप एक निश्चित सीमा में वर्गों की सूची खोजने के लिए बिल्डरों का उपयोग नहीं कर सकते हैं
स्टैंडर्ड लोफॉल्स लागू होते हैं
आपको 1 000 000 (1 मिलियन) तक का संचालन करने में सक्षम होना चाहिए
यदि इनपुट के साथ प्रदान किया गया है 1******, तो प्रिंट करना सही है [1000000]। प्रिंट करना भी सही है[1000000, 1002001, 1004004, 1006009, 1008016, 1010025, ...]
वाइल्डकार्ड अनुक्रम वाइल्डकार्ड वर्ण से कभी शुरू नहीं होंगे; यही है, वे हमेशा एक ही लंबाई के तार का मिलान करेंगे।

परीक्षण के मामलों

4**6  ->  [4096, 4356]
1**1  ->  [1521, 1681]
1**  ->  [100, 121, 144, 169, 196]
9****9  ->  [908209, 915849, 927369, 935089, 946729, 954529, 966289, 974169, 986049, 994009]
9*9***  ->  [919681, 929296]
1**0*  ->  [10000, 10201, 10404, 10609, 12100, 14400, 16900, 19600]
9***4  ->  [91204, 94864, 97344]

जीतना

14 फरवरी तक सबसे छोटा (वैध) (कार्यशील) सबमिशन, शुरुआती सबमिशन जीत से टाई-ब्रेक।

code-golf string math

— HyperNeutrino
स्रोत

1

मुझे लगता है कि यह स्पष्ट करने के लिए एक अच्छी शुरुआत यह निर्दिष्ट करने के लिए होगी कि ?उत्तरदाता द्वारा चुना जाना है।

— FryAmTheEggman

2

क्यों नहीं के लिए 25एक वैध जवाब है ? ****2*

— नील

3

मुझे लगता है कि यह क्लीनर होगा यदि संख्याओं में अग्रणी शून्य कभी नहीं थे, इसलिए केवल उनकी लंबाई के अनुक्रम से मेल खाता था।

— xnor

@ नील मेरे अपने समाधान के साथ एक समस्या होगी। मैं xnor का सुझाव लूंगा।

— HyperNeutrino

क्या इनपुट एक-अंक पूर्णांक और विशेष वर्ण, जैसे कि {4, "w", "w", 6}(या बेहतर अभी तक {4, w, w, 6}) की एक सरणी हो सकता है, वर्णों के एक सरणी के बजाय, जैसे {"4", "w", "w", "6"}?

— ग्रेग मार्टिन

0

05AB1E , 22 बाइट्स

शायद यहाँ सुधार के लिए बहुत जगह है।
किसी भी गैर अंक वाइल्डकार्ड के रूप में ठीक है।

3°LnvyS¹)ø€Æ0QPyg¹gQ&—

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

आगे गोल्फिंग के बाद आने के लिए स्पष्टीकरण।

— Emigna
स्रोत

यह सभी जानकारी के लिए काम करता है। बहुत बढ़िया।

— हाइपरनेत्रिनो

1

मैथेमेटिका, 44 बाइट्स

Print@@@IntegerDigits[Range@1*^3^2]~Cases~#&

इनपुट _वाइल्डकार्ड के रूप में (कोई उद्धरण नहीं) अंकों की एक सूची है । जैसे{4, _, _, 6}

व्याख्या

Range@1*^3

सूची तैयार करें {1, 2, 3, ... , 1000}

... ^2

इसे स्क्वायर करें। (1 से 1,000,000 तक सभी वर्गों की सूची)

IntegerDigits[ ... ]

प्रत्येक वर्ग को अंकों की सूची में विभाजित करें।

... ~Cases~#

उन लोगों को ढूंढें जो इनपुट द्वारा निर्दिष्ट पैटर्न से मेल खाते हैं।

Print@@@ ...

उन्हें प्रिंट करें।

— जंगहवान मिन
स्रोत

यह सभी परीक्षण मामलों के लिए काम करता प्रतीत होता है। बहुत बढ़िया।

— हाइपरनेट्रिनो

1

ब्रेकीलॉग , 23 बाइट्स

@e:{@$|,}a#0:{c.~^#I,}f

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

व्याख्या

@e                        Split into a list of characters
  :{@$|,}a                Replace each digit char by the corresponding digit, and each things
                            that are ot digits into variables
          #0              All elements of the resulting list must be digits
            :{       }f   Output is the result of finding all...
              c.            ...concatenations of those digits which...
               .~^#I,       ...result in a number which is the square of an integer #I

विभिन्न इनपुट प्रारूप, 13 बाइट्स

इनपुट के रूप में आपके द्वारा मान्य मान्य के आधार पर, आप ऐसा कर सकते हैं:

#0:{c.~^#I,}f

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

जो मूल रूप से ऊपर दिए गए उत्तर का दूसरा हिस्सा है, एक सूची के रूप में इनपुट युक्त अंक और चर जहां वाइल्डकार्ड हैं।

हालांकि मैं इसे वैध नहीं मानता, क्योंकि ब्रेकीलॉग (अपरकेस अक्षर) में केवल 26 चर नाम हैं, इसलिए यदि आपके पास 26 से अधिक wilcards है तो यह काम नहीं करेगा।

— Fatalize
स्रोत

यह सभी जानकारी के लिए काम करता है। बहुत बढ़िया। हालाँकि, मैं इसे 24 बाइट्स मानूंगा क्योंकि 1-बाइट तर्क की आवश्यकता है। मुझे यकीन नहीं है कि इसके लिए स्कोरिंग कैसे काम करेगा।

— हाइपरनेत्रिनो

1

@AlexL। तर्क केवल आउटपुट चर का नाम बताने के लिए है (यदि आप चाहें तो एक और बड़े अक्षर का उपयोग कर सकते हैं)। यह प्रोलॉग / भाषाओं में उन कार्यों के साथ जवाब देने के समान है जहां विधेय / फ़ंक्शन का नाम दिया गया है, लेकिन जब आप कॉल करते हैं तो आप वास्तव में आपके द्वारा उपयोग किए जाने वाले बाइट्स की गणना नहीं करते हैं।

— घातक

ठीक है। मुझे यकीन नहीं है कि अगर किसी को 24 के रूप में स्कोर करना चाहिए क्योंकि तर्क आवश्यक है (अन्यथा यह सिर्फ रिटर्न देता है true.), लेकिन मैंने उन भाषाओं का उपयोग नहीं किया है जिनकी पहले आवश्यकता होती है। मैं यह निर्धारित करने के लिए कुछ संदर्भ खोजने की कोशिश करूंगा कि मुझे यह कैसे स्कोर करना चाहिए, लेकिन यह 23 के रूप में स्कोर करने के लिए समझ में आता है, इसलिए मैं इसे उस पर रखूंगा।

— हाइपरन्यूट्रिनो

1

पर्ल 6 , 30 26 बाइट्स

-4 बाइट्स के लिए @ b2gills का धन्यवाद!

~~{grep /^<$_>$/,map * **2,^1e4}~~

{grep /^<$_>$/,(^1e4)»²}

वाइल्डकार्ड वर्ण के रूप में डॉट का उपयोग करता है, ताकि इनपुट को रेगेक्स के रूप में उपयोग किया जा सके:

{                            }   # a lambda
                         ^1e4    # range from 0 to 9999
               map * **2,        # square each value
 grep /      /,                  # filter numbers that match this regex:
        <$_>                     #   lambda argument eval'ed as sub-regex
       ^    $                    #   anchor to beginning and end

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

एक ऐसा संस्करण जो तारांकन चिह्न को वाइल्डकार्ड के रूप में स्वीकार करता है (जैसा कि कार्य विवरण के पिछले संशोधन द्वारा सुझाया गया है) 42 बाइट्स होंगे:

{grep /^<{.trans("*"=>".")}>$/,(^1e4)»²}

— SMLS
स्रोत

मैंने नियम बहाल किए हैं, और आप किसी भी वाइल्डकार्ड वर्ण का चयन कर सकते हैं। मैं इसे 38 बाइट्स के रूप में स्कोर कर रहा हूं।

— हाइपरनेत्रिनो

उम, आप इसका उपयोग कैसे करते हैं? मैं पर्ल के बारे में कुछ नहीं जानता।

— हाइपरएन्यूट्रीनो

@AlexL .: धन्यवाद, मैंने उत्तर अपडेट कर दिया है (और स्पष्टीकरण भी जोड़ दिया है)। यह एक मेमना है; आप इसे सीधे (उदाहरण के लिए { ... }("9*9***")) कह सकते हैं , या इसे बाद के उपयोग के लिए एक चर / प्रतीक को सौंप सकते हैं। ध्यान दें कि पर्ल 6 पर्ल से अलग भाषा है, इसलिए यह पर्ल इंटरप्रेटर के साथ काम नहीं करेगा।

— SMLS

मैं sudo apt-get install rakudoएक माना जाता था कि Perl6 दुभाषिया मिलता है ... जब मैं perl6अपने टर्मिनल में एक कमांड के रूप में डालता हूं, तो यह शुरू होता है जो एक Perl6 दुभाषिया लगता है, लेकिन मुझे नहीं पता कि इसका उपयोग कैसे करना है। मुझे पता है कि यह एक मेमना है, लेकिन मुझे नहीं पता कि इसे कैसे कॉल किया जाए।

— हाइपरनेत्रिनो

@AlexL .: मैंने एक "ऑनलाइन प्रयास करें" लिंक जोड़ा, जो इसे एक पूर्ण स्क्रिप्ट के रूप में दिखाता है जिसे आप के रूप में चला सकते हैं perl6 foo.p6 । आप इसे शेल ऑनलाइनर में भी टेस्ट कर सकते हैं, जैसेperl6 -e 'say {grep /^<$_>$/,map * **2,^1e4}( "9.9..." )'

— स्मेल करता है

1

रूबी, 54 बाइट्स

फ़ंक्शन जो एक स्ट्रिंग तर्क लेता है। इसे ऑनलाइन आज़माएं।

->s{(0..1e3).map{|i|"#{i**2}"[/^#{s.tr ?*,?.}$/]}-[p]}

— मूल्य स्याही
स्रोत

आप

— GB

यह काम नहीं करता है क्योंकि दूसरा #लाइन के बाकी हिस्से को एक टिप्पणी बना रहा है।

— हाइपरएन्यूट्रीनो

@AlexL ओह, यह सब ठीक काम करता है। repl.it/FJCV

— वैल्यू इंक

ओह, मैं ठीक से नहीं जानता कि रूबी का परीक्षण कैसे किया जाए। मैं क्षमाप्रार्थी हूं। यह सभी इनपुट के लिए काम करता है। बहुत बढ़िया!

— हाइपरनेत्रिनो

0

बैच, 109 बाइट्स

@for /l %%i in (0,1,999)do @set/aj=%%i*%%i&call copy nul %%j%%.%%j%%$>nul
@for %%s in (%1.%1$)do @echo %%~ns

?वाइल्डकार्ड के रूप में उपयोग करता है । 1000 फाइलें बनाकर काम करता है। फ़ाइल का नाम वर्ग संख्या है, और फ़ाइल का विस्तार एक $प्रत्यय के साथ वर्ग संख्या है । इसका कारण यह है कि बैच का पैटर्न मिलान ?वैकल्पिक के रूप में गिना जाता है, इसलिए 1?दोनों का मिलान होगा 1और 16; $इसलिए मजबूर करता मिलान सटीक होना करने के लिए। हालाँकि, हम इसका उत्पादन नहीं करना चाहते हैं $, इसलिए हम फ़ाइल नाम को केवल विस्तार के बिना आउटपुट करते हैं।

— नील
स्रोत

0

जावास्क्रिप्ट (ईएस 6), 68 66 बाइट्स

EDIT: जंगवान मिन के जवाब से प्रेरित होने के बाद नीचे दिए गए मेरे समाधान को अपडेट करें । अब यह ES6 अनुपालन है।

फॉर्मेट में इनपुट लेता है '1..4'जहां .वाइल्डकार्ड है।

1e6 को पुनरावृत्त करने और वर्गमूल के बजाय यह 1e3 और वर्ग को पुनरावृत्त करता है।

p=>[...Array(1e3)].map((_,n)=>''+n*n).filter(n=>n.match(`^${p}$`))

कोड स्निपेट दिखाएं

F=p=>[...Array(1e3)].map((_,n)=>''+n*n).filter(n=>n.match(`^${p}$`))

const update = () => {
  console.clear();
  console.log(F(input.value));
}

submit.onclick = update;
update();

<input id="input" type="text" value="9....9" style="width: 100%; box-sizing: border-box" /><button id="submit">submit</button>

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

जावास्क्रिप्ट (ईएस 7), 71 69 बाइट्स

p=>[...Array(1e6).keys()].filter(n=>n**.5%1?0:(''+n).match(`^${p}$`))

0 से 1e6 तक संख्याओं की एक सरणी बनाता है, फिर इसे उन संख्याओं द्वारा फ़िल्टर करता है जो वर्ग हैं और पैटर्न से मेल खाते हैं।

यह भयावह रूप से धीमा है क्योंकि यह हमेशा 1e6 की ओर बढ़ता है।

कोड स्निपेट दिखाएं

F=p=>[...Array(1e6).keys()].filter(n=>n**.5%1?0:(''+n).match(`^${p}$`))

const update = () => {
  console.clear();
  console.log(F(input.value));
}

submit.onclick = update;
update();

<input id="input" type="text" value="9....9" style="width: 100%; box-sizing: border-box" /><button id="submit">submit</button>

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

— जॉर्ज रीथ
स्रोत

मुझे नहीं लगता कि **यह काम कर रहा है, क्योंकि यह मुझे दे रहा है "SyntaxError: expected expression, got '*'"।

— HyperNeutrino

@AlexL। लगता है नियम बदल गए हैं। पिछले नियमों ने सुझाव दिया कि मैं वाइल्डकार्ड चरित्र चुन सकता हूं।

— जॉर्ज रीथ

आपको केवल समर्थन करने की आवश्यकता है 1e6...

— हाइपरन्यूट्रिनो

इसके अतिरिक्त, मैंने नियमों को वापस बदल दिया; समस्या नियमों के साथ नहीं है, यह इसलिए है क्योंकि **ऑपरेटर मौजूद नहीं है, कम से कम मेरे सिस्टम के साथ नहीं है।

— हायपरनेट्रिनो

@AlexL। क्षमा करें, मुझे लगा कि आपका मतलब इनपुट से है **। हाँ, यह ES7 मैं यहाँ शीर्षक अद्यतन करेगा है वर्तमान में समर्थित ब्राउज़रों की एक सूची है developer.mozilla.org/en/docs/Web/JavaScript/Reference/...

— जॉर्ज रीथ

0

पर्ल, 42 45 38 बाइट्स

EDIT: एलेक्स द्वारा स्पष्टीकरण, हम अवधि को वाइल्डकार्ड वर्ण के रूप में उपयोग कर सकते हैं जो y // ऑपरेशन से हट जाता है।

perl -pe 's|.*|@{[grep/^$&$/,map$_*$_,1..1e3]}|'

संपादित करें: समाधान जो तारांकन चिह्न को वाइल्डकार्ड वर्ण के रूप में उपयोग करता है और एसटीडीआईएन पर वाइल्डकार्ड अनुक्रम की अपेक्षा करता है

perl -pe 'y/*/./;s|.*|@{[grep/^$&$/,map$_*$_,1..1e3]}|'

यह एक निस्संदेह सुधार के लिए बहुत जगह है, यह बहुत सीधा है। वाइल्डकार्ड अभिव्यक्ति की अपेक्षा कमांड लाइन तर्क के रूप में की जाती है, जिसमें वाइल्डकार्ड वर्ण (और क्या?) होता है।

say"@{[grep/^$ARGV[0]$/,map$_*$_,1..1e3]}"

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

प्रश्न निर्दिष्ट करता है कि वाइल्डकार्ड को तारांकन के रूप में दिया गया है। क्या प्रश्न के पहले के संशोधन ने आपके अपने वाइल्डकार्ड चरित्र को चुनने की अनुमति दी थी?

— SMLS

1

@smls: यह प्रश्न अभी भी आपके स्वयं के वाइल्डकार्ड का चयन करता है, हालांकि यह नियम अनुभाग में नहीं है: वाइल्डकार्ड के रूप में उपयोग किया जाने वाला वर्ण आवश्यक रूप से तारांकित होने की आवश्यकता नहीं है, यह आपकी पसंद का कोई भी ASCII वर्ण हो सकता है, जब तक कि यह एक अंक नहीं है, जाहिर है।

— इमीना

हां, मैं इससे भ्रमित हो गया। बाद में, यह स्पष्ट रूप से कहता है कि वाइल्डकार्ड चरित्र को तारांकन करने की आवश्यकता है। मुझे लगता है कि रेगेक्स के साथ परिभाषा अग्रणी है। मैं अपने समाधान को संशोधित करूँगा।

— डेनियल

1

हम्म, वास्तव में @Eignign द्वारा उद्धृत वाक्य बहुत स्पष्ट है कि हम अपना वाइल्डकार्ड वर्ण चुन सकते हैं, है ना?

— SMLS

स्पष्ट करने के लिए, वाइल्डकार्ड वर्ण आप जो चाहें कर सकते हैं। मैंने स्पष्टीकरण को बहाल करते समय गलती से नियमों को गड़बड़ कर दिया।

— HyperNeutrino

0

पायथन 3 - 98 97 बाइट्स

import re;print(re.findall(r"\b"+input()+r"\b",("\n".join([str(x*x) for x in range(1,1001)]))))

'4..6' जैसे इनपुट की आवश्यकता है।

— Carra
स्रोत

आप का उपयोग करके 3 बाइट्स बचा सकते हैं import reऔर re.findall; अनुकूलन from...import *वास्तव में इस मामले में इसका अनुकूलन नहीं करता है।

— हाइपरनेत्रिनो

बशर्ते इनपुट 1...., यह देता है 1 4 9और 16 25मान्य उत्तर के रूप में, जो सही नहीं है। कृपया अपना कार्यक्रम सही करें।

— हाइपरनेत्रिनो

"\ N" पर जुड़कर मामले को ठीक करें।

— Carra

यह काम नहीं करता है 1......। यह लौटता है [], लेकिन इसे देना चाहिए [1000000]। इसके range(0, 1001)बजाय का उपयोग करके 0 बाइट्स की लागत पर तय किया जा सकता है range(0, 1000)।

— हाइपरनेत्रिनो

अच्छी बात है, मैंने सिर्फ विवरण से सभी परीक्षण मामलों की जाँच की :)

— कार्रा

0

k - 28 अक्षर

{s(&:)($:s:s*s:!1001)like x}

?वाइल्डकार्ड वर्ण के रूप में उपयोग करता है । likeसमारोह का उपयोग करता है ?वाइल्डकार्ड के रूप में है, और इस समारोह पहले 1001 वर्गों की एक सूची बनाता है (1M करने के लिए समावेशी होना करने के लिए), उन सब को तार करने के लिए डाले, और उसके बाद जाँच करता है, जहां वे आकार से मिलान।

    {s(&:)($:s:s*s:!1001)like x} "1??"
100 121 144 169 196

— सी। क्विली
स्रोत

मैं इसके लिए इस त्रुटि हो रही है: type error {s(&:)($:s:s*s:!1001)like x} "1" at execution instance 2 of ":"। क्या आप वर्किंग टेस्ट सूट का लिंक दे सकते हैं या देख सकते हैं कि क्या कोई समस्या है?

— हाइपरनेत्रिनो

@AlexL। यह मेरे लिए kdb + के k मोड में काम करता है

— C.

हम्म। मैं अलग-अलग दुभाषियों के साथ इसका परीक्षण करने की कोशिश करूँगा।

— HyperNeutrino

0

बैश + यूनिक्स उपयोगिताओं, 33 बाइट्स

dc<<<'0[2^pv1+lax]dsax'|grep ^$1$

यह 'का उपयोग करता है। वाइल्डकार्ड चरित्र के रूप में।

डीसी प्रोग्राम एक अनंत लूप में वर्ग संख्या को प्रिंट करता है:

0     Push 0 on the stack.

[     Start a macro (called a).

2^    Square the number at the top of the stack.

p     Print the number at the top of the stack, followed by a newline.

v     Replace the number at the top of the stack (a square number) with its square root.

1+    Increment the number at the top of the stack.

lax   Run the macro again (looping).

]     End of the macro.

dsax  Store the macro in register a and run it.

डीसी आउटपुट को grep पर पाइप किया जाता है, जो आवश्यक वर्गों से मेल खाने वाले वर्गों को प्रिंट करता है।

यह तब काम करता है जब मैं इसे एक वास्तविक लिनक्स या OS X सिस्टम पर चलाता हूं (लेकिन यह TIO पर काम नहीं करता है, शायद इसलिए कि dc प्रोग्राम हमेशा के लिए रिकवर करने की कोशिश करता है, और मुझे संदेह है कि TIO रिकर्सन और / या के लिए स्टैक स्पेस से बाहर चलता है या है) कभी न खत्म होने वाले पाइप के साथ एक समस्या)।

— मिशेल स्पेक्टर
स्रोत

मैं लिनक्स मिंट 17.3 रोजा के साथ इसे चला रहा हूं, और यह समाप्त नहीं हो रहा है। मुझे लगता है कि समस्या कभी न खत्म होने वाली dcकमांड के साथ है।

— हाइपरनेत्रिनो

मुझे संदेह है कि यह वास्तव में बफरिंग है जो इस मुद्दे का कारण बन रहा है। मेरे पास लिनक्स का वह संस्करण नहीं है, लेकिन आप grep के साथ grep की जगह लेने की कोशिश कर सकते हैं - लाइन-बफ़र्ड (प्रत्येक लाइन को प्रिंट होने के कारण प्रिंट किया जा सकता है)। [बेशक, कि कई बाइट्स जोड़ता है।]

— मिशेल स्पेक्टर

मैंने grep तर्क जोड़ा, लेकिन इससे कोई फर्क नहीं पड़ता। मैं के --line-bufferedदोनों तरफ डालने की कोशिश की ^$1$, लेकिन यह किसी भी तरह से काम नहीं करता है।

— हाइपरएन्यूट्रीनो

@ AlexL.Thank कोशिश करने के लिए। मुझे नहीं पता कि क्या अंतर कर्नेल में है या बैश संस्करण में मैं चल रहा हूं। मुझे यह TIO में काम करने के लिए मिला सिर का उपयोग करके grep के इनपुट को समाप्त करने के लिए मजबूर करके, निम्नानुसार: dc <<< '0 [2 ^ pv1 + lax] dsax' | head -1sed s/./0/g<<<$1 | grep ^ $ 1 $ uses परीक्षण की जा रही संख्या को सीमित करने के लिए पैटर्न (4-वर्ण पैटर्न केवल 9999 तक की जांच करें, आदि)। यहाँ एक TIO लिंक दिया गया है: tio.run/nexus/…

— मिशेल स्पेक्टर

ठीक करने के लिए धन्यवाद। मुझे नहीं लगता कि वर्तमान समाधान वास्तव में काम करेगा (हालांकि मुझे बैश का ज्यादा ज्ञान नहीं है), क्योंकि ऐसा लगता है कि इसे खिलाने से पहले सभी मूल्यों की गणना करने की आवश्यकता है grep। हालांकि, जैसा कि वर्तमान में यह सबसे छोटा समाधान नहीं है, मैं इसे स्कोरिंग के लिए 33 बाइट पर रखूंगा। यह सभी निविष्टियों के लिए काम करता प्रतीत होता है, इसलिए अच्छा काम!

— हाइपरनेत्रिनो

सभी वर्ग जो वाइल्डकार्ड अनुक्रम से मेल खाते हैं [बंद]

इनपुट

उत्पादन

मान्य इनपुट के उदाहरण:

मान्य आउटपुट के उदाहरण:

विशेष विवरण

परीक्षण के मामलों

जीतना

05AB1E , 22 बाइट्स

मैथेमेटिका, 44 बाइट्स

ब्रेकीलॉग , 23 बाइट्स

व्याख्या

विभिन्न इनपुट प्रारूप, 13 बाइट्स

पर्ल 6 , 30 26 बाइट्स

रूबी, 54 बाइट्स

बैच, 109 बाइट्स

जावास्क्रिप्ट (ईएस 6), 68 66 बाइट्स

जावास्क्रिप्ट (ईएस 7), 71 69 बाइट्स

पर्ल, 42 45 38 बाइट्स

पायथन 3 - 98 97 बाइट्स

k - 28 अक्षर

बैश + यूनिक्स उपयोगिताओं, 33 बाइट्स