त्रि-इंटरक्वाइन - तीन प्रोग्राम जो एक दूसरे को लूप में आउटपुट करते हैं

Question

संबंधित: इंटरक्वाइन

प्रोग्राम ए आउटपुट, रन होने पर बी के कोड को प्रोग्राम करता है, और बी आउटपुट सी के सोर्स को, और सी आउटपुट ए के सोर्स को।

इस बार आप दो वर्णों का आदान-प्रदान और फिर से विनिमय नहीं कर सकते :)

आवश्यकताएँ:

• सभी कार्यक्रमों में केवल एक ही भाषा
• मानक कमियां प्रतिबंध लागू होते हैं
• सभी कार्यक्रम अलग हैं। एक कार्यक्रम जो स्वयं आउटपुट करता है वह योग्य नहीं है। दो कि आउटपुट एक दूसरे के योग्य भी नहीं है।
• सभी कार्यक्रम गैर-रिक्त हैं, या कम से कम 1 बाइट लंबाई में हैं।
• पढ़ने के लिए कुछ भी नहीं है क्योंकि स्टड से जुड़ा हुआ है /dev/null(यदि आप कर सकते हैं तो आप इस नियम का दुरुपयोग कर सकते हैं )। आउटपुट स्टडआउट जाता है।
• यादृच्छिक परिणामों को उत्पन्न करने वाले कार्यों का उपयोग न करें।

अतिरिक्त:

• यदि संभव हो तो स्पष्टीकरण दें

स्कोर सबसे छोटे से एक की लंबाई है (क्या आप एक छोटे से एक लंबा कार्यक्रम उत्पन्न कर सकते हैं?)। कृपया सभी कार्यक्रमों की लंबाई लिखें और सबसे छोटी संख्या को उजागर करें। अनुगामी न्यूलाइन की गिनती नहीं है। सबसे कम स्कोर जीतता है ।

Comments

सम्बंधित। (एक ही बात, विभिन्न भाषाएँ।)

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

Answer 1

पायथन 3 , 50 बाइट्स

s='s=%r;print(s%%(s,%i*2%%7))';print(s%(s,1*2%7))

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

पिछले अभिव्यक्ति से चला जाता है 1*2%7के लिए 2*2%7करने के लिए 4*2%7फिर वापस करने के लिए 1*2%7।

Comments

एन-इंटरक्वाइन के लिए एक सार्वभौमिक समाधान की तरह दिखता है। आपको केवल 7 को (2 ^ n) -1 से बदलना होगा।

— 34 जुग

पायथन 2 में, मानचित्रण 1-2/_एक 3-चक्र बनाता है (1,-1,3), जिसके लिए भागने की आवश्यकता नहीं होने से एक बाइट बचाता है %।

— xnor

@iBug या बड़े के लिए भी कम n, s='s=%r;print(s%%(s,-~%i%%3))';print(s%(s,-~1%3))की जगह 3के साथn

— PurkkaKoodari

Answer 2

RProgN 2 , 12 8 बाइट्स

1
«\2*7%

व्याख्या की

1   # Push the digit to the stack.

«\2*7%
«       # Define a function from here to the matching ». As there is no matching », define it from here to the end of the program, and continue running.
 \      # Flip the function under the constant number.
  2*    # Multiply by 2.
    7%  # Modulo 7.

RProgN डिफ़ॉल्ट रूप से कैसे आउटपुट करता है, इसकी सुविधाजनक प्रकृति के कारण, यह संख्या छोड़ता है, जो पहली पंक्ति में 1, 2 और 4 के बीच लूप करता है, और दूसरे पर फ़ंक्शन का कठोर संस्करण। @LeakyNun के पायथन उत्तर से प्रेरित

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

Answer 3

CJam , 17 बाइट्स

{sZZe\6Ye\"_~"}_~

{s6Ze\ZYe\"_~"}_~

{sZ6e\ZYe\"_~"}_~

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

शायद इष्टतम नहीं है, लेकिन यह पिछली चुनौती के लिए मेरे दृष्टिकोण का एक संशोधन है ।

मूल विचार एक ही है, लेकिन हम दो स्वैप करते हैं, जिनमें से एक हमेशा एक ऑप है। प्रभावित सूचकांक हैं 2, 3और 6:

1:     {sZZe\6Ye\"_~"}_~
ZZe\             does nothing
       {sZZe\6Ye\"_~"}_~
6Ye\     \   /
          \ /
           X
          / \
         /   \
2:     {s6Ze\ZYe\"_~"}_~
6Ze\      \  /
           \/    doesn't really do anything
           /\
          /  \
       {s6Ze\ZYe\"_~"}_~
ZYe\     \/
         /\
3:     {sZ6e\ZYe\"_~"}_~
Z6e\      \  /
           \/
           /\
          /  \
       {sZZe\6Ye\"_~"}_~
ZYe\     \/      doesn't really do anything 
         /\
1:     {sZZe\6Ye\"_~"}_~

Answer 4

CJam , 14 बाइट्स

{_]3/W="_~"}_~

{_]3/W="_~"}{_]3/W="_~"}_~

{_]3/W="_~"}{_]3/W="_~"}{_]3/W="_~"}_~

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

अन्य कार्यक्रम क्रमशः 26 और 38 बाइट्स लंबे होते हैं।

व्याख्या

फिर भी एक और दृष्टिकोण!

{       e# Again, the usual quine framework. In this case, there might
        e# be one or two additional copies of the block on the stack.
  _     e#   Duplicate the top copy of the block.
  ]     e#   Wrap all copies in an array.
  3/    e#   Split into chunks of 3. For the first two programs, this will
        e#   just wrap all of them in an array. For the third program, this
        e#   splits the fourth copy off from the first three.
  W=    e#   Select the last chunk. So `3/W=` does nothing for the first
        e#   two programs, but discards three copies once we get to four.
  "_~"  e#   Push the remainder of the program.
}_~

Answer 5

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

“Ḥ%7Øv;”Ṙv1

इसने एक ही प्रोग्राम को 1 के स्थान पर 2 से बदल दिया, जो 2 को 4 से बदल दिया , जो मूल प्रोग्राम को उत्पन्न करता है।

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

Answer 6

पायथन 3, 127, 127 और 127 बाइट्स

a='a=%r;b=%r;c=%r;print(b%%(b,a,c))';b='b=%r;a=%r;c=%r;print(c%%(c,a,b))';c='c=%r;a=%r;b=%r;print(a%%(a,b,c))';print(b%(b,a,c))

प्रिंट

b='b=%r;a=%r;c=%r;print(c%%(c,a,b))';a='a=%r;b=%r;c=%r;print(b%%(b,a,c))';c='c=%r;a=%r;b=%r;print(a%%(a,b,c))';print(c%(c,a,b))

प्रिंट

c='c=%r;a=%r;b=%r;print(a%%(a,b,c))';a='a=%r;b=%r;c=%r;print(b%%(b,a,c))';b='b=%r;a=%r;c=%r;print(c%%(c,a,b))';print(a%(a,b,c))

यह इंटरक्वाइन प्रश्न के मेरे उत्तर पर आधारित है, जो एक सामान्य पायथन क्वीन पर आधारित है। और मुझे पता है कि जब हमें क्वाड-इंटरक्वाइन प्रश्न मिलता है तो क्या करना है;)

Answer 7

CJam , 14 बाइट्स

0{\)3%\"_~"}_~

1{\)3%\"_~"}_~

2{\)3%\"_~"}_~

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

व्याख्या

0{      e# Again, the standard CJam quine framework, but this time we have a zero
        e# at the bottom of the stack.
  \     e#   Bring the 0 to the top.
  )     e#   Increment.
  3%    e#   Mod 3 to loop from 2 back to 0.
  \     e#   Put the result underneath the block again.
  "_~"  e#   Push the remainder of the source.
}_~

Answer 8

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

eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=0)

eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=1)

eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=2)

o1.innerText = eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=0) 
o2.innerText = eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=1)
o3.innerText = eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=2)

<pre id="o1"></pre>
<pre id="o2"></pre>
<pre id="o3"></pre>

वैकल्पिक समाधान का उपयोग कर Function.prototype.toString(चीटी, 30 बाइट्स)

(f=n=>`(f=${f})(${++n%3})`)(1)

Answer 9

लैम्ब्डा कैलकुलस , 38 अक्षर, 44 बाइट्स

सभी quines की माँ पर आधारित एक सरल समाधान: y-combinator :

(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)

बीटा कटौती का उपयोग करते हुए हम देखते हैं कि यह वास्तव में एक त्रि-अंतःक्रिया है:

(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
(λy.y)(λz.z)(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
(λz.z)(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
etc.

Answer 10

जावा 8, 118 बाइट्स

v->{int i=0;String s="v->{int i=%d;String s=%c%s%2$c;return s.format(s,++i%%3,34,s);}";return s.format(s,++i%3,34,s);}

केवल int i=0;फ़ंक्शन / आउटपुट के बीच अंतर है (यह या तो है 0, 1या)2 )।

स्पष्टीकरण:

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

v->{                       // Method with empty unused parameter and String return-type
  int i=0;                 //  Integer, starting at 0, 1 or 2 depending on the version
                           //  (this is the only variation between the functions/outputs)
  String s="v->{int i=%d;String s=%c%s%2$c;return s.format(s,++i%%3,34,s);}";
                           //  String containing the unformatted source code
  return s.format(s,++i%3,s);}
                           //  Quine to get the source code, which we return as result
                           //  ++i%3 is used to cycle 0→1→2→0

अतिरिक्त स्पष्टीकरण:

क्वीन -पार्ट :

• String s इसमें बिना स्रोत वाला कोड होता है
• %s इस स्ट्रिंग को अपने साथ रखने के लिए उपयोग किया जाता है s.format(...)
• %c, %2$cऔर 34डबल-कोट्स को फॉर्मेट करने के लिए उपयोग किया जाता है (" )
• %% मॉडुलो-साइन को प्रारूपित करने के लिए उपयोग किया जाता है (% )
• s.format(s,...,34,s) यह सब एक साथ रखता है

आउटपुट / कार्यों का अंतर:

अधिकांश अन्य उत्तरों के समान दृष्टिकोण:

• int iया तो शुरू होता है 0, 1या2
• ++i%3अगले को यह बदल देती है ( 0→1; 1→2; 2→0)

Answer 11

> <> , 15 बाइट्स

1'~r2*7%nd3*>o<

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

अन्य> <> quines के समान सामान्य रूप का उपयोग करता है, लेकिन सामने एक अतिरिक्त चरित्र है जिसे 1, 2 और 4 के माध्यम से साइकिल चलाया जाता है।