सामान्यीकृत क्वीन जेनरेटर

Question

चुनौती

इस चुनौती में, आप एक स्रोत भाषा S और लक्ष्य भाषा निर्दिष्ट करते हैंT । आपका कार्य निम्नलिखित कार्यक्रम Pको भाषा में लिखना है S। यदि Qभाषा में एक वैध कार्यक्रम Tइनपुट के रूप में दिया जाता है P, तो यह Rभाषा में एक वैध कार्यक्रम का उत्पादन करेगा Tजो कोई इनपुट और आउटपुट नहीं लेता है Q(R), अर्थात, प्रोग्राम Qको स्रोत कोड पर लागू किया जाता है R। इसके अलावा , आपको अपने उत्तर को एक निर्विवाद उदाहरण कार्यक्रम Q(अधिक दिलचस्प, बेहतर, हालांकि आप इसके लिए कोई अंक नहीं देते हैं), परिणामी कार्यक्रम Rऔर के आउटपुट में प्रस्तुत करना चाहिए R। यह कोड-गोल्फ है, इसलिए Pजीत के लिए सबसे छोटा कोड है ।

दूसरे शब्दों में, यह एक "सार्वभौमिक क्वीन कंस्ट्रक्टर" लिखने के बारे में एक चुनौती है जो सामान्यीकृत quines के मनमाने प्रकार का निर्माण कर सकता है।

स्पष्टीकरण

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

एक उदाहरण

मान लीजिए कि मैं पायथन को अपनी स्रोत भाषा के रूप में, और हास्केल को अपनी लक्षित भाषा के रूप में चुनता हूं, और मुझे आगे की आवश्यकता है कि इनपुट प्रोग्राम String -> Stringनाम के फ़ंक्शन की एक-पंक्ति परिभाषा होनी चाहिए f। अगर मैं स्ट्रिंग-रिवर्सल प्रोग्राम देता हूं

f x = reverse x

मेरे पायथन प्रोग्राम के इनपुट के रूप में P, यह एक और हास्केल प्रोग्राम के सोर्स कोड को आउटपुट करेगा R। यह प्रोग्राम स्रोत कोड के STDOUT पर प्रिंट करता है R, लेकिन उलटा होता है। यदि Pपहचान समारोह दिया जाता है

f x = x

इनपुट के रूप में, आउटपुट प्रोग्राम Rएक क्वीन है।

Answer 1

स्रोत = लक्ष्य = सीजेएम, १ ९ १ by १६ बाइट्स

{`"_~"+}`)q\"_~"

यह मानता है कि इनपुट प्रोग्राम Q(STDIN पर दिया गया) कुछ CJam स्निपेट है जो स्टैक के शीर्ष पर एक स्ट्रिंग की अपेक्षा करता है और स्टैक के शीर्ष पर एक और स्ट्रिंग छोड़ता है।

इसका परीक्षण यहां करें।

उदाहरण

1. पहचान सिर्फ एक खाली स्निपेट होगी, इसलिए STDIN खाली प्रिंट छोड़ देगा

   {`"_~"+}_~
   

   जो एक अतिरिक्त के साथ मानक क्वीन है +।

2. CJam में एक स्ट्रिंग को उल्टा करने के लिए, आप उपयोग कर सकते हैं W%, इसलिए इसे STDIN पर रखें, इससे पैदावार होती है:

   {`"_~"+W%}_~
   

   जिसे हम प्राप्त करने के लिए दौड़ सकते हैं

   ~_}%W+"~_"`{
   

3. एक तीसरे उदाहरण के रूप में, हम एक स्निपेट का उपयोग करते हैं जो रिक्त स्थान के साथ एक स्ट्रिंग को काटता है ' *:। Pइनपुट के रूप में उस के साथ चल रहा है

   {`"_~"+' *}_~
   

   जो बदले में प्रिंट

   { ` " _ ~ " + '   * } _ ~  
   

4. यह अब भी काम करता है अगर Qइसमें लाइन ब्रेक शामिल हैं (हालांकि सीजेएम में यह कभी आवश्यक नहीं है)। यहां एक लाइन ब्रेक के साथ एक प्रोग्राम है, जो एक स्ट्रिंग से सभी लाइन ब्रेक को हटाता है (अनावश्यक रूप से जटिल तरीके से - लाइनों में विभाजित हो, फिर सम्मिलित हों):

   N/
   ""
   *
   

   यह निम्नलिखित में परिणाम R:

   {`"_~"+N/
   ""
   *}_~
   

   जो बदले में प्रिंट

   {`"_~"+N/""*}_~
   

व्याख्या

आइए पहले उत्पादित उत्पादन को देखें:

मानक सीजाम क्वीन है

{`"_~"}_~

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

• ब्लॉक पुश करें {`"_~"}।
• इसके साथ डुप्लिकेट करें _।
• के साथ प्रतिलिपि निष्पादित करें ~।
• अब ब्लॉक के अंदर, `पहले ब्लॉक को उसके स्ट्रिंग प्रतिनिधित्व में बदल देता है।
• "_~" स्रोत के दो पात्रों को धक्का देता है जो ब्लॉक का हिस्सा नहीं हैं (और इसलिए स्ट्रिंग प्रतिनिधित्व से गायब है)।
• कार्यक्रम के अंत में बैक टू बैक दो तार छपे हैं।

^{मूल क्वीन में `यह अनावश्यक है, क्योंकि यदि आप ब्लॉक को छोड़ देते हैं जैसा कि यह है, तो यह प्रोग्राम के अंत में सभी को एक ही प्रिंट करता है।}

मेरे कार्यक्रम Pका आउटपुट इस स्निपेट का एक संशोधित संस्करण है। सबसे पहले, मैंने +ब्लॉक में एक जोड़ा है , जो दो तारों को एक स्ट्रिंग में सम्‍मिलित करता है जिसमें संपूर्ण स्रोत होता है। ध्यान दें कि यह सच है कि मैं ब्लॉक के अंदर क्या करता हूं, कोई भी बात नहीं होगी, क्योंकि यह सब स्ट्रिंग प्रतिनिधित्व के साथ जोड़ा जाएगा `। अब मैं बस के बाद प्रोग्राम / स्निपेट Qको ब्लॉक के अंदर रख सकता हूं +, ताकि यह प्रिंट होने से पहले स्रोत स्ट्रिंग को संशोधित कर सके। फिर से, चूंकि Qब्लॉक के अंदर जाता है, यह उक्त स्रोत स्ट्रिंग का हिस्सा होगा।

संक्षेप में, Pप्रिंट

{`"_~"+Q}_~

अब, मैं इस आउटपुट के निर्माण के बारे में कैसे जाना जाता हूँ P:

{`"_~"+}         "Push the block without Q.";
        `        "Turn it into a string. This is shorter than writing a string right away,
                  because I'd have to escape the quotes, and I'd need two quotes instead of
                  one backtick.";
         )       "Pop off the last character (the brace) and push it on the stack.";
          q      "Read input Q.";
           \     "Swap Q with the brace.";
            "_~" "Push the final two characters.";

कार्यक्रम के अंत में चार तार स्वचालित रूप से (बैक-टू-बैक) मुद्रित होते हैं।

Comments

खैर, यह उपवास था! और निश्चित रूप से हरा मुश्किल है। स्पष्टीकरण भी अच्छा है।

— जर्गर्ब नोव

आपने कहां सीखा कि डब्ल्यू% उलटफेर करता है? dl.dropboxusercontent.com/u/15495351/cjam.pdf के पास यह नहीं है

— Faraz Masroor

क्या तरीकों की एक पूरी सूची है?

— फराज मसरूर

@FarazMasroor sourceforge.net/p/cjam/wiki/Basic%20operators/#percent (नंबर 3) ... यह एक ऐसी विशेषता है, जो कि गोल्फस्क्रिप्ट से उधार ली गई थी और किसी समय किसी ने मुझे बताया था कि यह गोल्फस्क्रिप्ट में कैसे काम करती है। ऐसा प्रतीत होता है कि यह एक सामान्य मुहावरा है कि यह कुछ अजीब अंतर्निहित ज्ञान है जो हर CJam / GS उपयोगकर्ता के पास है, लेकिन वास्तव में इसे बहुत जगहों पर नहीं समझाया गया है। (अधिक जानकारी के लिए, अच्छी तरह से प्रलेखित नहीं किए गए ऑपरेटर, sourceforge.net/p/cjam/wiki/Operators देखें )

— मार्टिन एंडर

Answer 2

हास्केल अभिव्यक्ति → हास्केल अभिव्यक्ति, 41 बाइट्स

((++)<*>show).('(':).(++")$(++)<*>show$")

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

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

P $ "Q"= द्वारा ((++)<*>show).('(':).(++")$(++)<*>show$") $ "Q"निर्मित "R"है

1. (++")$(++)<*>show$"): स्ट्रिंग को जोड़ना ")$(++)<*>show$",
2. ('(':): चरित्र को प्रस्तुत करना '(', और
3. (++)<*>show(= \x->x++show x): का एक उद्धृत संस्करण लागू करना,

परिणामस्वरूप "R"= "(Q)$(++)<*>show$\"(Q)$(++)<*>show$\""।

R= (Q)$(++)<*>show$"(Q)$(++)<*>show$"द्वारा काम करता है

1. स्ट्रिंग लेना "(Q)$(++)<*>show$",
2. (++)<*>show: उस के एक उद्धृत संस्करण को लागू करना,
3. Qउस पर आवेदन करना,

परिणामस्वरूप Q "(Q)$(++)<*>show$\"(Q)$(++)<*>show$\""= Q "R"।

(चारों ओर के परचेस Qआवश्यक हैं क्योंकि Qइसमें $आसानी से जैसे ही हो सकता Rहै, और $दुर्भाग्य से सही-सहयोगी है।)

डेमो

λ> putStrLn $ ((++)<*>show).('(':).(++")$(++)<*>show$") $ "id"
(id)$(++)<*>show$"(id)$(++)<*>show$"
λ> putStrLn $ (id)$(++)<*>show$"(id)$(++)<*>show$"
(id)$(++)<*>show$"(id)$(++)<*>show$"
λ> putStrLn $ ((++)<*>show).('(':).(++")$(++)<*>show$") $ "reverse"
(reverse)$(++)<*>show$"(reverse)$(++)<*>show$"
λ> putStrLn $ (reverse)$(++)<*>show$"(reverse)$(++)<*>show$"
"$wohs>*<)++($)esrever("$wohs>*<)++($)esrever(
λ> putStrLn $ ((++)<*>show).('(':).(++")$(++)<*>show$") $ "length"
(length)$(++)<*>show$"(length)$(++)<*>show$"
λ> print $ (length)$(++)<*>show$"(length)$(++)<*>show$"
44

Comments

न केवल $कोष्ठक की जरूरत है, बल्कि अनुगामी let, doया लंबोदर भाव भी हैं।

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

@ ØrjanJohansen ठीक है, लेकिन मुझे लगता है कि अनुमति नहीं देता है एक भाषा सबसेट परिभाषित किया जा सकता था unparenthesized लैम्ब्डा / let/ if/ case/ doअगर मैं उन्हें अपने आप को फेंकना नहीं है। शायद यह सिर्फ इतना है कि मेरे पास नहीं था।

— एंडर्स कासोर्ग

Answer 3

स्रोत = लक्ष्य = जावास्क्रिप्ट, 66

console.log("function a(){console.log("+prompt()+"(a+'a()'))}a()")

क्यू के लिए मान्यताओं:

• Q एक स्ट्रिंग-टू-स्ट्रिंग जावास्क्रिप्ट अनाम फ़ंक्शन होना चाहिए।

उदाहरण:

• उलटा । क्यू =function(s) { return s.split('').reverse().join(''); }

इस मामले में, P(Q)(या R) होगा: function a(){console.log(function(s) { return s.split('').reverse().join(''); }(a+'a()'))}a()और इसे निष्पादित करने से, हमें मिलेगा: )(a}))')(a'+a(} ;)''(nioj.)(esrever.)''(tilps.s nruter { )s(noitcnuf(gol.elosnoc{)(a noitcnufजो बिल्कुल वैसा ही है Q(R)।

• पहचान । क्यू =function(s) { return s; }

इस स्थिति में, P(Q)(या R) होगा: function a(){console.log(function(s) { return s; }(a+'a()'))}a()जो एक जावास्क्रिप्ट क्वीन है । कहने की जरूरत नहीं है, Q(R)क्यू ही होगा, क्योंकि क्यू आइडेंटिटी फंक्शन है।

---

कुछ नोट:

जावास्क्रिप्ट में एसटीडीआईएन पारंपरिक रूप से है prompt(), हालांकि, मैंने खुद को alert()कॉपी-पेस्ट का उपयोग करके प्रोग्रेम के रूप में रन आउटपुट की प्रक्रिया को आसान बनाने के लिए, एसटीडीयूएसटी की परंपरा से परहेज करने की अनुमति दी । (मुझे एहसास है कि जब मैं बदल रहा हूं तो 12 अक्षर तक बचा सकता हूं alert())।

मैं ES6 में चीजों को बहुत कम कर सकता हूं, लेकिन मैं अभी नेटिव जावास्क्रिप्ट के साथ रहना चाहता हूं। मैं अनुभव के लिए भविष्य में S = Scala, T = ECMA6 उत्तर प्रस्तुत करने पर विचार कर रहा हूं।

मुझे यह भी पता है कि जावास्क्रिप्ट कोड-गोल्फ में लगभग कभी भी सीजेएम को हरा नहीं सकता है , लेकिन मुझे यह चुनौती लेनी थी! यह एक मजेदार था।

Comments

धन्यवाद! यह वास्तव में विभिन्न स्रोत और लक्ष्य भाषाओं के साथ एक प्रविष्टि के लिए अच्छा होगा।

— जर्बर्ग

Answer 4

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

“ṚƓ^ṾṂ’³3

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

क्यू एक 7 फ़ंक्शन है (यानी जो शीर्ष स्टैक तत्व से परे नहीं दिखता है, और आई / ओ स्टैक के माध्यम से होता है), और कमांड-लाइन तर्क के रूप में दिया जाता है।

व्याख्या

7 कार्यक्रम

7 में सार्वभौमिक क्वीन कंस्ट्रक्टर जिसका उपयोग मैं यहां करता हूं:

717162234430…3

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

कार्यक्रम का शेष एक एकल स्टैक तत्व है (इसमें संतुलित 7s और 6s) है, जो निम्नलिखित को चलाता है:

717162234430…3
 1716           Push a stack element "7" onto the stack
     2          Copy it
      23        Pop and output one of the copies (selecting format 7)
        4430    Prepend it to the top of stack
             3  Output it

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

यह स्टैक तत्व अपने स्वयं के स्रोत कोड पर कैसे प्राप्त करता है? ठीक है, जब कार्यक्रम के अंत तक पहुँच गया है, 7 evals डिफ़ॉल्ट रूप से शीर्ष स्टैक तत्व। हालांकि, यह वास्तव में प्रक्रिया में स्टैक से पॉप नहीं हुआ है, इसलिए जिस स्टैक तत्व शाब्दिक का evalनेतृत्व किया गया था वह अभी भी है। (दूसरे शब्दों में, कार्यक्रम अपने स्वयं के स्रोत को नहीं पढ़ रहा है - जैसा कि इस तथ्य से स्पष्ट है कि यह 7कार्यक्रम की शुरुआत में देखने में असमर्थ है , जो एक शाब्दिक भाग के बजाय एक स्टैक तत्व विभाजक है - लेकिन इसके बजाय, यह ज्यादातर ऐसे शाब्दिक होते हैं जो evalडिफ़ॉल्ट रूप से नेतृत्व करते हैं।)

जेली कार्यक्रम

यह शायद मैंने लिखा है कम से कम जेली की तरह जेली कार्यक्रमों में से एक है; यह तीन nilads (होते हैं “ṚƓ^ṾṂ’, ³, 3) है, जो अनुक्रम में सिर्फ उत्पादन कर रहे हैं, क्योंकि कोई आपरेशन उन पर प्रदर्शन कर रहे हैं। 3स्पष्ट करने के लिए पर्याप्त है, बस एक पूर्णांक लगातार किया जा रहा है। ³यदि आप जेली पता भी सरल है: यह पहली बार कमांड लाइन तर्क के लिए जेली की स्पष्ट अंकन (जो वह जगह है जहाँ जेली आम तौर पर अपने इनपुट लेता है) है। जेली कार्यक्रम के बाकी मेरे 7 सार्वभौमिक क्वीन कंस्ट्रक्टर के थोक का प्रतिनिधित्व करता है: इस तथ्य का फायदा उठाकर कि 7 में सभी आदेशों को एएससीआईआई अंकों का उपयोग करके दिखाया जा सकता है, हम व्याख्या कर सकते हैं717162234430आदेशों की एक श्रृंखला के रूप में नहीं, या यहां तक ​​कि एक अष्टक संख्या के रूप में (जैसे कि यह वैचारिक रूप से है), लेकिन एक दशमलव संख्या के रूप में, जिसका अर्थ है कि हमें आउटपुट के लिए किसी विशेष प्रारूपण की आवश्यकता नहीं है। वह दशमलव संख्या “ṚƓ^ṾṂ’जेली के संपीड़ित पूर्णांक संकेतन में बन जाती है।

उदाहरण

यदि हम 24053प्रोग्राम Q के रूप में देते हैं , तो हमें निम्न आउटपुट मिलेगा:

717162234430240533

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

2405 शीर्ष स्टैक तत्व को स्वयं में सम्मिलित करता है:

2405   Stack   Explanation
       x
2      x|x     Duplicate top of stack
 4     x||x    Swap two stack elements, with an empty element between
  0    x|(X)   Escape the top stack element, then concatenate the top two
   5   xx      Execute the top stack element

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

जैसे, परिणामी प्रोग्राम R को चलाने से हमें R की दो प्रतियाँ मिलती हैं:

7171622344302405371716223443024053

Answer 5

CJam → CJam, 13 बाइट्स

{`"_~"+7}_~qt

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

इनपुट Qएक कोड स्निपेट होना चाहिए जो स्टैक में एकमात्र स्ट्रिंग को संशोधित करता है। Qस्टड से पढ़ा जाता है।

उदाहरण

इनपुट:

S*W%

यह हर दो वर्णों के बीच एक स्थान जोड़ता है, और स्ट्रिंग को उलट देता है।

आउटपुट:

{`"_~"+S*W%}_~

सामान्यीकृत कुनैन का उत्पादन:

~ _ } % W * S + " ~ _ " ` {

व्याख्या

{`"_~"+7}_~      e# Evaluate a generalized quine in CJam that only appends a 7.
q                e# Read the input.
t                e# Replace the 7th character (0-based) with the input.

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

यह हो सकता है {`"_~"+ }_~7qtकि अंतरिक्ष पेलोड के प्लेसहोल्डर है। लेकिन 7एक बाइट को बचाने के लिए पेलोड को बदलना ।

Answer 6

चारकोल → पर्ल (5), 29 33 बाइट्स

Ａ$_=q(αＡ);evalβαＳ"\α$_β\n";printβ

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

पर्ल प्रोग्राम क्यू को एक स्निपेट वापस करना चाहिए जो इनपुट को एक स्ट्रिंग के रूप में अपने दाहिने हाथ की ओर ले जाता है और चर में आउटपुट प्रदान करता है $_। (मनमाने ढंग से पर्ल कार्यों को इस रूप में लपेटकर के रूप में परिवर्तित किया जा सकता है sub x {…}; $_=x। ज्यादातर मामलों में, हालांकि, पर्ल के वाक्यविन्यास का अर्थ है कि कोई रैपिंग की आवश्यकता नहीं है।)

व्याख्या

द पर्ल

यहाँ सार्वभौमिक पर्ल क्वीन निर्माता जैसा दिखता है:

$_=q(…"\$_=q($_);eval";print);eval

(ज्यादातर मामलों में आप इसे नीचे करना चाहेंगे $_=q(say…"\$_=q($_);eval");eval , लेकिन मुझे यकीन नहीं है कि आप मनमाने ढंग से पर्ल कोड को …वहां फिट कर सकते हैं ।)

दूसरे शब्दों में, हमारे पास एक बाहरी आवरण है $_=q(…);evalजो एक स्ट्रिंग को असाइन करता है $_और फिर उसका मूल्यांकन करता है। रैपर के अंदर "\$_=q($_);eval", यानी हमारे द्वारा संग्रहित मूल्य का उपयोग करके अपनी सामग्री के साथ रैपर का पुनर्निर्माण $_, साथ ही उपयोगकर्ता द्वारा निर्दिष्ट कोड क्यू, प्लसprint आउटपुट प्रिंट करने के लिए। (दुर्भाग्य से हम उपयोग नहीं कर सकते हैं say; यह एक नई पंक्ति जोड़ता है, और यह quines में प्रासंगिक है।)

चारकोल

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

कुछ प्रयास करने के बाद, मैं चारकोल पर बस गया, जिसे मैंने पहले कभी इस्तेमाल नहीं किया है (और जो वास्तव में कुछ प्रलेखन के साथ कर सकता है); यह ASCII कला के लिए डिज़ाइन किया गया है लेकिन एक आयाम में भी तार लिखने में सक्षम है। ASCII वर्ण चारकोल में शाब्दिक रूप से मुद्रित होते हैं, जिसका अर्थ है कि निरंतर तारों को प्रिंट करना कोई बॉयलरप्लेट नहीं लेता है, और हम Ｓप्रोग्राम में उपयोगकर्ता इनपुट से लिए गए स्ट्रिंग को प्रक्षेपित करने के लिए कमांड का उपयोग कर सकते हैं ।

हालांकि (थोड़ा) छोटा होना संभव है। पर्ल यूनिवर्सल क्वीन कंस्ट्रक्टर में दो काफी लंबे दोहराया खंड होते हैं। इस प्रकार हम Ａउन्हें चर को निर्दिष्ट करने के लिए कमांड का उपयोग कर सकते हैं (जैसे Ａ…αकि चर को असाइन करता हैα ), और बस उनके नाम का उपयोग कर के माध्यम से स्ट्रिंग हम मुद्रण में चर को जोड़। यह स्ट्रिंग को शाब्दिक रूप से लिखने पर कुछ बाइट्स बचाता है।

दुर्भाग्य से, चारकोल कार्यक्रम के लिए एक नई रूपरेखा भी जोड़ते हैं, लेकिन यह बहुत बड़ी बात नहीं है; यह बस एक के लिए दो बाइट्स की लागत है\n क्यू के इनपुट के लिए उस newline को जोड़ने के है।

उदाहरण

यदि हम इनपुट देते हैं $_=reverse(जो एक स्ट्रिंग को उलट देता है), तो हमें निम्न आउटपुट मिलते हैं:

$_=q($_=reverse"\$_=q($_);eval\n";print);eval

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

जो एक क्वीन-एक जैसा है जो अपने स्रोत को पीछे की ओर प्रिंट करता है, जैसा कि अपेक्षित था।

Answer 7

जेली → अंडरलोड , 15 बाइट्स

“(a(:^)*“S):^”j

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

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

व्याख्या

द अंडरलोड

यहाँ उपयोग किए गए अंडरलोड यूनिवर्सल क्वाइन निर्माता हैं:

(a(:^)*…S):^

अधिकांश कार्यक्रम एकल शाब्दिक है। हम :^उसका अनुसरण करते हैं , जो उसे कॉपी करता है, फिर एक कॉपी का मूल्यांकन करता है (दूसरी कॉपी को स्टैक पर छोड़कर)।

जब शाब्दिक मूल्यांकन शुरू होता है, तो हम भागते हैं a(बचते हैं, जो इसे मूल प्रोग्रामए के रूप में उसी रूप में वापस लाते हैं), और (:^)*(जो एपेंड करता है :^), इस प्रकार पूरे कार्यक्रम के स्रोत कोड को फिर से संगठित करता है। फिर हम इसे अनियंत्रित तरीके से बदलने के लिए फ़ंक्शन Q चला सकते हैं, और परिणाम को प्रिंट कर सकते हैंS ।

द जेली

मैं इस समय चारकोल का उपयोग नहीं कर सकता क्योंकि प्रोग्राम के अंत में एक मान्य अंडरलोड दुभाषिया दुर्घटनाग्रस्त हो जाता है यदि प्रोग्राम एक नई सीमा के साथ समाप्त होता है। (कुछ अंडरलोड दुभाषियों, जैसे कि टीआईओ पर एक, इस नियम को लागू नहीं करते हैं, लेकिन मैं ठीक से पोर्टेबल होना चाहता था।) दुर्भाग्य से, चारकोल स्वाभाविक रूप से अपने उत्पादन में नए सिरे से अनुगामी बनाता है। इसके बजाय, मैंने जेली का उपयोग किया, जो इस तरह के सरल मामलों में लगभग समान है; कार्यक्रम में दो तत्वों ( ““”) के साथ एक सूची शाब्दिक होती है , और उन्हें इनपुट पर शामिल किया जाता है ( j), इस प्रकार प्रोग्राम में उपयोगकर्ता इनपुट को प्रक्षेपित किया जाता है।

उदाहरण

इनपुट का उपयोग करना :S^(एक प्रति प्रिंट करें, फिर मूल का मूल्यांकन करें), हमें निम्न अंडरलोड कार्यक्रम मिलता है:

(a(:^)*:S^S):^

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

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

Comments

चारकोल अब (yay)

— केवल

Answer 8

RProgN 2 , 11 बाइट्स

'{`{.%s}{'F

कार्यक्रम की व्याख्या

'{`{.%s}{'F
'{`{.%s}{'  # Push the string "{`{.%s}{" to the stack.
          F # Format the input with the top of the stack as a template. Which produces {`{.<INPUT>}{

काफी स्पष्टीकरण

उत्पन्न होने वाली क्वीन सरल है, फिर भी एक छोटी और मीठी क्वीन बनाने के लिए RProgN2 में बेजोड़ फंक्शन हैंडलर की कार्यक्षमता का उपयोग करता है, जिसे "लूपिंग" क्वीन कहा जाता है। यह एक आश्चर्यजनक रूप से एक समान अवधारणा है <> <quine।

{`{.}{
{`{.}   # Push the function {`{.} to the stack.
     {  # Try to define a new function, fail, loop back to index 1. (Which in turn, skips the function definition.)
 `{     # Push the string "{" to the stack.
   .    # Concatenate the top two values of the stack, which stringifies the function, then appends { to it.
    }   # Try to terminate a function, fail quietly, and terminate the program.

बेशक, इस कुनैन की संरचना की वजह से, कुछ भी नहीं, लेकिन सच नो-ऑप्स (जो कड़े नहीं होते हैं) को कॉन्फेटनेट फ़ंक्शन के बाद रखा जा सकता है, और

कुछ खदानें

• {`{.i}{: आउटपुट {}i.{`{। iसिर्फ "उलटा" फ़ंक्शन है, इसलिए यह प्रोग्राम खुद को उलट देता है।
• {`{.S§.}{: आउटपुट ..S`{{{}§। Sस्ट्रिंग को वर्णों §के ढेर में परिवर्तित करता है, स्टैक को लेक्सोग्राफिक रूप से सॉर्ट करता है, फिर .इसे एक साथ जोड़ता है, खुद को क्रमबद्ध करता है।

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