19

Il tuo compito è semplice: scrivi un programma (o una funzione) che non accetta input e produce qualcosa del genere:

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

Dov'è *name*il nome della lingua che stai usando, *length*è il numero di byte nel tuo codice ed *code*è il codice sorgente del tuo programma. Se *code*contiene più righe, ha quattro spazi prima di ogni riga.

Ecco un'implementazione di esempio a 124 byte in 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)))

L'output è:

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

Che in Markdown è:

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

Questo è code-golf , quindi vince la risposta più breve (in byte).

code-golf quine

— Esolanging Fruit
fonte

3

Sono abbastanza sicuro che questo sia un duplex, ma non riesco a trovare quello vecchio ...

— Dada,

Correlati

— Adnan,

1

Direi che questo è abbastanza diverso da quello perché sta generando uno per sé. L'idea è simile, ma è necessario scrivere un quine per questo.

— Esolanging Fruit,

Dovremmo assumere regole quine standard (ad esempio, non aprire il proprio codice e leggerlo)?

— Gabriel Benamy,

@GabrielBenamy Sì.

— Esolanging Fruit,

8

RProgN 2, 28 byte

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

— ATACO
fonte

2

Così com'è, questo non è un serio contendente e soggetto a cancellazione. Per favore, golf la tua risposta.

— Dennis,

1

@Dennis Golfed.

— ATaco,

2

Bello! Il punto dopo il conteggio dei byte non sembra essere richiesto, ma ci dovrebbero essere quattro spazi (o una scheda) prima del codice.

— Dennis,

5

Sottocarico, 48 byte

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

Post è esattamente come prodotto dal codice. Il quine è capace di payload (posiziona il payload dopo la S finale), rendendolo così un vero quine secondo una definizione ampiamente usata, ma usa una stringa eval (detto che, stringa eval è l'unico modo per fare un ciclo in Underload ; è abbastanza fondamentale per la lingua).

Dopo una discussione su Underload quines in chat, abbiamo deciso che anche questo è un quine dalle altre definizioni ampiamente utilizzate; il :^alla fine del programma è codificato da :^un po 'prima, e quindi una parte del programma codifica una parte diversa.

2

Si può discutere i n sottocarico quines? (Cool!:aSS)Cool!:aSS

— Calcolatrice

1

@CalculatorFeline Sfortunatamente, ciò non funziona a causa del (!).

— Esolanging Fruit,

2

Python 2, 58 byte

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

— Erik the Outgolfer
fonte

I contenuti di questo post sono esattamente come stampati dal codice.

— Erik the Outgolfer,

1

reticolare, 58 byte

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

Provalo online!

Spiegazione: :cinvia la stringa a carattere singolo c. Questo costruisce la stringa "## reticolare, 58 byte", indietro carattere per carattere, inverte la pila e Ogenera tutto, inclusa la stringa catturata dalla citazione iniziale.

— Conor O'Brien
fonte

1

CJam, 33 byte

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

Funziona in modo molto simile alla risposta Underload.

Stack trace ( Nrappresenta \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
fonte

1

V, 25 byte

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

(Questo non viene conteggiato nel markdown generato, perché mi piace fornire spiegazioni per il mio codice: P)

Ecco un hexdump, poiché il codice sorgente contiene caratteri non stampabili / non ASCII:

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

Questa risposta è solo una banale modifica del V quine estensibile standard .

Spiegazione:

ñ                                   " 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
fonte

1

JS, 50 49 27 30 byte

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

Provalo

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

Espandi frammento

— ispido
fonte

Genera un modello di markdown per il tuo post

Python 3, 124 byte

RProgN 2, 28 byte

Sottocarico, 48 byte

Python 2, 58 byte

reticolare, 58 byte

CJam, 33 byte

V, 25 byte

JS, 50 49 27 30 byte

Provalo