Una metaquine è un programma che non è una quine, ma il cui output, quando eseguito come un programma nella stessa lingua, è una quine.

L'obiettivo di questa sfida è scrivere una metaquina. Si tratta di code-golf , quindi vince il codice più breve, con la prima risposta utilizzata come tiebreaker. Si noti che sono accettabili solo programmi completi, a causa della definizione di un quine.

Regole per Quines

Sono accettate solo vere quine. Cioè, è necessario stampare l'intero codice sorgente su STDOUT, senza :

• leggendo il codice sorgente, direttamente o indirettamente.
• basandosi su un ambiente REPL che semplicemente valuta e stampa ogni espressione che gli dai da mangiare.
• basandosi su funzionalità linguistiche che in alcuni casi stampano semplicemente l'origine.
• usando messaggi di errore o STDERR per scrivere tutto o parte del quine. (È possibile scrivere elementi su STDERR o produrre avvisi / errori non fatali purché STDOUT sia un quine valido e i messaggi di errore non ne facciano parte.)
• il codice sorgente costituito esclusivamente da valori letterali (siano essi valori letterali stringa, valori letterali numerici, ecc.) e / o NOP.

Qualsiasi output non sopprimibile (come avvisi sul copyright, messaggi di avvio / arresto o un feed di riga finale) può essere ignorato nell'output per motivi di validità del quine.

Esempio

Ignorando la regola che proibisce i programmi solo letterali e il quining incorporato, questa sarebbe una metaquina in Seriamente:

"Q"

Il programma è composto dalla singola stringa letterale "Q", che viene implicitamente stampata in uscita. Quando Qviene eseguito l'output ( ), è un quine ( Qè la funzione quine integrata).

CJam, 6 byte

"_p"_p

stampe

"_p"
_p

che è il quint proprio più corto in CJam.

Provalo qui.

Spiegazione

Entrambi i programmi funzionano esattamente allo stesso modo, poiché l'alimentatore di linea all'interno del quine corretto è un no-op ed è incluso solo perché è più costoso rimuoverlo dall'output. Come funzionano i programmi:

"_p"  e# Push this string.
_     e# Duplicate it.
p     e# Print a string representation of the top of the stack (i.e. the string with
      e# quotes) followed by a linefeed.
      e# The other copy is then printed automatically at the end of the program, without
      e# stringifying it.

Nota a margine

Lo stesso vale per GolfScript come

".p".p

quale stampa

".p"
.p

con un avanzamento di riga finale, che a sua volta è uno dei quines più brevi conosciuti.

Pyth, 12 11 10 9 byte

Chiuso un altro byte grazie a @ Pietu1998.

jN B".[9N

Questo stampa

.[9N".[9N

che è un quine in Pyth. Puoi provarlo qui .

Fissione , 6 byte

!+OR"'

stampe

'!+OR"

Qual è il quino di Fissione più corto . Questo funziona perché i cambiamenti ciclici del programma lasciano il suo output completamente inalterato.

Provalo online!

Javascript ES6, 21 byte

$=_=>`$=${$};$()`
$()

Banale.

Python 2, 29 byte

_="_=%r;print _%%_";print _%_

Si scopre che il noto quine in pitone corto si trasforma facilmente in una metaquina :)

E, dal momento che non dobbiamo preoccuparci di abbinare la nuova riga finale, la metaquina è in realtà più breve!

Japt, 15 13 byte

Q+"+Q ³s7J" ²

Provalo online!

Questo programma emette

"+Q ³s7J"+Q ³s7J

che è il quine più breve conosciuto in Japt.

Come funziona

Q+"..." // Take a quotation mark plus this string.  "+Q ³s7J
²       // Repeat it twice.                         "+Q ³s7J"+Q ³s7J
        // Implicit output

Versione non competitiva, 11 byte

Q+"+Q ²é" ²

Ho appena aggiunto é un comando "ruota". Così

"+Q ²é"+Q ²é

è ora un quine valido.

Ruby, 25 23

puts"puts <<2*2,2
"*2,2

Genera il classico quine Ruby HEREdoc

puts <<2*2,2
puts <<2*2,2
2

Vecchia soluzione

_='_=%p;$><<_%%_';$><<_%_

Si genera tranne le virgolette singole sostituite da virgolette doppie.

JavaScript, 50 byte

a="a=%s;console.log(a,uneval(a))";eval(a.slice(5))

Basato sul più breve quine JS di lettura non sorgente conosciuto dall'uomo , ma ben 8 byte più corto. stampe

a="a=%s;console.log(a,uneval(a))";console.log(a,uneval(a))

che è un quine.

Pesce (> <>), 17 byte

Funziona usando il classico fish quine "r00g!;oooooooo|ma aggiunge un {che sposta l'intero stack a sinistra in modo che il programma originale non sia un quine, ma il suo output, quando eseguito, lo è.

"{r00g!;oooooooo|

Uscite:

"r00g!;oooooooo|

che è un pesce quine!

Gelatina , 3 byte (non competitiva)

Sfortunatamente, gli atomi richiesti sono circa 2 settimane più giovani della sfida.

Metaquine

”Ṙv

Provalo online!

Come funziona

”Ṙv  Main link. No arguments.

”Ṙ   Set the left argument and the return value to the character 'Ṙ'.
  v  Dyadic eval; evaluate the return value with the left argument as argument.
     Executing the atom Ṙ on the argument 'Ṙ' prints a string representation of
     the character, i.e., the string "”Ṙ".
     Finally, v returns its unaltered argument, which is printed implicitly.

Quine

”ṘṘ

Provalo online!

Come funziona

”ṘṘ  Main link. No arguments.

”Ṙ   Set the left argument and the return value to the character 'Ṙ'.
  Ṙ  Print a string representation of the character, i.e., the string "”Ṙ".
     (implicit) Print the unaltered return value.

Poiché il secondo Ṙstampa i primi due caratteri ( ”Ṙ), questo è un vero e proprio quine secondo la nostra definizione.

Octopen-Baru, 22 byte

** Risposta non competitiva

愛[35211].pack歩U')

Uscita rubino

puts [35211].pack(' U')

Quali uscite 見. Che è una quinta in Octopen-Baru!

7 , 2 byte, sfida post-lingua in lingua

Il programma è lungo due byte e può essere interpretato in diversi modi; come discarica esadecimale:

00000000: 4ff4                                     O.

come tabella codici 437:

O⌠

o, più facilmente, in ottale (che 7 usa nativamente):

237723

Provalo online!

Il funzionamento di questo è molto semplice: si tratta dello standard 7 quine con un elemento stack no-op inserito tra le due metà, per renderlo diverso (in questo contesto, 7separa gli elementi stack). (Avrei potuto anche inserirlo all'inizio,. 723723Non avrei potuto interpretarlo alla fine perché i 7 finali sono come gli spazi vuoti finali, e ignorati nella codifica compatta, quindi non sarebbe diverso dal programma di output. )

Per inciso, questo programma è un palindromo in esadecimale, ma per lo più è solo una coincidenza.

Sottocarico, 11 byte

(:aSS)::aSS

Abbastanza semplice. Viene stampato (:aSS):aSS, che è lo standard Underload Quine.

Brachylog , 12 byte

"~k;?w₁"gjw₃

Provalo online!

Una delle 132 varianti di metachina della stessa lunghezza sul quine che ho tradotto dal quach di Brachylog v1 (non imbroglione) di Fatalize. In realtà ho scritto un programma (non golfistico e nel complesso sciocco) per stamparli tutti:

{[[";?","gj","jḍ"],"₁₃₅₇"]j∋ᵐ{ḍ≠&};"\"~~k~ww~w\"~ww~w~n"}ᶠ{lw" metaquines generated:
"ẉ&}w₁ᵐ

Provalo online!

Ci sono due parti del quine originale che potrebbe essere sostituito illogica: ;?può essere cambiato in gjo jḍ, e ₁può essere cambiato in ₃, ₅o ₇. Se li manteniamo o li cambiamo al di fuori della stringa letterale in un modo e all'interno della stringa letterale in un modo diverso, quindi l'output non corrisponderà alla sorgente, perché qualsiasi variante presente nella stringa letterale verrà stampata sia all'interno che all'esterno di essa , risultante in un quine che non era l'esecuzione iniziale del programma.

;?, gje jḍsono intercambiabili perché tutti e tre accoppiano la stringa letteralmente con se stessa: a causa del layout del programma, la variabile di input ?è unificata con la stringa, quindi ;?accoppia la stringa con se stessa; indipendentemente dal layout, gjavvolge la stringa in un elenco che viene quindi concatenato a se stesso; allo stesso modo jḍconcatena la stringa a se stessa, quindi la divide a metà.

I wpedici con numeri dispari sono intercambiabili perché, sebbene originariamente wpotesse prendere solo 0 o 1, con 0 che stampava l'input su we 1 stampando il primo elemento formattato con il secondo, l'inventario dei pedici per wè diventato un qualcosa che funziona esternamente come bitfield: il bit basso del pedice codifica se è diretto o formattato, il bit centrale codifica se la variabile di output dawnon è vincolato o impostato sull'input e il bit alto codifica se la stampa viene eseguita immediatamente o se è ritardata fino alla fine del programma, quindi può essere soggetta a backtracking. (Quei pedici sono stati il ​​mio primo e finora il più grande contributo a Brachylog.) Dato che la quina e la metaquina non usano la variabile di output e non fanno marcia indietro, tutti e quattro i pedici dispari sono equivalenti.

Befunge-93, 22 byte

"+1_@#`+39:,g0:">:#,_@

Ho appena preso il quine standard, l'ho messo tra virgolette, l'ho invertito (quindi è caricato correttamente sulla pila) e quindi ho aggiunto una stampa di pila alla fine.

Sono 8 caratteri aggiunti al normale quine, quindi è molto probabile che ci sia una soluzione migliore.

Turtlèd , 52 byte (non competitivo)

1 meno di quine originale

@##'@r,r,r-{ +.r_}r{ +.r_}"#'@r,r,r-{ +.r_}r{ +.r_}"

Funziona allo stesso modo, tranne per il fatto che non ha un carattere alla fine, quando eseguito, avrà un carattere alla fine, che non ha effetto sull'output, perché scrive # su un #. Nota che l'output è leggermente diverso dal quine che ho creato per la sfida del quine, ma funziona allo stesso modo: "scrive #, che è il suo ultimo carattere, come il quine che ho creato. Dai un'occhiata alla spiegazione qui .

Lua, 45 byte

Il mio codice non è mio.

s="s=%qprint(s:format(s))"print(s:format(s));

si tradurrà in

s="s=%qprint(s:format(s))"print(s:format(s))

che è un quine. Sono contento che ;sia facoltativo in Lua.

Pushy , 7 byte

Non competitiva in quanto la lingua postdatizza la sfida.

Questo è il quine standard, ma con le nuove righe rimosse. I newline non significano nulla in Pushy, ma sono il separatore standard dell'operatore di stampa, e quindi necessari per un vero quine.

95 34_"

Provalo online! Questo produce:

95 34
_"

Qual è il quinto Pushy più corto - una spiegazione su come funziona può essere trovata qui .

In alternativa, H5-34_"funziona con lo stesso numero di byte.

Schiuma , 14 byte

[. .'|: ~|]: ~

Questo stampa il secondo spago in schiuma che può essere trovato qui . Questo è in realtà più breve perché .metterà sempre uno spazio tra ogni elemento, ma la barra nel terzo token mi consente di omettere lo spazio prima di esso.

Buccia , 6 byte

D"S+s¨

Provalo online!

Stampa il quino Husk standard S+s"S+s".

 "S+s¨    The string S+s"
D         concatenated with itself.

Il quine ha spiegato:

   "S+s"    The string S+s
 +          concatenated with
S           itself passed through
  s         the function which returns its string representation.