डबल-स्लिट क्वीन

Question

उद्देश्य:

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

नियम:

1. आप दोनों कार्यक्रमों के लिए किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं, दोनों के लिए समान प्रोग्रामिंग भाषा आवश्यक नहीं है।
2. आपके प्रोग्राम को किसी फ़ाइल, फ़ाइल नाम, नेटवर्क, अन्य प्रोग्राम या किसी अन्य चीज़ से कोई इनपुट नहीं लेना चाहिए।

अनिवार्य मानदंड:

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

उदाहरण:

इस कार्यक्रम का स्रोत कोड एक होने से :

"QIE"

इस उदाहरण के दो प्रोग्राम कोड स्रोत :

"UN"

फिर दोनों कार्यक्रमों से मान्य डबल-स्लिट क्विन आउटपुट होना चाहिए:

""QUINE""

यह कोड-गोल्फ है, कम से कम बाइट्स जब दोनों स्रोत कोड की लंबाई को समेटते हैं, और जाहिर है कि प्रत्येक प्रोग्राम आउटपुट की लंबाई भी जीतता है!

Comments

प्रत्येक व्यक्तिगत कार्यक्रम में भी एक क्वीन होना आवश्यक नहीं है, सही है? और प्रत्येक प्रोग्राम में कम से कम एक वर्ण होना चाहिए?

— mbomb007

@ mbomb007 यह सही है। प्रत्येक व्यक्तिगत कार्यक्रम को शुरू से अंत तक एक ज़िप की तरह दोनों स्रोत कोड वर्णों का उत्पादन करना चाहिए। खैर, मुझे लगता है कि आपको कम से कम 1 बाइट की आवश्यकता होगी एक प्रोग्राम भाषा में QUINE आउटपुट करने के लिए? दोनों प्रोग्राम से आउटपुट समान होना चाहिए।

— प्लेसेन

मुझे यकीन नहीं है कि मैं समझता हूं कि बाकी आउटपुट को लंबे स्रोत कोड के बाकी हिस्सों से सही ढंग से भरना चाहिए । कैसे किया जाएगा Aऔर XYZinterleaved? AXYZ?

— डेनिस

@ डेनिस बस पसंद है .+या zकाम करता है

— ऑप्टिमाइज़र

@ डेनिस सही। जब छोटे बाइट्स से बाहर चलाता है, तो लंबे समय तक स्रोत कोड से छोड़ा जाता है, दोनों कार्यक्रमों से आउटपुट में जोड़ा जाना चाहिए।

— प्लेसेन

Answer 1

CJam, 49 47 बाइट्स

{`:_"__~~e#QUINE"}_~

तथा

{`:_"__~~e#QUINE"}_~e#QUINE

दोनों छपते हैं

{{``""__~~""++::__""ee##QQUUIINNEE""}}__~~e#QUINE

इसे ऑनलाइन आज़माएं: प्रोग्राम 1 , प्रोग्राम 2 , वैधता का प्रमाण

वे कैसे काम करते हैं

{                }   e# Push a code block.
                  _~ e# Execute a copy.
 `                   e# Convert the code block into a string.
  :_                 e# Duplicate each character of the resulting string.
    "__~~e#QUINE"    e# Push this string.

प्रोग्राम 1 यहां समाप्त होता है और इसके पूरे स्रोत कोड (जो प्रत्येक वर्ण को दो बार दोहराया जाता है) के साथ-साथ स्टैक पर स्ट्रिंग ई # क्वीन का एक स्ट्रिंग प्रतिनिधित्व है ।

कार्यक्रम 2 अतिरिक्त पारस e#QUINE, जो एक टिप्पणी है।

दोनों स्थितियों में, CJam दो स्ट्रिंग्स को स्वचालित रूप से प्रिंट करता है, जिसके परिणामस्वरूप उपरोक्त आउटपुट होता है।

Answer 2

गंभीरता से, 46 56 42 बाइट्स

QUNX;RZtdXεj.ƒ£REIQ

हेक्स डंप:

51554e583b525a746458ee6a2e7f9f9c524549510a

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

QQUINEXR;£RƒZ⌂t.djXεεXjd.t⌂ZƒR£;RXENIUQQ

(किसी कारण से यह अदृश्य चरित्र को प्रदर्शित करता है जब यह मेरे टर्मिनल में आउटपुट करता है। मैं वास्तव में यह नहीं समझता कि 7F बाइट)।

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

Q                     Push the source to the stack
 U                    Nop
  NX                  Push and pop lyrics to 99 bottles of beer
    ;R                Make a copy of the source reversed.
      Z               Zip them together.
       t              Completely flatten the list.
        dX            Delete the trailing newline
          εj          Join it into a string.
            .         Print it with a trailing newline.
             ⌂        (This is that 7F byte that won't show up. It halts.)

कार्यक्रम के बाकी हिस्सों को निष्पादित नहीं किया गया है।

फिर दूसरी दिशा:

\n                   Nop
  Q                  Push the source code.
   IE                Nops
     R               Reverse source code to get source of first program
      £              Eval it into a function
       ƒ             Call it.

इस बिंदु पर, हम अब ऊपर पहला कार्यक्रम चला रहे हैं, इसलिए निष्पादन वहां जारी है।

मैं इस तथ्य का अत्यधिक शोषण कर रहा हूं कि कई आदेश यहां तार या खाली ढेर के लिए कुछ नहीं करते हैं। tजब स्टैक पर केवल एक आइटम होता है , तो मैं अप्रत्याशित व्यवहार का शोषण कर रहा हूं । इस कार्यक्रम को गंभीरता से भविष्य के संस्करणों में काम करने की उम्मीद न करें।

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

Comments

@ डेनिस आपने अपने कंप्यूटर पर इसका परीक्षण किया? यह मेरे अपने निर्माण के माहौल की एक कलाकृति हो सकती है।

— क्विंटोपिया

@ डेनिस एनवीएम तुम सही हो। गंभीर रूप से आउटपुट विधियों में से सभी एक लाइनफ़ीड जोड़ते हैं। मैं इसे 8 बाइट्स की कीमत पर ठीक कर सकता हूं। ऐसा लगता है कि आपका तरीका छोटा होगा (जो दुखद है क्योंकि यह तरीका कूलर IMO है)।

— क्विंटोपिया

Answer 3

GolfScript, 46 बाइट्स

{`{.}%"..~~QUINE"}.~

तथा

{`{.}%"..~~QUINE"}.~QUINE

दोनों छपते हैं

{{``{{..}}%%""....~~~~QQUUIINNEE""}}..~~QUINE

इसे ऑनलाइन आज़माएं: प्रोग्राम 1 , प्रोग्राम 2 , वैधता का प्रमाण

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

{`{.}%"..~~QUINE"}.~

{                }    # Push a code block.
                  .~  # Execute a copy.
 `                    # Convert the code block into a string.
  {.}%                # Duplicate each character of the resulting string.
      "..~~QUINE"     # Push that string.

प्रोग्राम 2 के अतिरिक्त कोड का स्रोत कोड QUINE\n, जो दो अपरिभाषित टोकन हैं।

Answer 4

पर्ल, 61 + 60 = 121 बाइट्स

कार्यक्रम 1:

$x=q<print"\$x=q<$x>;eval\$x#"=~s/./$&$&/gr,QUINE>;eval$x#QIE

कार्यक्रम 2:

$x=q<print"\$x=q<$x>;eval\$x#"=~s/./$&$&/gr,QUINE>;eval$x#UN

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

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