Tarefa

Você receberá uma string na entrada que consiste apenas nos caracteres de aa z, ou seja, a entrada corresponderá ao regex /^[a-z]*$/.

Sua saída deve ser um programa completo no mesmo idioma, cujo código fonte contém a entrada e é uma opção adequada.

Exemplo

Seu programa receberia a entrada abce a saída:

...abc...

O acima deve ser um programa completo no mesmo idioma que não requer entrada e saída:

...abc...

isto é, ele próprio sai.

Pontuação

Isso é código-golfe . A resposta mais curta em bytes vence.

Referências

• O que conta como uma solução adequada?

Python 3, 57 61 bytes

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

Pega um quine básico python 3 daqui e substitui o nome da variável pela entrada.

Nota: Como foi salientado pelo Hyper Neutrino em comentários, este não funciona para palavras-chave reservadas como for, if, etc.

O acréscimo de um caractere que nenhuma das palavras-chave reservadas termina com 'x'um número como esse ou qualquer número corrige isso. (Ørjan Johansen).

Geléia , 9 bytes

Gerador

;“¶Øv”ṾØv

Experimente online!

Como funciona

;“¶Ø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 a entrada for quine, o seguinte programa será gerado.

“quine
Øv”Ṙv

Experimente online!

Como funciona

Este é o padrão Jelly quine. Primeiro,

“quine
Øv”

define o argumento esquerdo e o valor de retorno para a sequência "quine\nØv".

Em seguida, Ṙimprime uma representação de sequência (o código do bloco anterior) e retorna a sequência inalterada.

Depois, vpega o argumento esquerdo e o passa como entrada para o programa Jelly

quine
Øv

Em todos os programas Jelly, apenas o link principal (definido na última linha) é executado, portanto a primeira linha é totalmente ignorada.

Por fim, Øvdefine o valor de retorno como "Ṙv", que é impresso implicitamente quando o programa externo é concluído.

Haskell , 51 bytes

q pega uma string e retorna uma string.

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

Experimente online!

Exemplo de saída para putStr$q"test":

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

Experimente online!

• Coloca o texto quine principal e a string desejada em uma tupla.
• Usa fstpara extrair o texto principal.
• Usos show para transformar toda a tupla em uma string.
• Usa mappendpara combinar as duas funções anteriores. Convenientemente mappendem duas funções, fornece uma função que aplica cada função ao seu argumento e combina os resultados com mappendo tipo de resultado (aqui concatenação de cadeias).

Subcarga , 14 bytes

(~aSaS(:^)S):^

Experimente online!

Use como (test)(~aSaS(:^)S):^ - que é em si uma solução.

Como funciona

• Underload é uma linguagem esotérica concatenativa (baseada em pilha). Ele não suporta entrada de leitura, portanto, qualquer argumento é colocado na pilha inicialmente.
• (test)e (~aSaS(:^)S)são literais de seqüência de caracteres, então coloque-se na pilha, com o último no topo.
• :duplica a (~aSaS(:^)S)string no topo da pilha e ^executa seu conteúdo como um subprograma.
• ~troca os dois principais elementos da pilha, agora (test)está no topo .
• aenvolve (test)entre parênteses extras.
• S pega a corda ((test)) no topo da pilha e a imprime sem os parênteses externos (que são apenas sintaxe literal).
• Agora aSimprime o restante(~aSaS(:^)S) na pilha da mesma forma (com parênteses).
• Por fim, (:^)Simprime a final :^.

Subcarga , 14 bytes

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

Experimente online!

Uma abordagem diferente da outra resposta do Underload; ao invés de ser um quine, ele constrói um quine. Curiosamente, ele sai com o mesmo número de bytes. Esta é uma função que leva seu argumento da pilha e produz para a saída padrão.

Explicação

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

A função resultante é assim:

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

Em outras palavras, ele imprime uma string literal contendo a si mesma, seguida por :^. Isso é claramente um problema (porque o que acabou de ser impresso é o mesmo que o código que executamos para executá-lo).

V , 9 bytes

ñ"qPxÉÑ~j

Experimente online!

Essa é uma modificação do padrão V quine e estou orgulhoso de que este seja apenas um byte a mais.

Hexdump:

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

Explicação:

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

Então, a gravação para implicitamente e é reproduzida. Isso irá gerar a seguinte saída:

ñ"qPxÉÑ~jHello

Como jinterromperá a reprodução da macro, nada Helloserá executado.

Python 2, 38 bytes

Embora a entrada seja necessária apenas para oferecer suporte a-z, isso deve funcionar com qualquer entrada de linha única que não contenha bytes NUL.

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

Experimente online

Para entrada, abca solução resultante é:

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

Experimente online

RProgN 2 , 15 bytes

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

Explicado

Usando o formato

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

onde %qestá a entrada qouted, constrói uma quantidade do sabor

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

que é um quine RProgN2 padrão, {']C'.}]Cque, antes de concluído, anexa e destrói a sequência de caracteres inserida.

Experimente online!

Retina , 14 bytes

A contagem de bytes assume a codificação ISO 8859-1.

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

Experimente online!

Para entrada x, isso gera:

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

Explicação

A saída é uma pequena modificação do padrão quine . Simplesmente usamos a regex em |xvez da regex vazia. Como a correspondência |ainda permite (e prioriza) e a correspondência vazia, a funcionalidade em si não é afetada e, comox sempre conterá letras, é garantida a própria sintaxe regex válida.

Imprimir isso realmente usa uma técnica que é semelhante ao próprio quine. Para evitar a duplicação do quine, inserimos ¶\(*S1`|apenas uma vez no início da string. Isso é exatamente metade do código fonte. Para imprimi-lo duas vezes sem avanço de linha, usamos a configuração \(\, que agrupa o programa inteiro em um grupo e cria o próprio palco, bem como o grupo que o contém, imprime o resultado sem avanço de linha.

Japt , 14 bytes

"\"iQ ²ª`"+U ²

Teste online! Para uma entrada deabc , saídas

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

que produz a si próprio. Teste online!

Explicação

Esta é uma extensão do padrão Japt com capacidade de carga útil:

"iQ ²"iQ ²

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

A única diferença é que anexamos ª`abcno final, que em JavaScript é basicamente ||"abc". Como o resultado da primeira parte é sempre uma string não vazia (verdade), o|| nunca é executada.

Existem várias versões alternativas do mesmo comprimento:

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

CJam , 16 14 bytes

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

Experimente online!

Como funciona

"`_~"           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)

Que produz algo parecido "`_~\"test\";"`_~"test";.

JavaScript, 21 bytes

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

Perl 5 , 35 bytes

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

Experimente online!