Compito

Ti verrà data una stringa nell'input composta solo dai caratteri da aa z, cioè l'input corrisponderà alla regex /^[a-z]*$/.

L'output dovrebbe essere un programma completo nella stessa lingua, il cui codice sorgente contiene l'input ed è un quine appropriato.

Esempio

Il tuo programma riceverà l'input abce l'output:

...abc...

Quanto sopra dovrebbe essere un programma completo nella stessa lingua che non accetta input e output:

...abc...

cioè si emette da solo.

punteggio

Questo è code-golf . Vince la risposta più breve in byte.

Riferimenti

Cosa conta come un vero quine?

code-golf quine

— Perdente Suora
fonte

3

Hmm .. Quindi come un 'quat' (quine + cat)?

— Matthew Roh,

7

Python 3, 57 61 byte

lambda x:"s='s=%r;print(s%%s)';print(s%s)".replace('s',x+'x')

Prende un quine di base di Python 3 da qui e sostituisce il nome della variabile con l'input.

Nota: Come sottolineato da Hyper Neutrino nei commenti, questo non funziona per parole chiave riservate come for, ifecc

Aggiunta di un carattere che nessuna delle parole chiave riservate termina con tale 'x'o qualsiasi numero risolve questo problema. (Ørjan Johansen).

— c ..
fonte

Molto creativo per usare il nome della variabile.

— Leaky Nun,

3

Non funziona per l'input "for"o per qualsiasi altra parola riservata in Python.

— HyperNeutrino,

Posso confermare Non funziona per tutti gli input possibili. Provalo online

— mbomb007,

@HyperNeutrino, Notato, inoltre non ho idea di come aggirarlo

— c ..

È possibile aggiungere un carattere aggiuntivo che non si trova alla fine di una parola chiave, ad esempio 'x'.

— Ørjan Johansen,

6

Gelatina , 9 byte

Generatore

;“¶Øv”ṾØv

Provalo online!

Come funziona

;“¶Øv”ṾØv  Main link. Argument: s (string of letters)

;“¶Øv”     Concatenate s and the string "\nØv".
      Ṿ    Uneval; get its string representation.
           (implicit) Print the previous return value since the next link is an
           otherwise unparsable nilad.
       Øv  Set the return value to "Ṙv".

Quine

Se l'ingresso è quine, viene generato il seguente programma.

“quine
Øv”Ṙv

Provalo online!

Come funziona

Questo è lo standard Jelly Quine. Primo,

“quine
Øv”

imposta l'argomento sinistro e il valore restituito sulla stringa "quine\nØv".

Quindi, Ṙstampa una rappresentazione di stringa (il codice dal blocco precedente) e restituisce la stringa inalterata.

Successivamente, vaccetta l'argomento sinistro e lo passa come input al programma Jelly

quine
Øv

In tutti i programmi Jelly, viene eseguito solo il collegamento principale (definito nell'ultima riga), quindi la prima riga viene completamente ignorata.

Infine, Øvimposta il valore restituito su "Ṙv", che viene stampato implicitamente al termine del programma esterno.

— Dennis
fonte

8 byte

— Erik the Outgolfer

4

Haskell , 51 byte

q prende una stringa e restituisce una stringa.

q s|t<-"main=putStr$fst`mappend`show$"=t++show(t,s)

Provalo online!

Esempio di output per putStr$q"test":

main=putStr$fst`mappend`show$("main=putStr$fst`mappend`show$","test")

Provalo online!

Mette il testo principale e la stringa desiderata in una tupla.
Utilizza fstper estrarre il testo principale.
Utilizza showper trasformare l'intera tupla in una stringa.
Utilizza mappendper combinare le due funzioni precedenti. Convenientemente mappendsu due funzioni fornisce una funzione che applica ciascuna funzione al suo argomento e combina i risultati con mappendil tipo di risultato (qui concatenazione di stringhe).

— Ørjan Johansen
fonte

4

Sottocarico , 14 byte

(~aSaS(:^)S):^

Provalo online!

Usa come (test)(~aSaS(:^)S):^- che è esso stesso un quine.

Come funziona

Underload è un linguaggio esoterico concatenativo (basato su stack). Non supporta l'input di lettura, quindi eventuali argomenti vengono inizialmente messi in pila.
(test)e (~aSaS(:^)S)sono letterali stringa, quindi posizionati in pila, con quest'ultimo in cima.
:duplica la (~aSaS(:^)S)stringa in cima allo stack, quindi ^esegue il suo contenuto come sottoprogramma.
~scambia i primi due elementi nello stack, quindi ora (test)è il più in alto.
aavvolge (test)tra parentesi extra.
Sprende la stringa ((test))in cima alla pila e la stampa senza le parentesi esterne (che sono solo sintassi letterale).
Ora aSstampa il resto (~aSaS(:^)S)sulla pila in modo simile (con le parentesi).
Alla fine, (:^)Sstampa la finale :^.

— Ørjan Johansen
fonte

Non funziona davvero )(come input, penso.

— R

@Riker True, Underload purtroppo non supporta le parentesi non corrispondenti. Ma i specifica domanda a- z.

— Ørjan Johansen,

Ah ok. Non l'ho notato.

— R

4

Sottocarico , 14 byte

a(aS(:^)S)~*:^

Provalo online!

Un approccio diverso dall'altra risposta Underload; piuttosto che essere esso stesso un quine, questo costruisce un quine. È interessante notare che arriva allo stesso numero di byte. Questa è una funzione che prende il suo argomento dallo stack e l'output all'output standard.

Spiegazione

a(aS(:^)S)~*:^
a               Generate a string literal containing the input
 (aS(:^)S)~*    Prepend "aS(:^)S"
            :^  Mockingbird: run the resulting function with itself as argument

La funzione risultante è simile al seguente:

aS(:^)S(input)
aS              Print a string literal containing the argument
  (:^)S         Print ":^"
       (input)  Push "input" onto the stack

In altre parole, stampa una stringa che contiene se stessa, seguita da :^. Questo è chiaramente un quine (perché ciò che è stato appena stampato è lo stesso del codice che abbiamo eseguito per eseguirlo in primo luogo).

Sembra che in TIO, è possibile eliminare l'iniziale a, purché non ti dispiaccia l'errore di segmentazione stampato su stderr quando l'input contiene a.

— Ørjan Johansen,

Non pensavo nemmeno di eseguire semplicemente la stringa letterale che l'utente fornisce, sulla base del fatto che il lavoro del programma è già finito a quel punto e senza (essere un personaggio che appare nell'input, tutti i programmi necessariamente non faranno nulla o si bloccheranno. Non penso nemmeno che sia specifico di TIO; il programma non è valido, ma ha già prodotto l'output desiderato al momento del crash.

2

V , 9 byte

ñ"qPxÉÑ~j

Provalo online!

Questa è una modifica dello standard V quine e sono orgoglioso che sia solo un byte più lungo.

hexdump:

00000000: f122 7150 78c9 d17e 6a                   ."qPx..~j

Spiegazione:

ñ           " Record the following commands into register 'q'
 "qP        " Paste register 'q' before all input
    x       " Delete the last character of what we just pasted (this will be a 'ÿ')
     ÉÑ     " Insert 'Ñ' at the beginning of this line
       ~    " Toggle the case of this character
        j   " Move down a line. During playback, this will cancel playback of the current macro,
            " So everything after here is a NOOP

Quindi, la registrazione si interrompe implicitamente e viene riprodotta. Ciò genererà il seguente output:

ñ"qPxÉÑ~jHello

Poiché jinterromperà la riproduzione della macro, non Helloverrà mai eseguito nulla .

— DJMcMayhem
fonte

2

Python 2, 38 byte

Sebbene l'input sia richiesto solo per il supporto a-z, dovrebbe funzionare con qualsiasi input a riga singola che non contenga byte NUL.

s='s=%r;print s%%s#'+input();print s%s

Provalo online

Per input abcil quine risultante è:

s='s=%r;print s%%s#abc';print s%s#abc

Provalo online

— mbomb007
fonte

1

RProgN 2 , 15 byte

"{']C'.%q[}]C"F

spiegato

Usando il formato

{']C'.%q[}]C}

dove si %qtrova l'input qouted, crea un quine del sapore

{']C'."Some Text"[}]C

che è uno standard RProgN2 quine, {']C'.}]Cche, prima di essere completato, aggiunge e distrugge la stringa immessa.

Provalo online!

— ATACO
fonte

1

Retina , 14 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

\(\`^
¶\(*S1`|

Provalo online!

Per input x, questo output:


\(*S1`|x
\(*S1`|x

Spiegazione

L'output è una modifica minore del quine standard . Usiamo semplicemente regex |xinvece di regex vuoto. Poiché i |permessi (e le priorità) ancora e la corrispondenza vuota, la funzionalità stessa non è interessata e poiché xconterrà sempre e solo lettere, è garantita la stessa sintassi regex stessa.

La stampa in realtà utilizza una tecnica simile alla quine stessa. Per evitare la duplicazione del quine, inseriamo ¶\(*S1`|solo una volta all'inizio della stringa. È esattamente metà del codice sorgente. Per stamparlo due volte senza un avanzamento di riga, utilizziamo la configurazione \(\, che avvolge l'intero programma in un gruppo e rende sia lo stage stesso che il gruppo che lo contiene stampano il risultato senza un avanzamento di riga.

— Martin Ender
fonte

1

Japt , 14 byte

"\"iQ ²ª`"+U ²

Provalo online! Per un input di abc, output

"iQ ²ª`abc"iQ ²ª`abc

che produce se stesso. Provalo online!

Spiegazione

Questa è un'estensione del Japt quine standard con capacità di payload:

"iQ ²"iQ ²

"iQ ²"      // Take this string.  iQ ²
      iQ    // Insert a quote.    "iQ ²
         ²  // Repeat this twice. "iQ ²"iQ ²
            // Implicit: output result of last expression

L'unica differenza è che aggiungiamo ª`abcalla fine, che in JavaScript è sostanzialmente ||"abc". Poiché il risultato della prima parte è sempre una stringa non vuota (in verità), ||non viene mai eseguito.

Esistono diverse versioni alternative della stessa lunghezza:

"iQ ²ª`abc"iQ ²ª`abc   quine||"abc"
"iQ ²ª$abc"iQ ²ª$abc   quine||abc
"iQ ²ª{abc"iQ ²ª{abc   quine||function(){ ... }
"iQ ²ªXabc"iQ ²ªXabc   quine||X.a(...) (X could be any uppercase letter or digit)
"iQ ²//abc"iQ ²//abc   quine//abc      (// is a comment in JS/Japt)
"iQ ²;[abc"iQ ²;[abc   quine;          (unmatched [ causes a parsing error)

— ETHproductions
fonte

0

CJam , 16 14 byte

"`_~"q`';++`_~

Provalo online!

Come funziona

"`_~"           e# Push "`_~"
     q`         e# Push a string representation of the input (input wrapped in quotes)
       ';       e# Push a semicolon
         ++     e# Concatenate all this together
           `    e# Get the string representation of the resulting string
            _~  e# Duplicate it and eval it (pushing the original string on the stack again)

Che produce qualcosa di simile "`_~\"test\";"`_~"test";.

— Gatto di affari
fonte

0

JavaScript, 21 byte

$=_=>`$=${$}/*${_}*/`

— ericw31415
fonte

0

Perl 5 , 35 byte

$_=q{say"\$_=q{$_};eval"#}.<>;eval

Provalo online!

— Dom Hastings
fonte

Stampa un quine che contiene l'input

Compito

Esempio

punteggio

Riferimenti

Python 3, 57 61 byte

Gelatina , 9 byte

Generatore

Come funziona

Quine

Come funziona

Haskell , 51 byte

Sottocarico , 14 byte

Come funziona

Sottocarico , 14 byte

Spiegazione

V , 9 byte

Python 2, 38 byte

RProgN 2 , 15 byte

spiegato

Retina , 14 byte

Spiegazione

Japt , 14 byte

Spiegazione

CJam , 16 14 byte

JavaScript, 21 byte

Perl 5 , 35 byte