19

आपका कार्य सरल है: एक प्रोग्राम (या फ़ंक्शन) लिखें जो कोई इनपुट नहीं लेता है और कुछ इस तरह से आउटपुट करता है:

## *name*, *length* bytes
    *code*

कहाँ *name*भाषा का उपयोग कर रहे हैं उसका नाम है, *length*अपने कोड में बाइट की संख्या है, और *code*अपने कार्यक्रम के स्रोत कोड है। यदि *code*एक से अधिक रेखाएँ हैं, तो इसमें प्रत्येक पंक्ति से पहले चार स्थान हैं।

यहाँ पायथन 3 में 124-बाइट उदाहरण कार्यान्वयन है:

s = "## Python 3, 124 bytes{2}    s = {1}{0}{1}{2}print(s.format(s,chr(34),chr(10)))"
print(s.format(s,chr(34),chr(10)))

आउटपुट है:

## Python 3, 124 bytes
    s = "## Python 3, 124 bytes{2}    s = {1}{0}{1}{2}print(s.format(s,chr(34),chr(10)))"
    print(s.format(s,chr(34),chr(10)))

मार्कडाउन में कौन सा है:

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

s = "## Python 3, 124 bytes{2}    s = {1}{0}{1}{2}print(s.format(s,chr(34),chr(10)))"
print(s.format(s,chr(34),chr(10)))

यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

code-golf quine

— फल तोड़ना
स्रोत

3

मुझे पूरा यकीन है कि यह एक दुपट्टा है, लेकिन पुराने को नहीं खोज सकते ...

— दादा

RProgN 2, 28 बाइट्स

«"  %s"F"#RProgN 2, 28 Bytes"

— Ataco
स्रोत

2

जैसा कि, यह एक गंभीर दावेदार नहीं है और हटाने के अधीन है। कृपया अपना उत्तर गोल्फ दें।

— डेनिस

1

@ डेनिस गॉकेटेड

— एटको

2

अच्छा! बाइट गिनती के बाद डॉट की आवश्यकता नहीं लगती है, लेकिन कोड से पहले चार स्थान (या एक टैब) होना चाहिए।

— डेनिस

5

अंडरलोड, 48 बाइट्स

(#Underload, 48 bytes
)(~:S(    ):S*aSaS(:^)S):^

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

चैट में अंडरलोड के बारे में चर्चा के बाद, हमने तय किया कि यह अन्य व्यापक रूप से इस्तेमाल की जाने वाली परिभाषाओं द्वारा भी एक क्वीन है; :^कार्यक्रम के अंत में से एन्कोड किया गया है :^कुछ समय पहले एक और इस कार्यक्रम के इस प्रकार एक हिस्सा एक अलग हिस्सा encodes।

2

आप चर्चा कर सकते हैं मैं एन अंडरलोड quines? (Cool!:aSS)Cool!:aSS

— कैलक्यूलेटरफल

1

@CalculatorFeline दुर्भाग्य से, क्योंकि यह काम नहीं करता है (!)।

— 3

2

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

_='## Python 2, 58 bytes\n    _=%r;print _%%_';print _%_

— आउटग्रॉफर को एरिक करें
स्रोत

इस पोस्ट की सामग्री ठीक उसी तरह है जैसे कोड द्वारा छापी जाती है।

— आउटगोल्फर

1

जालीदार, 58 बाइट्स

"'34'c: 4*91+c:s:e:t:y:b: 85: :,:r:a:l:u:c:i:t:e:r: :#dqO;

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

स्पष्टीकरण: :cएकल-चार स्ट्रिंग को धकेलता है c। यह स्ट्रिंग "## जालीदार, 58 बाइट्स" बनाता है, चरित्र द्वारा पीछे की ओर, स्टैक को उलट देता है, और Oप्रारंभिक उद्धरण द्वारा कैप्चर किए गए स्ट्रिंग सहित, सब कुछ विवाद करता है।

— कोनोर ओ ब्रायन
स्रोत

1

CJam, 33 बाइट्स

{"## CJam, 33 bytes"N@S4*\"_~"}_~

बहुत कुछ अंडरलोड जवाब की तरह काम करता है।

स्टैक ट्रेस ( Nप्रतिनिधित्व करता है \n)

{"## CJam, 33 bytes"N@S4*\"_~"}
{"## CJam, 33 bytes"N@S4*\"_~"} {"## CJam, 33 bytes"N@S4*\"_~"}
{"## CJam, 33 bytes"N@S4*\"_~"} "## CJam, 33 bytes"
{"## CJam, 33 bytes"N@S4*\"_~"} "## CJam, 33 bytes" N
"## CJam, 33 bytes" N {"## CJam, 33 bytes"N@S4*\"_~"}
"## CJam, 33 bytes" N {"## CJam, 33 bytes"N@S4*\"_~"} " "
"## CJam, 33 bytes" N {"## CJam, 33 bytes"N@S4*\"_~"} " " 4
"## CJam, 33 bytes" N {"## CJam, 33 bytes"N@S4*\"_~"} "    "
"## CJam, 33 bytes" N "    " {"## CJam, 33 bytes"N@S4*\"_~"}
"## CJam, 33 bytes" N "    " {"## CJam, 33 bytes"N@S4*\"_~"} "_~"
<implicit output>

— फल तोड़ना
स्रोत

1

वी, 25 बाइट्स

ñi#V, 25 bytes<esc>o´ Ñ<esc>~"qpx

(यह उत्पन्न मार्कडाउन में नहीं गिना जाता है, क्योंकि मुझे अपने कोड के लिए स्पष्टीकरण प्रदान करना पसंद है: P)

यहाँ एक हेक्सडम्प है, क्योंकि स्रोत कोड में अप्राप्य / गैर- ASCII वर्ण हैं:

00000000: f169 2356 2c20 3235 2062 7974 6573 1b6f  .i#V, 25 bytes.o
00000010: b420 d11b 7e22 7170 78                   . ..~"qpx

यह उत्तर मानक एक्स्टेंसिबल वी क्वीन का सिर्फ एक मामूली संशोधन है ।

स्पष्टीकरण:

ñ                                   " Run the following code one time, storing it in
                                    " register 'q'
 i                                  "   Enter insert mode
  #V, 25 bytes<esc>                 "   And insert the header
                   o                "   Open up a newline, and enter insert mode again
                    ´ Ñ             "   Enter four spaces, then a 'Ñ' character.
                                    "   (The reason we insert it uppercase, is because
                                    "   lowercase would end the loop now)
                       <esc>        "   Return to normal mode
                            ~       "   Toggle the case of the char under the cursor ('Ñ')
                             "qp    "   Paste the contents of register 'q' (this is the
                                    "   same as the entire program minus the initial 'ñ',
                                    "   followed by a 'ÿ' character because V is weird)
                                x   "   Delete the last character (the ÿ)

— DJMcMayhem
स्रोत

1

जेएस, 50 49 27 30 बाइट्स

f=_=>`#JS, 30 bytes\n    f=`+f

कोशिश करो

f=_=>`#JS, 30 bytes\n    f=`+f
console.log(f())

स्निपेट का विस्तार करें

— झबरा
स्रोत

अपनी पोस्ट के लिए एक मार्कडाउन टेम्पलेट बनाएं