Nhiệm vụ của bạn rất đơn giản: Viết chương trình (hoặc chức năng) không có đầu vào và đầu ra giống như thế này:

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

Trong trường hợp *name*là tên của ngôn ngữ mà bạn đang sử dụng, *length*là số byte trong mã của bạn, và *code*là mã nguồn của chương trình của bạn. Nếu *code*chứa nhiều dòng, nó có bốn khoảng trắng trước mỗi dòng.

Đây là một triển khai ví dụ 124 byte trong Python 3:

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)))

Đầu ra là:

## 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)))

Mà trong Markdown là:

Python 3, 124 byte

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)))

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

RProgN 2, 28 byte

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

Tải trọng, 48 byte

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

Python 2, 58 byte

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

mặt lưới, 58 byte

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

Hãy thử trực tuyến!

Giải thích: :cđẩy chuỗi char đơn c. Điều này xây dựng chuỗi "## reticular, 58 byte", ký tự ngược theo ký tự, đảo ngược ngăn xếp và Obỏ qua mọi thứ, bao gồm cả chuỗi được trích dẫn bởi trích dẫn ban đầu.

CJam, 33 byte

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

Hoạt động rất nhiều như câu trả lời Underload.

Dấu vết ngăn xếp ( Nđại diệ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>

V, 25 byte

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

(Điều này không được tính trong phần đánh dấu được tạo, vì tôi thích cung cấp giải thích cho mã của mình: P)

Đây là một hexdump, vì mã nguồn chứa các ký tự không thể in / không phải ASCII:

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

Câu trả lời này chỉ là một sửa đổi nhỏ của quine V mở rộng tiêu chuẩn .

Giải trình:

ñ                                   " 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 ÿ)

JS, 50 49 27 30 byte

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

Thử nó

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