No meu tempo no PPCG, notei que os problemas de quine e poliglota são bastante populares. Além disso, as meta-soluções para problemas, ou seja, scripts que geram um programa que é a solução para um problema, tendem a receber muito feedback positivo da comunidade. Portanto, eu criei esse desafio, que implementa essas três idéias.

Sua tarefa, leitor e entusiasta do código-golfe , é criar o mais curto possível um script que possa ser executado nos dois idiomas A e B para gerar quines para A e B. Quando o programa for executado no idioma A, ele deverá gerar um programa que é um quine no idioma B, mas não no idioma A e vice-versa. Os idiomas A e B podem ter uma versão diferente do mesmo idioma, desde que você tenha em mente que os quines gerados devem funcionar apenas em uma das versões.

Lembre-se de que as brechas padrão devem ser consideradas fechadas e apenas quines apropriadas são permitidas.

Boa sorte, o menor número de personagens vence!

CJam 0.6.6 dev / GolfScript, 15 14 12 bytes

"0$p"0$~a:n;

Graças a @ jimmy23013 por jogar fora 2 bytes!

Resto para ser atualizado.

Verificação

Como o envio envolve espaços em branco significativos, é melhor comparar os hexdumps.

$ xxd -g 1 mpquine
0000000: 22 60 30 24 7e 22 30 24 7e 4e 4d 3a 6e 3b        "`0$~"0$~NM:n;
$
$ cjam mpquine | tee quine.gs | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e 0a                 "`0$~"`0$~.
$ golfscript quine.gs | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e 0a                 "`0$~"`0$~.
$ cjam quine.gs | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e                    "`0$~"`0$~
$
$ golfscript mpquine | tee quine.cjam | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e                    "`0$~"`0$~
$ cjam quine.cjam | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e                    "`0$~"`0$~
$ golfscript quine.cjam | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e 0a                 "`0$~"`0$~.

CJam

CJam imprime "`0$~"0$~e um avanço de linha à direita.Experimente online!

O programa gerado é impresso "`0$~"0$~com o avanço de linha à direita no GolfScript ( Experimente online! ), Mas sem o avanço de linha no CJam ( Experimente online! ).

Como a metaquina funciona

"`0$~"         e# Push that string on the stack.
      0$~      e# Push a copy and evaluate it:
               e#   `     Inspect the string, pushing "\"`0$~\"".
               e#    0$   Push a copy.
               e#      ~  Evaluate, pushing "`0$~".
               e# Both "\"`0$~\"" and "`0$~" are now on the stack.
         NM    e# Push "\n" and "".
           :n; e# Map print over the elements of "" (none) and pop the result.
               e# "\"`0$~\"", "`0$~", and "\n" are now on the stack, and the
               e# characters they represent will be printed implicitly.

Como funciona o quine

"`0$~"          # Push that string on the stack.
      0$~       # As in CJam.
         <LF>   # Does nothing.
                # "\"`0$~\"" and "`0$~" are now on the stack, and the characters
                # they represent will be printed implicitly, plus a linefeed.

Ao contrário do GolfScript, o CJam não imprime um avanço de linha à direita, por padrão, portanto, não é um problema no CJam.

GolfScript

Impressões GolfScript "`0$~"0$~, sem deixar espaço em branco.Experimente online!

O programa gerado é impresso "`0$~"0$~sem espaços em branco no CJam ( Experimente online! ), Mas o GolfScript acrescenta um avanço de linha ( Experimente online! ).

Como a metaquina funciona

"`0$~"0$~       # As in CJam.
         NM     # Unrecognized token. Does nothing.
           :n   # Store the top of the stack – "`0$~" – in the variable n. n holds
                # "\n" by default. When the program finishes, the interpreter
                # prints n implicitly, usually resulting in a trailing linefeed.
                # By redefining n, it will print "0$~" instead.
             ;  # Pop the string from the stack so it won't be printed twice.

Como funciona o quine

"`0$~"0$~      e# Works as in GolfScript.

Ao contrário do CJam, o GolfScript anexa um avanço de linha ao conteúdo da pilha, portanto, isso não é uma questão no GolfScript.

CJam / Fissão, 22 bytes

"'!+OR'")5-"{'_'~}_~";

Experimente no CJam. Experimente em Fissão.

No CJam, isso imprime o padrão de fissão quine :

'!+OR"

Experimente o fission quine.

Em Fission, isso imprime uma "variante -less do padrão CJam quine:

{'_'~}_~

Experimente o CJam quine.

Isso também funciona para 22 bytes (imprimindo os mesmos limites):

"& *NQ!":)R"{'_'~}_~";

Explicação

No CJam:

"'!+OR'"    e# Push this string.
)           e# Pull off the last character.
5-          e# Subtract 5, turning ' into ".
"{'_'~}_~"  e# Push this string.
;           e# And discard it again.

Portanto, no final do programa, a pilha contém a sequência "'!+OR"e o caractere ", ambos impressos implicitamente.

Em Fissão, o fluxo do programa começa no Rátomo certo. '"apenas altera a massa de átomos ), 5e -são ignorados por vários motivos. Em seguida, o átomo entra no modo de impressão no "e imprime {'_'~}_~. ;destrói o átomo e finaliza o programa.

Clojure / Common Lisp, 274 bytes

(defmacro t []"((fn [s] (print (list s (list (quote quote) s)))) (quote (fn [s] (print (list s (list (quote quote) s))))))")(if '()(print(let[s clojure.string/replace](.toUpperCase(s(s(s(s(s(t)"fn""lambda")"[s]""(s)")"(quote ""'")"e)""e")")))))""))))"))))(eval '(princ(t))))

Alguns espaços adicionados para facilitar a leitura

(defmacro t []"((fn [s] (print (list s (list (quote quote) s))))
     (quote (fn [s] (print (list s (list (quote quote) s))))))")
(if '()(print(let[s clojure.string/replace](.toUpperCase
    (s(s(s(s(s(t)"fn""lambda")"[s]""(s)")"(quote ""'")"e)""e")")))))""))))"))))
    (eval '(princ(t))))

Define basicamente uma macro que retorna um quine no Clojure. Clojure requer parâmetros para definição de macro fornecidos como vetor ( []) enquanto Common Lisp (felizmente) simplesmente o ignora. Depois disso, diferimos 2 idiomas, avaliando '()qual é igual a nile, portanto, falsey no Common Lisp e trueno Clojure. Em seguida, fazemos manipulações de strings usando o Clojure, que o Common Lisp nem tenta avaliar como ocorre em outro iframo. O Clojure, por outro lado, tenta verificar se outro ramo está pelo menos correto antes de executar, por isso teve que usareval -lo para estar correto no Clojure e gerar a string correta no Common Lisp.

Nota: o retorno de duas strings diferentes provavelmente pode ser mais curto, mas não será diferente dos desafios poliglotas sobre a saída de strings diferentes em idiomas diferentes. ¯ \ _ (ツ) _ / ¯

Execução da fonte original do Clojure: https://ideone.com/SiQhPf

Execução da fonte original comum do Lisp: https://ideone.com/huLcty

Saída de Clojure: ((LAMBDA (S) (PRINT (LIST S (LIST 'QUOTE S)))) '(LAMBDA (S) (PRINT (LIST S (LIST 'QUOTE S)))))

Saída Lisp comum: ((fn [s] (print (list s (list (quote quote) s)))) (quote (fn [s] (print (list s (list (quote quote) s))))))

Saída de Clojure executada no Common Lisp: https://ideone.com/T1DF7H

Vice-versa: https://ideone.com/Fezayq

Jelly / GolfScript, 18 16 bytes

0000000: 3a 6e 22 ff cc cc 22 7d 7f fe 22 3a 6e 60 ff 3b  :n"..."}..":n`.;

Verificação

O teste de todos os programas envolvidos com o fluxo exato de bytes só pode ser feito localmente.

$ LANG=en_US # Latin-1. Jelly doesn't care about the exact encoding,
$            # as longs as it's not UTF-8.
$
$ xxd -g 1 mpquine
0000000: 3a 6e 22 ff cc cc 22 7d 7f fe 22 3a 6e 60 ff 3b  :n"..."}..":n`.;
$
$ jelly f mpquine | tee quine.gs | xxd -g 1
0000000: 22 3a 6e 60 22 3a 6e 60                          ":n`":n`
$ golfscript quine.gs | xxd -g 1
0000000: 22 3a 6e 60 22 3a 6e 60                          ":n`":n`
$ jelly f quine.gs 2> /dev/null | xxd -g 1
$
$ golfscript mpquine | tee quine.jelly | xxd -g 1
0000000: ff cc cc                                         ...
$ jelly f quine.jelly | xxd -g 1
0000000: ff cc cc                                         ...
$ golfscript quine.jelly | xxd -g 1
0000000: 0a

Geléia

Com a página de código de Jelly , o programa tem a seguinte aparência.

:n"”ṘṘ"}
“":n`”;

Isso imprime ( Experimente online! )

":n`":n`

que é um quine no GolfScript ( Experimente on-line! ), mas um erro do analisador no Jelly ( Experimente on-line! ).

GolfScript

No latim-1, o programa tem a seguinte aparência, com um caractere DEL não imprimível entre }e þ.

:n"ÿÌÌ"} þ":n`ÿ;

Isso imprime ( Experimente online! )

ÿÌÌ

ou visualizado com a página de código de Jelly,

”ṘṘ

que é um quine no Jelly ( Experimente online! ), mas apenas imprime um avanço de linha no GolfScript ( Experimente online! ).

JavaScript / C 278 bytes

Em impressionantes 278 bytes:

//\
console.log('int main(){char*A="int main(){char*A=%c%s%c;printf(A,34,A,34);}";printf(A,34,A,34);}');/*
int main(){puts("A='A=;B=String.fromCharCode(39);console.log(A.slice(0,2)+B+A+B+A.slice(2));';B=String.fromCharCode(39);console.log(A.slice(0,2)+B+A+B+A.slice(2));");}//*/

OCine:

int main(){char*A="int main(){char*A=%c%s%c;printf(A,34,A,34);}";printf(A,34,A,34);}

A coluna JavaScript:

A='A=;B=String.fromCharCode(39);console.log(A.slice(0,2)+B+A+B+A.slice(2));';B=String.fromCharCode(39);console.log(A.slice(0,2)+B+A+B+A.slice(2));

Befunge / Fissão, 35 bytes

"$TQ-#'">,#-:#2_@;"+1_@#`+66:,g0:"L

Experimente em Befunge | Experimente em Fissão

Em Befunge, produz a quina de fissão :

'!+OR"

Em Fissão, produz o quine Befunge :

:0g,:66+`#@_1+

Python / Retina, 70 65 64 66 bytes

Eu usei a mesma estratégia que usei na poliglota Python / Retina anterior .

#
print"\nS`((.+))"*2+"\n\n"
#?
#_='_=%r;%_\n';_
#?;
#;print _%
#

Experimente em Python | Experimente na Retina

#é um comentário em Python, portanto, ele simplesmente imprime a retina em Python. Na Retina, o primeiro estágio (2 linhas) não faz nada, porque não #será encontrado na entrada. O próximo estágio não substitui nada pela base do Python Quine. O terceiro estágio substitui cada ponto e vírgula pela #print _%peça. O último estágio remove todos #.

Quine na Retina:

S`((.+))
S`((.+))

Quine em Python:

_='_=%r;print _%%_\n';print _%_

Os cordões utilizados podem ser vistos neste desafio . O retine quine é um erro no Python, e o python quine não possui saída no Retina.

Python 3 / Python 2, 62 bytes

_='_=%r;print(_%%_['+'~'*-~int(-1/2)+'int(-1/2):])';print(_%_)

Experimente no Python 2 , Python 3 .

Baseado no Python Quine aqui . O fator de distinção entre as duas versões é o que elas fazem int(-1/2): no Python 2, /é a divisão inteira (arredondamento para baixo), com o resultado de -1; no Python 3, /é a divisão de ponto flutuante ( -0.5), que inttrunca para 0.

Construímos uma corda _em três partes. '_=%r;print(_%%_['e 'int(-1/2):])'são sempre os mesmos. A parte interessante é '~'*-~int(-1/2):

• No Python 2, -~int(-1/2)é 0e o til não é adicionado à string;
• No Python 3, -~int(-1/2)é 1e o til é adicionado à string.

Assim, o Python 2 gera a solução Python 3

_='_=%r;print(_%%_[int(-1/2):])';print(_%_[int(-1/2):])

e Python 3 produz a solução Python 2

_='_=%r;print(_%%_[~int(-1/2):])';print(_%_[~int(-1/2):])

Em cada versão, a expressão dentro é [ :]avaliada como 0, o que faz com que a fatia inclua a cadeia inteira, enquanto no idioma errado que ela avalia -1, o que faz com que a fatia inclua apenas o último caractere, truncando a saída para que não seja uma solução completa.

Brain-Flak , brainfuck 4617 4009 bytes

((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()()()())))()())[()()])))()()())[()()])))())[()])[()()()()])))))))))))))))))))))))))))))))))))))))))))()()())()())[()()()()])()()())[()()])()())[()()()()])()()()))()()())[()()])[()()()()])))))))))))))))))))()())))()()())[()()()()])()()()()())[()()]))()())[()()()])()())[()()])))()()())[()()])))())[()()])[()()()])))))))))))))))))))))))))))))))))))))))))))()()()())[()()()])()()()())[()()])[()()()]))()()()())[()()()])()()()())[()()])[()()()])()()()())[()()()])()()()())[()()])[()()()]))))))))))))))()()()())[()()()])()()()())[()()])[()()()]))()()()())[()()()])()()()())[()()])[()()()])))))))))))))))))))))))))))))()()()())[()()()])()()()())[()()])[()()()]))()()()())[()()()])()()()()()))))))[()()()])[()])()()))))()()){({}<>)<>}<>([]){({}[()]<(({}[()]<((((((()()()){}())){}{}){}())<>)>)<>){({}[()]<({}()())>){({}[()]<({}())>){({}[()]<({}((()()()){}()){})>){({}[()]<({}()())>){({}[()]<({}(((()()()){}()){}){}())>){(<{}({}()())>)}}}}}}{}([]<({}<{({}<>)<>}<>>)>){({}[()]<({}<>)<>>)}{}{({}[()]<(({}))>)}{}(((({})(((()()())){}{}){}())))<>>)}{}{<>({}<>)}{+++++++>>>+>>>+++++++>>>++++++++>>>+++>>>++++>>>++>>>+++>>>++++>>>++++++++>>>+++>>>++++>>>+>>>+++++>>>++++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+>>>+>>>+>>>+>>>+>>>+>>>+>>>+>>>++>>>+>>>++>>>+>>>++>>>+>>>++>>>+>>>++>>>++>>>+++++++>>>++++++++>>>++>>>+++++++>>>++++++++>>>++>>>+++++++>>>++++++++>>>++>>>+++>>>++++>>>++>>>++>>>+>>>++>>>++>>>++>>>++++>>>++>>>+++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>+>>>+>>>+>>>++>>>+>>>++>>>+>>>++>>>++>>>++>>>+++++++>>>++++++++>>>+++++++>>>++++++++>>>++>>>+++++++>>>++++++++>>>+>>>++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>++>>>+>>>++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>+>>>+>>>+>>>++>>>+>>>++>>>+>>>++>>>++>>>+++++++>>>++++++++>>>+>>>++>>>++>>>+++++++>>>++++++++>>>++>>>+++++++>>>++++++++>>>+>>>++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>++>>>+>>>++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>+>>>+>>>+>>>++>>>+>>>++>>>+>>>++>>>+>>>++>>>+>>>++>>>++>>>++>>>+++++++>>>++++++++>>>+++++++>>>++++++++>>>++>>>+++++++>>>++++++++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++>>>+++++++>>>++++++++>>>+>>>+++++++>>>++++++++>>>+>>>++>>>+>>>++>>>++>>>++++>>>++>>>++++++++>>>++++++++>>>++++++++>>>++++++++>>>++++++++>>>++++++++>>>++++++++>>>+++++++>>>++++++++>>>+>>>+++++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++>>>++++>>>++>>>+++>>>++++>>>++++++++>>>+++>>>++++>>>++++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+++>>>++++>>>++>>>+++>>>++++>>>++++>>>++>>>++++++++>>>+++++++>>>++++++++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>++>>>+>>>++>>>++>>>++>>>++++>>>++>>>++++++++>>>+++++++>>>++++++++>>>+++>>>++++>>>++++>>>++>>>++++++++>>>+++++++>>>++++++++>>>+++>>>++++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++>>>++++>>>++>>>+++>>>++++>>>++++++++>>>+++>>>++++>>><<<[<<<]>>>[>++++++++++++++++++++++++++++++++++++++++.<[->.+.->+<<]>+.[-]>>]<[<<<]>>>[<++++++++++++++++++++++++++++++++++++++++>-[<+>-[<+++++++++++++++++++>-[<++>-[<+++++++++++++++++++++++++++++>-[<++>-[<++++++++++++++++++++++++++++++>-[<++>-]]]]]]]<.>>>>]}{}

Experimente online!

Experimente online!

A explicação está a caminho. Eu ainda estou jogando este