Um metaquine é um programa que não é um quine, mas cuja saída, quando executada como um programa no mesmo idioma, é um quine.

O objetivo deste desafio é escrever uma metaquina. Isso é código-golfe , o código mais curto vence, com a resposta mais antiga usada como desempate. Observe que apenas programas completos são aceitáveis ​​devido à definição de quine.

Regras para Quines

Somente quines verdadeiros são aceitos. Ou seja, você precisa imprimir todo o código fonte literalmente para STDOUT, sem :

• lendo seu código fonte, direta ou indiretamente.
• confiando em um ambiente REPL que simplesmente avalia e imprime todas as expressões que você alimenta.
• confiando em recursos de idioma que apenas imprimem a fonte em certos casos.
• usando mensagens de erro ou STDERR para escrever a totalidade ou parte da solução. (Você pode escrever coisas para STDERR ou produzir avisos / erros não fatais, desde que STDOUT seja uma solução válida e as mensagens de erro não façam parte dela.)
• o código-fonte que consiste apenas de literais (sejam literais de seqüência de caracteres, literais numéricos etc.) e / ou NOPs.

Qualquer saída não suprimível (como avisos de direitos autorais, mensagens de inicialização / desligamento ou um avanço de linha à direita) pode ser ignorada na saída para garantir a validade do quine.

Exemplo

Ignorando a regra que proíbe programas somente literais e quining interno, isso seria uma metaquina em Seriamente:

"Q"

O programa consiste na literal de cadeia única "Q", que é impressa implicitamente na saída. Quando a saída ( Q) é executada, é um quine ( Qé a função quine interna).

CJam, 6 bytes

"_p"_p

Impressões

"_p"
_p

que é a menor solução adequada para CJam.

Teste aqui.

Explicação

Ambos os programas funcionam exatamente da mesma maneira, já que o avanço de linha dentro do quine adequado é não operacional e incluído apenas porque é mais caro removê-lo da saída. Como os programas funcionam:

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

O mesmo funciona no GolfScript que

".p".p

que imprime

".p"
.p

com um avanço de linha à direita, que, por sua vez, é um dos peixes mais curtos conhecidos.

Pitão, 12 11 10 9 bytes

Bati mais um byte graças a @ Pietu1998.

jN B".[9N

Isso imprime

.[9N".[9N

que é um quine em Pyth. Você pode experimentá-lo aqui .

Fissão , 6 bytes

!+OR"'

Impressões

'!+OR"

Qual é o quine Fission mais curto . Isso funciona porque as mudanças cíclicas do programa deixam sua saída completamente inalterada.

Experimente online!

Javascript ES6, 21 bytes

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

Trivial.

Python 2, 29 bytes

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

Acontece que o conhecido short python quine é facilmente transformado em uma metaquina :)

E, como não precisamos nos preocupar em combinar a nova linha à direita, a metaquina é realmente mais curta!

Japonês, 15 13 bytes

Q+"+Q ³s7J" ²

Teste online!

Este programa gera

"+Q ³s7J"+Q ³s7J

que é o quine mais curto conhecido em Japt.

Como funciona

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

Versão não concorrente, 11 bytes

Q+"+Q ²é" ²

Eu apenas acrescentou é , um comando de "rotação". então

"+Q ²é"+Q ²é

agora é uma solução válida.

Ruby, 25 23

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

Gera a clássica ruby ​​HEREdoc quine

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

Solução antiga

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

Gera-se, exceto com as aspas simples substituídas por aspas duplas.

JavaScript, 50 bytes

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

Baseado no quine JS mais curto, sem leitura de origem, conhecido pelo homem , mas um bom 8 bytes mais curto. Impressões

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

que é um quine.

Peixe (> <>), 17 bytes

Isso funciona usando o quine de peixe clássico, "r00g!;oooooooo|mas adiciona um {que desloca toda a pilha para a esquerda, para que o programa original não seja um quine, mas sua saída, quando executada, é.

"{r00g!;oooooooo|

Saídas:

"r00g!;oooooooo|

que é um peixe quine!

Gelatina , 3 bytes (não concorrente)

Infelizmente, os átomos necessários são aproximadamente duas semanas mais novos que o desafio.

Metaquina

”Ṙv

Experimente online!

Como funciona

”Ṙ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

”ṘṘ

Experimente online!

Como funciona

”ṘṘ  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.

Como o segundo Ṙimprime os dois primeiros caracteres ( ”Ṙ), essa é uma definição adequada para nossa definição.

Octopen-Baru, 22 bytes

** Resposta não concorrente

愛[35211].pack歩U')

Saída Ruby

puts [35211].pack(' U')

Quais saídas 見. Que é uma quine em Octopen-Baru!

7 , 2 bytes, desafio de pós-datas de idiomas

O programa tem dois bytes de comprimento e pode ser interpretado de várias maneiras; como um dump hexadecimal:

00000000: 4ff4                                     O.

como página de código 437:

O⌠

ou, mais facilmente, em octal (que 7 usa nativamente):

237723

Experimente online!

O funcionamento disso é muito simples: é o quine padrão 7 com um elemento de pilha não operacional inserido entre as duas metades, para torná-lo diferente (nesse contexto, 7separa os elementos de pilha). (Eu também poderia ter inserido no início 723723. Eu não poderia ter interpretado no final, porque 7s à direita são como espaços em branco à direita e ignorados na codificação compactada, portanto, não seria diferente do programa de saída. )

Aliás, este programa é um palíndromo em hexadecimal, mas isso é apenas coincidência.

Subcarga, 11 bytes

(:aSS)::aSS

Bem simples. Ela é impressa (:aSS):aSS, que é a solução padrão Underload.

Braquilog , 12 bytes

"~k;?w₁"gjw₃

Experimente online!

Uma das 132 variações de metaquina do mesmo comprimento na coluna que eu traduzi da coluna Brachylog v1 (sem trapaça) de Fatalize. Na verdade, eu escrevi um programa (sem golfe e bobo em geral) para imprimir todos eles:

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

Experimente online!

Há duas partes do Quine original, que poderia ser substituído inconseqüente: ;?pode ser alterado para gjou jḍe ₁podem ser alteradas para ₃, ₅ou ₇. Se mantivermos ou alterá-los fora da literal da cadeia de caracteres de uma maneira e dentro da literal da cadeia de caracteres de uma maneira diferente, a saída não corresponderá à origem, porque as variantes presentes na literal da cadeia de caracteres serão impressas dentro e fora dela. , resultando em uma solução que não era a execução inicial do programa.

;?, gjE jḍsão intercambiáveis porque todos os três par o literal string com si: devido à disposição do programa, a variável de entrada ?é unificado com a corda, então ;?pares a corda com si mesmo; independentemente do layout, gjagrupa a string em uma lista que é concatenada para si mesma; da mesma forma jḍconcatena a corda para si mesma e depois a divide pela metade.

Os wsubscritos de números ímpares são intercambiáveis ​​porque, embora originalmente wpudesse levar apenas 0 ou 1, com 0 imprimindo a entrada em we 1 imprimindo o primeiro elemento formatado com o segundo, o inventário de subscrito wse transformou em algo que funciona externamente como um campo de bits: o bit baixo do subscrito codifica se é direto ou formatado, o bit médio codifica se a variável de saída dewé irrestrito ou definido como entrada, e o bit alto codifica se a impressão é feita imediatamente ou se está atrasada até o final do programa para que possa estar sujeita a retrocesso. (Esses subscritos foram minha primeira e até agora maior contribuição para o Brachylog.) Como o quine e o metaquine não usam a variável de saída e não retrocedem, todos os quatro subscritos ímpares são equivalentes.

Befunge-93, 22 bytes

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

Acabei de pegar o quine padrão, colocá-lo entre aspas, invertê-lo (para que ele seja carregado corretamente na pilha) e adicionei uma impressão de pilha no final.

São 8 caracteres adicionados ao quine normal, então é muito possível que exista uma solução melhor.

Turtlèd , 52 bytes (não competitivo)

1 menos que o quine original

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

Funciona da mesma maneira, exceto que ele não possui um caractere no final; quando executado, ele terá um caractere no final, que não afeta a saída, porque grava # em um #. Observe que o resultado é um pouco diferente do quine que fiz para o desafio do quine, mas funciona da mesma maneira: "escreve #, que é seu último caractere, como o quine que fiz. Confira a explicação aqui .

Lua, 45 bytes

Código Quine não meu.

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

vai resultar em

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

que é um quine. Ainda bem que ;é opcional em Lua.

Pushy , 7 bytes

Não competir, pois o idioma adia o desafio.

Este é o quine padrão, mas com as novas linhas removidas. As novas linhas não significam nada no Pushy, mas são o separador padrão do operador de impressão e, portanto, são necessárias para uma verdadeira solução.

95 34_"

Experimente online! Isso gera:

95 34
_ "

Qual é o quine Pushy mais curto - uma explicação sobre como ele funciona pode ser encontrada aqui .

Como alternativa, H5-34_"funciona para a mesma contagem de bytes.

Espuma , 14 bytes

[. .'|: ~|]: ~

Isso imprime a segunda espuma de espuma que pode ser encontrada aqui . Na verdade, é mais curto, porque .sempre colocamos um espaço entre cada elemento, mas a barra no terceiro token permite-me omitir o espaço antes dele.

Casca , 6 bytes

D"S+s¨

Experimente online!

Imprime o padrão Husk quine S+s"S+s".

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

O quine explicou:

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