एक क्वीन प्रिंट करें जिसमें इनपुट शामिल है

Question

कार्य

आपको इनपुट में एक स्ट्रिंग दी जाएगी जिसमें केवल वर्णों से aहै z, यानी इनपुट regex से मेल खाएगा /^[a-z]*$/।

आपका आउटपुट उसी भाषा में एक पूरा कार्यक्रम होना चाहिए, जिसके स्रोत कोड में इनपुट शामिल है, और एक उचित क्वीन है।

उदाहरण

आपका कार्यक्रम इनपुट abcऔर आउटपुट प्राप्त करेगा :

...abc...

ऊपर उसी भाषा में एक पूरा कार्यक्रम होना चाहिए जिसमें कोई इनपुट और आउटपुट न हो:

...abc...

यानी यह खुद को आउटपुट करता है।

स्कोरिंग

यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब।

संदर्भ

• एक उचित रानी के रूप में क्या मायने रखता है?

Comments

हम्म .. तो एक 'क्वाट' (क्वीन + बिल्ली) की तरह?

— मैथ्यू रो

Answer 1

अजगर 3, 57 61 बाइट्स

lambda x:"s='s=%r;print(s%%s)';print(s%s)".replace('s',x+'x')

एक मूल अजगर से 3 क्वीन लेता है यहां है और इनपुट के साथ चर नाम बदलता है।

नोट: जैसा कि हाइपर न्यूट्रिनो ने टिप्पणियों में बताया है, यह आरक्षित खोजशब्दों जैसे काम नहीं करता हैfor , ifआदि

एक वर्ण लागू करना जो आरक्षित खोजशब्दों में 'x'से किसी के साथ समाप्त नहीं होता है जैसे कि या कोई भी संख्या इसे ठीक करती है। (अर्जन जोहानसन)।

Comments

चर नाम का उपयोग करने के लिए बहुत रचनात्मक।

— लीक नून

"for"पायथन में इनपुट , या किसी अन्य आरक्षित शब्द के लिए काम नहीं करता है ।

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

पुष्टि कर सकते हैं। यह सभी संभव इनपुट के लिए काम नहीं करता है। इसे ऑनलाइन

— आजमाएं

@ हाइपर न्युट्रीनो, नोय्ड, भी कोई विचार नहीं है कि इसे कैसे प्राप्त किया जाए

— c ..

आप एक अतिरिक्त वर्ण जोड़ सकते हैं जो किसी भी खोजशब्द के अंत में नहीं है, जैसे कि 'x'।

— अर्जन जोहान्सन

Answer 2

जेली , 9 बाइट्स

जनक

;“¶Øv”ṾØv

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

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

;“¶Øv”ṾØv  Main link. Argument: s (string of letters)

;“¶Øv”     Concatenate s and the string "\nØv".
      Ṿ    Uneval; get its string representation.
           (implicit) Print the previous return value since the next link is an
           otherwise unparsable nilad.
       Øv  Set the return value to "Ṙv".

Quine

यदि इनपुट है quine, तो निम्न प्रोग्राम उत्पन्न होता है।

“quine
Øv”Ṙv

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

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

यह मानक जेली क्वीन है। प्रथम,

“quine
Øv”

बाएं तर्क और स्ट्रिंग के लिए वापसी मान सेट करता है "quine\nØv"।

फिर, Ṙ एक स्ट्रिंग प्रतिनिधित्व (पिछले ब्लॉक से कोड) को प्रिंट करता है और अनछुए स्ट्रिंग को वापस करता है।

बाद में, vबाएं तर्क को लेता है और इसे जेली प्रोग्राम के इनपुट के रूप में पास करता है

quine
Øv

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

अंत में, Øvवापसी का मान निर्धारित करता है "Ṙv", जो बाहरी कार्यक्रम समाप्त होने पर निहित रूप से मुद्रित होता है।

Comments

8 बाइट्स

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

Answer 3

हास्केल , 51 बाइट्स

q एक स्ट्रिंग लेता है और एक स्ट्रिंग लौटाता है।

q s|t<-"main=putStr$fst`mappend`show$"=t++show(t,s)

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

उदाहरण के लिए आउटपुट putStr$q"test":

main=putStr$fst`mappend`show$("main=putStr$fst`mappend`show$","test")

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

• एक ट्यूल में मुख्य क्वीन टेक्स्ट और वांछित स्ट्रिंग डालता है।
• fstमुख्य पाठ को निकालने के लिए उपयोग करता है।
• showपूरे टपल को एक स्ट्रिंग में बदलने के लिए उपयोग करता है।
• mappendदो पिछले कार्यों को संयोजित करने के लिए उपयोग करता है। सुविधाजनक mappendदो कार्यों पर अपना तर्क करने के लिए प्रत्येक समारोह लागू होता है और साथ परिणाम को जोड़ती है कि एक समारोह देता mappendपरिणाम प्रकार (यहाँ स्ट्रिंग संयोजन) के लिए।

Answer 4

अंडरलोड , 14 बाइट्स

(~aSaS(:^)S):^

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

के रूप में उपयोग करें (test)(~aSaS(:^)S):^- जो स्वयं एक रानी है।

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

• अंडरलोड एक समवर्ती (स्टैक-आधारित) गूढ़ भाषा है। यह रीडिंग इनपुट का समर्थन नहीं करता है, इसलिए किसी भी तर्क को शुरू में स्टैक पर रखा जाता है।
• (test)और (~aSaS(:^)S)स्ट्रिंग शाब्दिक हैं, इसलिए खुद को स्टैक पर रखें, शीर्ष पर उत्तरार्द्ध के साथ।
• :(~aSaS(:^)S)स्टैक के ऊपर स्ट्रिंग को डुप्लिकेट करता है , फिर^ अपनी सामग्री को उपप्रोग्राम के रूप में चलाता है।
• ~ स्टैक पर शीर्ष दो तत्वों को स्वैप करता है, इसलिए अब (test) ऊपरवाला है।
• a wraps (test)अतिरिक्त कोष्ठक में है।
• S स्ट्रिंग लेता है ((test))स्टैक के शीर्ष पर , और इसे बाहरी कोष्ठक के बिना प्रिंट करता है (जो कि केवल शाब्दिक वाक्यविन्यास हैं)।
• अब aSशेष को प्रिंट करता है(~aSaS(:^)S) को स्टैक पर इसी तरह से (कोष्ठक के साथ) ।
• आखिर में, (:^)Sफाइनल प्रिंट करता है :^।

Comments

वास्तव )(में इनपुट के रूप में काम नहीं करता है , मुझे लगता है।

— R

@ रिकर सच, अंडरलोड दुर्भाग्य से बेमेल कोष्ठकों का समर्थन नहीं करता है। लेकिन सवाल निर्दिष्ट करता है a- z।

— अर्जन जोहानसन

आह ठीक है। उस पर ध्यान नहीं दिया।

— Rɪᴋᴇʀ

Answer 5

अंडरलोड , 14 बाइट्स

a(aS(:^)S)~*:^

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

अन्य अंडरलोड उत्तर से एक अलग दृष्टिकोण; बल्कि खुद एक रानी होने के नाते, यह एक रानी का निर्माण करता है। दिलचस्प है, यह बाइट्स की एक ही संख्या के लिए बाहर आता है। यह एक फ़ंक्शन है जो स्टैक से अपना तर्क लेता है और मानक आउटपुट पर आउटपुट करता है।

व्याख्या

a(aS(:^)S)~*:^
a               Generate a string literal containing the input
 (aS(:^)S)~*    Prepend "aS(:^)S"
            :^  Mockingbird: run the resulting function with itself as argument

परिणामी फ़ंक्शन इस तरह दिखता है:

aS(:^)S(input)
aS              Print a string literal containing the argument
  (:^)S         Print ":^"
       (input)  Push "input" onto the stack

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

Comments

यह टीआईओ में दिखता है, आप प्रारंभिक को छोड़ सकते हैं a, जब तक कि आपको इनपुट में शामिल होने पर स्टडर के लिए मुद्रित विभाजन त्रुटि को बुरा न लगे a।

— अर्जन जोहान्सन

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

Answer 6

वी , 9 बाइट्स

ñ"qPxÉÑ~j

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

यह मानक V quine का एक संशोधन है , और मुझे गर्व है कि यह केवल एक बाइट है।

Hexdump:

00000000: f122 7150 78c9 d17e 6a                   ."qPx..~j

स्पष्टीकरण:

ñ           " Record the following commands into register 'q'
 "qP        " Paste register 'q' before all input
    x       " Delete the last character of what we just pasted (this will be a 'ÿ')
     ÉÑ     " Insert 'Ñ' at the beginning of this line
       ~    " Toggle the case of this character
        j   " Move down a line. During playback, this will cancel playback of the current macro,
            " So everything after here is a NOOP

फिर, रिकॉर्डिंग निहित रूप से बंद हो जाती है और वापस खेली जाती है। यह निम्न आउटपुट उत्पन्न करेगा:

ñ"qPxÉÑ~jHello

चूंकि jमैक्रो का प्लेबैक टूट जाएगा, इसमें कुछ भी Helloकभी नहीं चलेगा।

Answer 7

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

हालाँकि इनपुट केवल समर्थन के लिए आवश्यक है a-z, यह किसी भी एकल-पंक्ति इनपुट के साथ काम करना चाहिए जिसमें NUL बाइट्स नहीं हैं।

s='s=%r;print s%%s#'+input();print s%s

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

इनपुट के abcलिए जिसके परिणामस्वरूप क्वीन है:

s='s=%r;print s%%s#abc';print s%s#abc

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

Answer 8

RProgN 2 , 15 बाइट्स

"{']C'.%q[}]C"F

व्याख्या की

प्रारूप का उपयोग करना

{']C'.%q[}]C}

%qqouted इनपुट कहां है, स्वाद का एक हिस्सा बनाता है

{']C'."Some Text"[}]C

जो कि एक मानक RProgN2 क्वीन है, {']C'.}]Cसमाप्त होने से पहले, इनपुट किए गए स्ट्रिंग को जोड़ता है और नष्ट कर देता है।

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

Answer 9

रेटिना , 14 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

\(\`^
¶\(*S1`|

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

इनपुट के लिए x, यह आउटपुट:

\(*S1`|x
\(*S1`|x

व्याख्या

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

इसे प्रिंट करना वास्तव में एक ऐसी तकनीक का उपयोग करता है, जो खुद ही क्वीन के समान है। क्वीन के दोहराव से बचने के लिए, हम ¶\(*S1`|केवल एक बार स्ट्रिंग की शुरुआत में सम्मिलित करते हैं। यह स्रोत कोड से ठीक आधा है। एक लाइनफीड के बिना दो बार इसे प्रिंट करने के लिए, हम कॉन्फ़िगरेशन का उपयोग करते हैं \(\, जो पूरे प्रोग्राम को एक समूह में लपेटता है और दोनों स्टेज को ही बनाता है और साथ ही ग्रुप वाले को बिना लाइनफीड के परिणाम को प्रिंट करता है।

Answer 10

जाप , 14 बाइट्स

"\"iQ ²ª`"+U ²

इसे ऑनलाइन टेस्ट करें! abcआउटपुट के इनपुट के लिए

"iQ ²ª`abc"iQ ²ª`abc

जो खुद को आउटपुट करता है। इसे ऑनलाइन टेस्ट करें!

व्याख्या

यह मानक पेलोड-सक्षम जाप क्वीन का एक विस्तार है:

"iQ ²"iQ ²

"iQ ²"      // Take this string.  iQ ²
      iQ    // Insert a quote.    "iQ ²
         ²  // Repeat this twice. "iQ ²"iQ ²
            // Implicit: output result of last expression

एकमात्र अंतर यह है कि हम ª`abcअंत में संलग्न हैं , जो मूल रूप से जावास्क्रिप्ट में है ||"abc"। चूंकि पहले भाग का परिणाम हमेशा एक गैर-रिक्त स्ट्रिंग (सत्य) होता है, ||कभी नहीं चलता है।

एक ही लंबाई के कई वैकल्पिक संस्करण हैं:

"iQ ²ª`abc"iQ ²ª`abc   quine||"abc"
"iQ ²ª$abc"iQ ²ª$abc   quine||abc
"iQ ²ª{abc"iQ ²ª{abc   quine||function(){ ... }
"iQ ²ªXabc"iQ ²ªXabc   quine||X.a(...) (X could be any uppercase letter or digit)
"iQ ²//abc"iQ ²//abc   quine//abc      (// is a comment in JS/Japt)
"iQ ²;[abc"iQ ²;[abc   quine;          (unmatched [ causes a parsing error)

Answer 11

CJam , 16 14 बाइट्स

"`_~"q`';++`_~

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

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

"`_~"           e# Push "`_~"
     q`         e# Push a string representation of the input (input wrapped in quotes)
       ';       e# Push a semicolon
         ++     e# Concatenate all this together
           `    e# Get the string representation of the resulting string
            _~  e# Duplicate it and eval it (pushing the original string on the stack again)

जो कुछ इस तरह का उत्पादन करता है "`_~\"test\";"`_~"test";।

Answer 12

जावास्क्रिप्ट, 21 बाइट्स

$=_=>`$=${$}/*${_}*/`

Answer 13

पर्ल 5 , 35 बाइट्स

$_=q{say"\$_=q{$_};eval"#}.<>;eval

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