धोखेबाज चक्रीय क्वीन

Question

संकल्पना

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

नियम

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

Comments

मुझे अभी भी पूरी तरह से यकीन नहीं है कि एक अर्ध-रानी क्या है।

— कॉनर ओ'ब्रायन

@ ConorO'Brien यह एक प्रोग्राम को आउटपुट करता है जो मूल प्रोग्राम को आउटपुट करता है

— dkudriavtsev

समझा। शब्दांकन काफी अस्पष्ट है।

— कॉनर ओ'ब्रायन

सबसे कम उत्तर का चयन क्यों नहीं किया जाएगा? क्या यह कैटलॉग है?

— अताको

सिर्फ रिकॉर्ड के लिए, मैं इसे एक आपसी क्वीन (कि चुनौती के लिए अलग-अलग भाषाओं की आवश्यकता होती है ) कहूंगा ।

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

Answer 1

बैश + कोरुटिल्स, 11 बाइट्स

tr xy yx<$0

यह प्रिंट करता है

tr yx xy<$0

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

बदले में, वह प्रिंट करता है

tr xy yx<$0

Comments

एक धोखा और एक आम भाषा में नहीं।

— डेन्सन

मुझे लगता है कि trकमांड को रीडायरेक्ट किया गया है $0जो अपना स्वयं का सोर्स कोड है। तो यह "धोखा" है।

— रोमन ग्रैफ

Answer 2

घोंघे, 0 बाइट्स

दूसरा कार्यक्रम है

1

पहला प्रोग्राम खाली इनपुट पर रिक्त पैटर्न के मैचों की संख्या को गिनता है (जिसमें वास्तव में 0 क्षेत्र है, लेकिन पैटर्न को हमेशा कम से कम एक बार हैक के रूप में चलाया जाता है ताकि प्रोग्राम को यह तय करने की अनुमति मिल सके कि वे खाली इनपुट पर क्या प्रिंट करना चाहते हैं)। दूसरा कार्यक्रम एक क्वांटिफायर (जैसे {1}रेगेक्स) से शुरू होता है , जो एक पार्स त्रुटि का कारण बनता है। चूंकि प्रोग्राम सफलतापूर्वक पार्स नहीं करता है, STDOUT खाली स्ट्रिंग है।

Comments

मैंने सोचा कि शायद एक भाषा थी जिसने ऐसा किया (यानी अशक्त कार्यक्रम एक गैर-रिक्त परिणाम के साथ सफल होता है, लेकिन यह परिणाम एक कार्यक्रम के रूप में कुछ भी नहीं करता है)। मैंने होम्सिंग की कोशिश की लेकिन काम करने के लिए दुभाषिया नहीं मिला। लगता है कि आपको एक और भाषा मिली जहां यह काम करता है, हालांकि। (क्या आपके पास दुभाषिया का लिंक है?)

@ ais523 github.com/feresum/PMA या tio.run/nexus/snails ।

— feersum

Answer 3

7 , 2 बाइट्स

7 एक 3-बिट वर्ण सेट का उपयोग करता है, लेकिन इनपुट बाइट्स में पैक किया जाता है (और मेटा के अनुसार, उप-बाइट चरित्र सेट के साथ भाषाओं को डिस्क पर फ़ाइल के लिए बाइट्स का उपयोग करके गिना जाता है )। यहाँ xxdकार्यक्रम का एक डंप है:

00000000: 4cf4                                     L.

इस फ़ाइल को 7 दुभाषिया को देते समय, यह निम्न प्रोग्राम को आउटपुट करेगा:

00000000: 4fa6 7f                                  O..

जो फिर से मूल कार्यक्रम को फिर से आउटपुट देगा।

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

231 7 23 मूल कार्यक्रम, ऑक्टल में अनपैकस्टैक पर 
231 पुश 237
    23 पुश 23 ढेर पर
             (निहित) कार्यक्रम में स्टैक के शीर्ष की एक प्रति संलग्न करें
            स्टैक के 2 डुप्लिकेट शीर्ष (वर्तमान में 23 )
        3      स्टैक का आउटपुट टॉप, पॉप सेकंड स्टैक तत्व

इस बिंदु पर, 7 दुभाषिया देखता है कि स्टैक के शीर्ष में कमांड ( 2और 3) हैं जो प्रतिनिधित्व योग्य नहीं हैं, इसलिए यह स्टैक के शीर्ष से बच जाता है, उत्पादन 723(जो है)। पहला कमांड आउटपुट आउटपुट फॉर्मेट का चयन करता है; इस मामले में, यह प्रारूप 7 है, "आउटपुट को उसी तरह प्रारूपित करें जैसे प्रोग्राम"। इसलिए कमांड्स आउटपुट को बाइट्स में पैक करते हैं। फिर कार्यक्रम जारी है:

२३१ 7 २३ २३
             (निहित) कार्यक्रम में स्टैक के शीर्ष की एक प्रति संलग्न करें
            स्टैक के 2 डुप्लिकेट टॉप (वर्तमान में 237 )
          स्टैक के 3    आउटपुट टॉप, पॉप सेकंड स्टैक एलिमेंट
           7   स्टैक पर एक खाली तत्व पुश करें

इस बिंदु पर, स्टैक पर खाली स्टैक तत्वों के अलावा कुछ भी नहीं है, इसलिए प्रोग्राम बाहर निकलता है। हम 23पहले आउटपुट करते हैं । यदि हम बच जाते हैं 237(और हमें करना है, क्योंकि इसमें अप्रमाणित आदेश शामिल हैं), हमें मिलता है 7231। यह सीधे आउटपुट प्राप्त करता है, जिससे प्रोग्राम का अंतिम आउटपुट 237231( प्रोग्राम के रूप में उसी तरह स्वरूपित होता है, अर्थात बाइट में पैक किया जाता है)। वह है 4fa67f। (यह ध्यान दिया जा सकता है कि 1आउटपुट को प्रभावित करने के मामले में पूरी तरह से व्यर्थ था, केवल यही कारण है कि दोनों कार्यक्रमों को अलग-अलग बनाना है।)

रनिंग 237231लगभग उसी तरह से आगे बढ़ता है; अंतर यह है कि बेकार 1पहले प्रिंट के बाद ही चलता है (और खाली तत्व को दूसरी बार प्रोग्राम के वर्तमान छोर तक पहुंचने पर अंतर्निहित रूप से हटा दिया जाता है)। फिर से, 231समाप्त होता है खुद को outputting, 23समाप्त होता है outputting खुद को एक से पहले 7, और हम प्राप्त करते हैं 231723, मूल कार्यक्रम।

पर्यवेक्षक यह ध्यान दे सकते हैं कि भाषा के "मूल" अष्टक में समान लंबाई होने के बावजूद दोनों कार्यक्रम डिस्क पर अलग-अलग लंबाई के हैं। ऐसा इसलिए है क्योंकि एक 7 प्रोग्राम को 1 बिट्स की एक मनमानी संख्या के साथ गद्देदार किया जा सकता है, और पैक्ड प्रारूप अनुगामी पैडिंग को छोड़ देता है। यहां बताया गया है कि एन्कोडिंग कैसे होती है:

2  3  1  7  2  3
010011001111010011(1...)
4   c   f   4   padding

दूसरे शब्दों में, दो बाइट्स, 4C F4कार्यक्रम का प्रतिनिधित्व करने के लिए पर्याप्त हैं, इसलिए यह सब मैंने उपयोग किया है।

Answer 4

पायथन 3, 297 279 251 243 225 218 208 180 126 111 बाइट्स

गैर धोखाधड़ी:

A=''';print(("A="+("'"*3+A)*2).translate({65:66,66:65}))''';print(("A="+("'"*3+A)*2).translate({65:66,66:65}))

यह प्रिंट:

B=''';print(("B="+("'"*3+B)*2).translate({65:66,66:65}))''';print(("B="+("'"*3+B)*2).translate({65:66,66:65}))

जिसे निष्पादित करते समय, मूल कार्यक्रम प्रिंट करता है।

Comments

वाह! ठंडा! मैं ऐसा कभी सोच नहीं सकता था।

— dkudriavtsev

Answer 5

बैच, 14 बाइट्स

@echo @type %0

जो जब cyclicquine.batआउटपुट के रूप में चलते हैं

@type cyclicquine.bat

जब चला मूल बैच फ़ाइल आउटपुट।

Answer 6

RProgN , 4 बाइट्स।

समुदाय इस तरह की चीज को एक धोखा देने वाली रानी के रूप में मानता है , जो इस प्रकार मानदंड को संतुष्ट करता है।

1
2

अनुगामी न्यूलाइन के साथ।

यह प्रिंट करता है

2
1

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

RProgN स्टैक पॉपिंग को प्रिंट करता है, इसलिए ऊपर से नीचे तक।

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

Comments

कुछ समय पहले एक चैट चर्चा हुई थी जिसमें 1\n1\nआरोप लगाया गया था कि RProgN में एक गैर-धोखाधड़ी वाला क्वीन होगा, क्योंकि 1s में से प्रत्येक एक दूसरे को प्रिंट करता है (और यह केवल धोखा माना जाएगा यदि प्रत्येक 1 स्वयं मुद्रित हो)। यह सब वास्तव में तात्पर्य है कि कभी-कभी परिभाषित करने में मुश्किल हो सकती है। (हालांकि, यह उत्तर दोनों तरह से सही है, क्योंकि प्रश्न को वास्तव में धोखा देने की आवश्यकता नहीं है , बस इसे अनुमति देता है।)

इसके अलावा, हालांकि मैं यह कहने में संकोच कर रहा था, RProgN 1\nमें तकनीकी रूप से एक वैध क्वीन है, जैसा 1कि एक स्थिर नहीं है, लेकिन एक फ़ंक्शन को कॉल जो 1स्टैक को धक्का देता है।

— अताको

उपयोग में एक उचित रानी की कई परिभाषाएँ हैं। यह कम से कम एक द्वारा अमान्य है, लेकिन संभवतः कुछ अन्य द्वारा मान्य है।

@ ais523 आपने मेरी जिज्ञासा को जगा दिया है, आपने RProgN को निर्दिष्ट किया है, फिर भी मुझे नहीं लगा कि मेरी छोटी भाषा को इतना (या कोई) ध्यान मिला। क्या विशेष रूप से RProgN के बारे में चैट, या समान सिंटैक्स वाली भाषा थी?

— एटीको

यह लगभग 7 था , जिसमें "बैकवर्ड" प्रोग्राम के सेगमेंट को प्रिंट करने की प्रवृत्ति भी है। मैं वहां दिए गए विचारों से अलग था।

Answer 7

जोल्फ, 6 बाइट्स

1q_a_q

जब चलाते हैं, तो यह आउटपुट:

q_a_q1

जो बदले में आउटपुट देता है 1q_a_q।

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

व्याख्या

1q_a_q
1       the digit one (ignored)
 q      the source code (ignored)
     q  the source code
    _   reversed
   a    and outputted
 _      and reversed (ignored)

q_a_q1
q       the source code (ignored)
     1  the digit one (ignored)
    q   the source code
   _    reversed
  a     and outputted
 _      and reversed (ignored)

Answer 8

जावास्क्रिप्ट (ईएस 6), 69 60 59 बाइट्स

(_0=_=>console.log(`(_0=${_0})()`.replace(/0/g,n=>+!+n)))()

आउटपुट:

(_1=_=>console.log(`(_1=${_1})()`.replace(/1/g,n=>+!+n)))()

---

-1 बाइट (@ETHProductions): regex में \ d के बजाय 0 का उपयोग करें

Comments

n=>1-nइसके बजाय प्रयास करें n=>+!+n।

— कॉनर ओ'ब्रायन

@Conner O'Brien दुर्भाग्य से 1regex द्वारा प्रतिस्थापित किया जाएगा।

— darrylyeo

@ETHproductions हे, मुझे इसके बारे में सोचना चाहिए था।

— darrylyeo

Answer 9

बैश + सेड, 15 बाइट्स

डेनिस के जवाब के रूप में एक ही विचार ।

sed y/xz/zx/ $0

Answer 10

बैश, कैट, और रेव, 19 16 बाइट्स

rev $0 # 0$  ver

-3 @izabera के लिए धन्यवाद

Comments

इस होगा नहीं Bash, Tacहै, और `रेव?

— कॉनर ओ'ब्रायन

rev $0 # 0$<space><space>verकिसी कारण के लिए मैं एक टिप्पणी में दो रिक्त स्थान नहीं डाल सकते हैं

— izabera

ओह, अच्छा @izabera

— NoOneIsHere

@ ConorO'Brien नहीं, tac rev-ed है cat।

— NoOneIsHere

@SeeOneRhino ओह .... मैं देखता हूं

— कॉनर ओ'ब्रायन

Answer 11

> <>, 16 बाइट्स

"$r00gol?!;50.01

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

आउटपुट

"$r00gol?!;50.10

यह यहां दिए गए एक संशोधन का है । मुझे यकीन नहीं है कि अगर यह धोखा दे रहा है, तो यह कोडबॉक्स पढ़ता है और इसे आउटपुट करता है।

Comments

आप 00g को 2- में बदल सकते हैं और यह कोडबॉक्स को पढ़े बिना एक ही बाइट काउंट रखेगा।

— टीले पेलिकन

@ Tealpelican, धन्यवाद! लक्ष्य यह माना जाता है कि इसे "धोखा" माना जाए: पी। (और मैं पूरी तरह से उस नियम को नहीं समझता)

— redstarcoder