सेल्फ-कोडिंग कोड कोड कोडी कोडी

Question

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

जब प्रोग्राम पी 2 को चलाया जाता है, तो पी 3 से 1 बाइट लंबे समय तक चलने वाले पी 3 प्रोग्राम को आउटपुट करना चाहिए। P3 को एक प्रोग्राम P4 का उत्पादन करना चाहिए जो P3 की तुलना में एक बाइट लंबा है, आदि P5, P6, ..., P, के लिए समान है।

कार्यक्रम श्रृंखला अनिश्चित काल तक, या ऐसे स्थान पर जाना चाहिए जहाँ दुभाषिया अब संभाल नहीं सकता है (लेकिन भाषा में सैद्धांतिक रूप से मान्य कार्यक्रम के रूप में रहना चाहिए)

नियम

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

प्रत्येक भाषा में बाइट्स में सबसे छोटा प्रोग्राम P1 जीत जाता है!

Comments

@ Οurous क्या ??? मैंने खुद उस टैग को नहीं जोड़ा ...

— iBug

@iBug के बावजूद, क्या सबमिशन को अपने स्वयं के सोर्स कोड को पढ़ने की अनुमति है?

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

@ आईबग "क्वीन" टैग इसे डिफ़ॉल्ट रूप से मना करता है, और यह आमतौर पर ऐसा करने के लिए उत्तरों को अधिक दिलचस्प बनाता है। यह आप पर निर्भर है।

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

"puts <<2*2,2\nputs <<2*2,2\n\n2"रूबी में प्रत्येक पुनरावृत्ति में 2 से बढ़ता है। मुझे कुछ भी बेहतर नहीं मिला। : - /। दिलचस्प चुनौती!

— एरिक डुमिनील

प्रोग्राम

— FireCubez

Answer 1

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

-2 बाइट्स @ शुग्गी को धन्यवाद

f=_=>"f=_"+f

परीक्षण स्निपेट

s=`f=_=>"f=_"+f`;

for(i=10;i--;s=eval(s)())
  o.innerText+=s+"\n";

<pre id=o></pre>

Comments

मुझे दूसरी जगह ले गया कि। ख़ुशामदी!

— शैगी

क्या कोई मुझे समझा सकता है, मैं उसके चारों ओर अपना सिर नहीं लपेट सकता, यह कैसे बढ़ता है?

— htmlcoderexe

@htmlcoderexe पैरामीटर नाम से "f=_"पहले एक अतिरिक्त तैयार _करता है, जिसके कारण हर पुनरावृत्ति की लंबाई बढ़ जाती है।

— हरमन एल

Answer 2

ASCII के 7 , 4 बाइट्स

1603

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

मुझे पता है कि 7 आमतौर पर ASCII में एन्कोड नहीं किया गया है, लेकिन इस बार यह अधिक सुविधाजनक एन्कोडिंग है ताकि हम प्रत्येक रन के साथ 1 बाइट जोड़ रहे हैं, न कि 3 बिट्स।

मुझे यकीन नहीं है कि यह धोखा के रूप में गिना जाता है या नहीं। (यह स्पष्ट होना सामान्य है कि 7 क्वीन धोखा दे रही है या नहीं, क्योंकि यह सीमा रेखा को कई तरीकों से फैलाती है।) आप एक अच्छा तर्क दे सकते हैं कि यह 0एन्कोड करता है 6, लेकिन सामान्य रूप से यह स्पष्ट नहीं है कि परिणामी अक्षर कहां से आते हैं। "7 में, क्योंकि इसमें बहुत सारे, काफी विचित्र, निहित व्यवहार हैं।

यह प्रोग्राम अपने आप को 1एप्टर्ड के साथ प्रिंट करता है, और ऐसा तब भी करेगा जब आप इसमें से कई नंबर जोड़ देंगे 1। यहाँ एक टिप्पणी डीबग का पता लगाया गया है 160311:

|| 160311      Initial data ||; initial program 160311
||7 60311      1 command = append 7 to data
|1 0311        6 command = escape from the last | onwards (7 escapes to 1)
|16e77         0311 commands = append 6e77 to data
|16e77 16e77   Implicit (program is empty): copy data past last | to program
|16e777 6e77   1 command = append 7 to data
71603111 e77   6 command = escape from the last | onwards
71603111 e77   e7 command = output in same encoding as the source

( |कार्यक्रम में कोई कसर नहीं छोड़ी गई है, इसलिए eतुरंत कार्यक्रम को साइड इफेक्ट के रूप में छोड़ दिया जाएगा, जिसका अर्थ है कि अंतिम 7एस कभी नहीं चलता है)।

इस बारे में मूल भ्रम कि सभी वर्ण कहाँ से आ रहे हैं, 7 में अधिकांश कमांड केवल रन बनाते समय डेटा का उत्पादन करते हैं, और फिर 6कमांड के एक अनुक्रम को फिर से संगठित करने का प्रयास करते हैं जो डेटा के दिए गए टुकड़े का उत्पादन करेगा; यह अक्सर मूल के करीब होता है, लेकिन मूल के समान नहीं। (क्वीनिंग उद्देश्यों के लिए, आप सामान्य रूप से 7 प्रोग्राम इस तरह से लिखते हैं कि परिणाम लगभग समान होगा, सामान्य रूप से अग्रणी या अनुगामी 7एस में भिन्नता ।) इसलिए, उदाहरण के लिए, 1डेटा बन जाता है 716, जो सबसे आसान तरीका है। 1वर्तमान डेटा स्ट्रिंग के लिए। हमने मूल रूप से इसे 16एक अलग (लेकिन समान) वर्ण अनुक्रम के साथ निर्मित किया , जिसमें से एक को नष्ट कर दिया|डेटा के साथ शुरुआत की गई। (मुझे लगता है कि शायद सबसे अच्छा तर्क है कि यह शाब्दिक-केवल क्वीन नहीं है कि आउटपुट इनपुट से अलग है!)

Answer 3

हास्केल , 74 66 बाइट्स

संपादित करें:

• H.PWiz द्वारा -2 बाइट्स का उपयोग करके <>, फिर -6 ले जाकर (10*)<$>।

यह अब नए मुक्त <>ऑपरेटर ( Semigroupगुणन) का उपयोग करता है, आयात के बिना काम करने के लिए जीएचसी 8.4 की आवश्यकता होती है।)

main=putStr$fst<>show$(10*)<$>("main=putStr$fst<>show$(10*)<$>",1)

इसे ऑनलाइन आज़माएं! (एक आयात के साथ धोखा देता है क्योंकि TIO में अभी तक GHC 8.4 नहीं है।)

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

• main=putStr$ निम्न स्ट्रिंग मान को आउटपुट करने के लिए बॉयलरप्लेट है।

• fst<>showएक ऐसा कार्य है जो एक ट्यूपल लेता है, और एक स्ट्रिंग देता है जिसमें ट्यूपल के पहले तत्व से मिलकर टपल का तत्व शामिल होता है। अर्थात

  (fst<>show)(s,t) = fst(s,t)<>show(s,t) = s++show(s,t)

• (10*)<$>निम्नलिखित टपल के अंतिम तत्व को 10 से गुणा करता है , 0इसके स्ट्रिंग प्रतिनिधित्व के लिए एक अंक जोड़ता है ।

Comments

आप को बचा सकता है कम से कम 2 बाइट्स के साथ(<>)

— H.PWiz

@ H.PWiz धन्यवाद, आगे बढ़ कर कुछ और मिला (10*)<$>।

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

Answer 4

सी (जीसीसी) , 134 132 बाइट्स

कैनोनिकल सी क्वीन का थोड़ा सा परिश्रम। घबड़ाता हुआ लंबा।

x;*s="x;*s=%c%s%c;main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}";main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}

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

Answer 5

विखंडन 2 , 7 बाइट्स

'!+OR!"

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

मानक विखंडन क्वीन , लेकिन एक अतिरिक्त के साथ जो !प्रत्येक पुनरावृत्ति पर कोड की शुरुआत में एक अतिरिक्त 0x01 प्रिंट करता है।

Answer 6

परी / जीपी , 35 बाइट्स

(f=(x)->print1("(f="f")("1x")"))(1)

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

Answer 7

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

s="print's=%r;exec s'%(s+'#')";exec s

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

Answer 8

ब्रेनफक , 420 बाइट्स

->+++>>+++>+>++>+++>+>+>+++>>>>>>>>>>>>>>>>>>>>+>+>++>+++>++>>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>>+++>>+++>>>>>+++>+>>>>>>>>>++>+++>+++>+>>+++>+++>+>++>>+++>+>+++>+>++>+++>>>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>>>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>>>+++>+>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++[[<++++++++++++++++>-]<+++++++++.<]>.

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

यह "मानक" ब्रेनफैक क्वीन पर एक संशोधन है , जिसके .अंत में एक अतिरिक्त .पुनरावृत्ति पर टिक जाता है ।

ख़ुद ही ब्रेनफ़क वर्णों को हेक्स अंकों के ढेर के रूप में अंकित करता है: विशेष रूप से, हेक्स डिजिट्स c-0x2b, जो आसानी से निम्नलिखित हैं:

+: 0x00
-: 0x02
[: 0x30
]: 0x32
<: 0x11
>: 0x13
,: 0x01
.: 0x03

एन्कोडिंग कोड के दो स्निपेट को कवर करता है: >++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++एन्कोडिंग के एन्कोडिंग को स्वयं धकेलता है, और [[<++++++++++++++++>-]<+++++++++.<]स्टैक चलता है और सब कुछ प्रिंट करता है।

Answer 9

गंदा , 9 बाइट्स

'"n[!]a!␛

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

'   start and end a string literal
"   push a literal '
n   remove newlines
[!] print the string
a   push the alphabet
!   print the first character
␛   end the program

यदि स्रोत-कोड पढ़ने की अनुमति है:

गंदा , 8 बाइट्स

Q[!]W33!

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

व्याख्या की:

Q   push the source code
[!] print each character
W   clear the now-empty stack
33! print an exclaimation mark

मान्य हो सकता है:

गंदा , 4 बाइट्स

Q[‼]

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

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

नोट यह केवल देशी अक्षर समूह में काम करता है, और नहीं है जब आप UTF8 सामने के अंत का उपयोग करें कि - तो यह TIO पर आप चरित्र यह के बीच आउटपुट प्रतिस्थापित करने की आवश्यकता की कोशिश करने []के साथ ‼है, जो यह क्या की छपाई के लिए UTF8 बराबर है ।

Comments

4-बाइट संस्करण निश्चित रूप से अमान्य है।

— एर्ग आउटफोलर

Answer 10

जावा 8, 162 146 बाइट्स

v->{String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"+1;return s.format(s,34,s).replaceAll("1+$","");}

इसे ऑनलाइन आज़माएं।
पहले आउटपुट प्रोग्राम का प्रयास करें ; दूसरा आउटपुट प्रोग्राम आज़माएं ; तीसरा आउटपुट प्रोग्राम आज़माएं ।

स्पष्टीकरण:

v->{                       // Method with empty unused parameter and String return-type
  String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"
                           //  The unformatted source code
           +1;             //  Plus a random digit (1 in this case)
  return s.format(s,34,s)  //  Create the quine
          .replaceAll("1+$","");}
                           //  Then remove any trailing 1s

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

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

चुनौती हिस्सा:

• +1 एक 1 दोनों को जोड़ता है जो कि अनफ़ॉर्मेटेड और स्वरूपित प्रोग्राम है।
• .replaceAll("1+$","");}: क्योंकि हम केवल दो के बजाय एक-एक करके प्रोग्राम बाइट-काउंट बढ़ाना चाहते हैं, हम लौटने से पहले किसी भी अनुगामी 1s को हटा देते हैं।

Answer 11

> <> , 9 बाइट्स

#o<:}-1:"

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

एक क्लासिक> <> क्वीन पर भिन्नता, जो बस #सामने की नकल करने के लिए एक और डुबकी कमांड जोड़ती है ।

Answer 12

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

$_=q{say"\$_=q{$_
};eval"};eval

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

Answer 13

GolfScript , 9 बाइट्स

{'.~1'}.~

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

CJam , 9 बाइट्स

{"_~1"}_~

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

मैं इन दोनों समाधानों को एक ही उत्तर में पोस्ट कर रहा हूं, क्योंकि वे एक-दूसरे के मामूली बदलाव हैं और बिल्कुल उसी तरह से काम करते हैं। वे दोनों आम गोल्फस्क्रिप्ट क्वीन {'.~'}.~(या {"_~"}_~सीजेएम में) पर आधारित हैं , जो कि मेरे पिछले उत्तर में अधिक विस्तार से वर्णित है ।

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

Answer 14

अटैच , 76 72 61 बाइट्स

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

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

मानक क्वीन जो xप्रत्येक पुनरावृत्ति के बाद के अंत में एक स्थान जोड़ता है ।

पहले कुछ पुनरावृत्तियों:

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]] ",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]  ",Repr[x+sp]]

आदि।

अटैच, 72 बाइट्स

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

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

यह बस मानक प्रारूप क्वीन की एक भिन्नता है, एक चर के साथ जो प्रत्येक पुनरावृत्ति के बाद yसेट किया जाता है10*y

पहले कुछ पुनरावृत्तियों:

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=10Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=100Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

आदि।

Answer 15

स्विफ्ट 4 , 89 बाइट्स

let(a,b)=(";print(\"let(a,b)=\\((a,b+\"-\"))\"+a)", "");print("let(a,b)=\((a,b+"-"))"+a)

एक अनुगामी न्यूलाइन शामिल है

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

Answer 16

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

main=putStr$snd(span(<'m')s)++show s;s='#':"main=putStr$snd(span(<'m')s)++show s;s='#':"

इसे ऑनलाइन आज़माएं! #डेटा स्ट्रिंग के लिए तैयार करके बढ़ता है ।

Comments

तुम showसिर्फ एक स्ट्रिंग से अधिक आईएनजी और पैटर्न मिलान का उपयोग करके थोड़ा बचा सकते हैं । इसे ऑनलाइन आज़माएं!

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

@ ØrjanJohansen अच्छा लगा! अंतर्निहित मानक हास्केल क्वीन को छोड़कर यह एक पूरी तरह से अलग दृष्टिकोण है, इसलिए इसे स्वयं पोस्ट करने के लिए स्वतंत्र महसूस करें।

— लकोनी

ठीक है, अगर आप ऐसा सोचते हैं।

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

Answer 17

स्टैक्स , 20 18 बाइट्स

"34s+cTZL"34s+cTZL

इसे चलाएं और डीबग करें

हर पुनरावृत्ति को 2 कोटेशन मार्क से पहले एक अतिरिक्त स्थान बनाता है।

व्याख्या

"34s+cTZL "34s+cTZLसमझाने के लिए कार्यक्रम का उपयोग करता है ।

"34s+cTZL "34s+cTZL
"34s+cTZL "            String literal
           34s+        Prepend a double quote, Now the string is `"34s+cTZL `
               cT      Copy and trim trailing spaces
                 Z     Put a 0 under the top of stack
                       Stack now (from top to bottom): `["34s+cTZL,0,"34s+cTZL ]`
                  L    Collect all elements on stack, from bottom to top
                       Implicit output, 0 is converted to space.

Answer 18

जेस्टेक्स , 4 बाइट्स

£↕♣:

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

Answer 19

गोल> <> , 7 बाइट्स

":r2ssH

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

यह नियमित रूप से गोल> <> क्वीन की एक साधारण भिन्नता है, लेकिन Hहर बार इसे चलाने की एक प्रति जोड़ता है । चूंकि Hकमांड प्रोग्राम को रोकती है H, इसलिए अंत में अतिरिक्त व्यवहार नहीं बदलता है।

Answer 20

रूनिक एनकाउंटर , 6 बाइट्स

"'<S@>

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

यह एक अजीब था। जो मुझे करना था ~, वह जो किंग द्वारा पाई गई मूल रानी से हटा दिया गया था ।

हर अतिरिक्त रन <अंत में एक और जोड़ता है , जैसे:

"'<S@><<<<<<<<<

जिनमें से सभी कुछ नहीं करते हैं।

संबंधित चुनौती पर इस उत्तर की सीधी प्रति । यह सिर्फ पहले ही हर बाइट से 1 बाइट बढ़ने के लिए हुआ (इस चुनौती के लिए मजबूत तर्क उस एक या इसके विपरीत की नकल है)।

Answer 21

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

“⁾;⁶;ØV” ṘV

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

Answer 22

आश्चर्य है , 33 बाइट्स

f\ @(-> ol) ["f\ ";f;";f1";#0];f1

सामान्य क्वीन पर एक दिलचस्प संस्करण जो प्रत्येक पुनरावृत्ति के बाद 1 संलग्न करता है।

प्रगति:

f\ @(-> ol) ["f\ ";f;";f1";#0];f1
f\ @(-> ol) ["f\ ";f;";f1";#0];f11
f\ @(-> ol) ["f\ ";f;";f1";#0];f111
...

व्याख्या

f\ @                               #. Sets f to a function that does the following:
    (-> ol) [                      #.   Output each:
             "f\ ";                #.     String for declaration of f
                   f;              #.     Formatted representation of f's function
                     ";f1";        #.     String for call of f
                           #0      #.     Argument passed into f
                             ];f1  #. Call f with 1 as the argument

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

Answer 23

कोल्डफ्यूजन, 277 बाइट्स

<cfset u=Chr(34)><cfset q="<cfset u=Chr(34)><cfset q=%s%s%s><cfoutput>%screateObject(%sjava%s,%sjava.lang.String%s).format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])%s</cfoutput>
"><cfoutput>#createObject("java","java.lang.String").format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])#</cfoutput>

यह मेरे कोल्डफ़्यूज़न क्वीन का एक तुच्छ संशोधन है जो प्रत्येक अतिरिक्त समय में एक नई पंक्ति जोड़ता है।

स्थानीय रूप से lucee-express-5.2.6.60 पर परीक्षण किया गया

Answer 24

विंडोज बैच, 38 36 बाइट्स

echo|set/p"=q">q&copy/b/y %0+q %0
::

यह कोड "q" नामक एक फ़ाइल बनाता है, जिसमें 'q' अक्षर होता है, और फिर इसे मूल फ़ाइल में जोड़ देता है। ध्यान दें कि "::" "रेम" के लिए एक उपनाम है जिसे अतिरिक्त स्थान की आवश्यकता नहीं है।

सहेजा गया 2 बाइट्स user3493001 के लिए धन्यवाद।

Answer 25

टी-एसक्यूएल , 175 बाइट्स

DECLARE @ VARCHAR(MAX)='DECLARE @ VARCHAR(MAX)=*SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @'SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @

पहले मैंने एक एसक्यूएल क्वीन लिखा, फिर मैंने इसे एक अतिरिक्त स्थान ( इस उत्तर से प्रेरित कुछ ) को जोड़ने के लिए संशोधित किया ।

Answer 26

बेफ़ुंज -98 (पायफ़ुंग) , 22 19 बाइट्स

r:#,_ #;'D2/'<,,@;"

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

हर पीढ़ी के अंतिम से पहले एक <जोड़ता है।

Answer 27

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 89 बाइट्स

var s="var s={0}{1}{0}+8;Write(s.Trim('8'),(char)34,s);"+8;Write(s.Trim('8'),(char)34,s);

केविन क्रूज़सेन के जवाब से प्रेरित।

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