Générez un modèle de démarque pour votre publication

19

Votre tâche est simple: écrivez un programme (ou une fonction) qui ne prend aucune entrée et génère quelque chose comme ceci:

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

Où *name*est le nom de la langue que vous utilisez, *length*le nombre d'octets dans votre code et *code*le code source de votre programme. S'il *code*contient plusieurs lignes, il comporte quatre espaces avant chaque ligne.

Voici un exemple d'implémentation de 124 octets en 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)))

La sortie est:

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

Ce qui dans Markdown est:

Python 3, 124 octets

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

Il s'agit de code-golf , donc la réponse la plus courte (en octets) l'emporte.

code-golf quine Esolanging Fruit
la source
3
Je suis presque sûr que c'est un dup, mais je ne trouve pas l'ancien ...
Dada
En relation
Adnan
1
Je dirais que c'est assez différent de celui-là parce qu'il en génère un pour lui-même. L'idée est similaire, mais vous devez écrire une quine pour celle-ci.
Esolanging Fruit
Devrions-nous assumer des règles de quine standard (par exemple, ne pas ouvrir votre propre code et le lire)?
Gabriel Benamy
@GabrielBenamy Oui.
Esolanging Fruit

Réponses:

8

RProgN 2, 28 octets

«"  %s"F"#RProgN 2, 28 Bytes"
ATaco
la source
2
En l'état, ce n'est pas un concurrent sérieux et sujet à suppression. Veuillez jouer votre réponse au golf.
Dennis
1
@Dennis Golfed.
ATaco
2
Agréable! Le point après le nombre d'octets ne semble pas être requis, mais il devrait y avoir quatre espaces (ou une tabulation) avant le code.
Dennis
5

Sous-charge, 48 octets

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

la source
La publication est exactement telle que produite par le code. Le quine est capable de charge utile (placez la charge utile après le S final), ce qui en fait un vrai quine selon une définition largement utilisée, mais utilise une chaîne eval (cela dit, la chaîne eval est le seul moyen de faire une boucle dans Underload ; c'est assez fondamental pour la langue).
Après une discussion dans les quines de sous-charge dans le chat, nous avons décidé que c'était aussi une quine par les autres définitions largement utilisées; le :^à la fin du programme est codé par le :^un peu plus tôt, et donc une partie du programme code une autre partie.
2
Vous pouvez discuter i n Quines sous -charge ? (Cool!:aSS)Cool!:aSS
CalculatorFeline
1
@CalculatorFeline Malheureusement, cela ne fonctionne pas à cause du (!).
Esolanging Fruit
2

Python 2, 58 octets

_='## Python 2, 58 bytes\n    _=%r;print _%%_';print _%_
Erik le Outgolfer
la source
Le contenu de ce message est exactement tel qu'imprimé par le code.
Erik the Outgolfer
1

réticulaire, 58 octets

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

Essayez-le en ligne!

Explication: :cpousse la chaîne à caractère unique c. Cela crée la chaîne "## réticulaire, 58 octets", en arrière caractère par caractère, inverse la pile et Omet tout, y compris la chaîne capturée par la citation initiale.

Conor O'Brien
la source
1

CJam, 33 octets

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

Fonctionne un peu comme la réponse Underload.

Trace de pile ( Nreprésente \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>
Esolanging Fruit
la source
1

V, 25 octets

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

(Ceci n'est pas compté dans le démarque généré, car j'aime fournir des explications pour mon code: P)

Voici un hexdump, car le code source contient des caractères non imprimables / non ASCII:

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

Cette réponse n'est qu'une modification triviale du quine V extensible standard .

Explication:

ñ                                   " 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
la source
1

JS, 50 49 27 30 octets

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

Essayez-le

f=_=>`#JS, 30 bytes\n    f=`+f
console.log(f())
Développer l'extrait

Hirsute
la source