Nel mio periodo su PPCG, ho notato che i problemi di quine e poliglotta sono piuttosto popolari. Inoltre, le meta-soluzioni ai problemi, ovvero gli script che generano un programma che è la soluzione a un problema, tendono a ricevere molti feedback positivi dalla comunità. Pertanto, ho creato questa sfida, che implementa queste tre idee.

Il tuo compito quindi, lettore ed appassionato di code-golf , è quello di creare il più breve possibile uno script che possa essere eseguito in due lingue A e B per generare quine per A e B. Quando il tuo programma viene eseguito in lingua A, dovrebbe generare un programma che è un quine nella lingua B ma non nella lingua A e viceversa. Le lingue A e B possono essere versioni diverse della stessa lingua, a condizione che si tenga presente che i quines generati dovrebbero funzionare solo in una delle versioni.

Tieni presente che le scappatoie standard devono essere considerate chiuse e sono consentiti solo quines adeguati .

Buona fortuna, vince il minor numero di personaggi!

CJam 0.6.6 dev / GolfScript, 15 14 12 byte

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

Grazie a @ jimmy23013 per giocare a golf con 2 byte!

Riposo da aggiornare.

Verifica

Dal momento che l'invio comporta spazi significativi, è meglio confrontare i dump esadecimali.

$ 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

Stampe CJam "`0$~"0$~e un avanzamento riga finale. Provalo online!

Il programma generato stampa "`0$~"0$~con l'avanzamento di riga finale in GolfScript ( Provalo online! ), Ma senza l'avanzamento di riga in CJam ( Provalo online! ).

Come funziona la metaquina

"`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.

Come funziona il 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.

A differenza di GolfScript, CJam non stampa un avanzamento riga di default, quindi questo non è un quine in CJam.

GolfScript

Stampa GolfScript "`0$~"0$~, senza spazi vuoti finali. Provalo online!

Il programma generato stampa "`0$~"0$~senza trascurare gli spazi bianchi in CJam ( Provalo online! ), Ma GolfScript aggiunge un avanzamento riga ( Provalo online! ).

Come funziona la metaquina

"`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.

Come funziona il quine

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

A differenza di CJam, GolfScript aggiungerà un avanzamento di riga al contenuto dello stack, quindi questo non è un quine in GolfScript.

CJam / Fissione, 22 byte

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

Provalo in CJam. Provalo in Fissione.

In CJam, questo stampa il quine Fission standard :

'!+OR"

Prova il Finequine.

In Fissione, questo stampa una "variante senza-lo dello standard CJam quine:

{'_'~}_~

Prova il CJam Quine.

Questo funziona anche per 22 byte (stampando le stesse quines):

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

Spiegazione

In 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.

Quindi alla fine del programma, lo stack contiene la stringa "'!+OR"e il carattere ", entrambi implicitamente stampati.

In Fissione, il flusso del programma inizia Rcon un atomo a destra. '"cambia solo la massa atomi, ), 5e -vengono ignorati per vari motivi. Quindi l'atomo entra in modalità di stampa su "e stampa {'_'~}_~. ;distrugge l'atomo e termina il programma.

Clojure / Lisp comune, 274 byte

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

Alcuni spazi aggiunti per la leggibilità

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

Definisce sostanzialmente una macro che restituisce un quine in Clojure. Clojure richiede parametri per la definizione di macro fornita come vector ( []) mentre Common Lisp (per fortuna) lo ignora. Dopodiché differiamo 2 lingue valutando '()quale è uguale nile quindi falso in Common Lisp ed è truein Clojure. Quindi eseguiamo manipolazioni di stringhe usando Clojure che Common Lisp non prova nemmeno a valutare mentre va in un altro iframo. Clojure, d'altra parte, cerca di verificare se almeno un altro ramo è corretto prima dell'esecuzione, quindi è stato necessario utilizzarlo evalper essere sia corretto in Clojure sia per generare una stringa corretta in Common Lisp.

Nota: il semplice ritorno di due stringhe diverse potrebbe essere probabilmente più breve ma non sarà diverso dalle sfide di un poliglotta sull'output di stringhe diverse in lingue diverse. ¯ \ _ (ツ) _ / ¯

Esecuzione della sorgente originale Clojure: https://ideone.com/SiQhPf

Esecuzione della fonte originale comune di Lisp: https://ideone.com/huLcty

Uscita clojure: ((LAMBDA (S) (PRINT (LIST S (LIST 'QUOTE S)))) '(LAMBDA (S) (PRINT (LIST S (LIST 'QUOTE S)))))

Uscita Lisp comune: ((fn [s] (print (list s (list (quote quote) s)))) (quote (fn [s] (print (list s (list (quote quote) s))))))

L'output di Clojure viene eseguito in Common Lisp: https://ideone.com/T1DF7H

Viceversa: https://ideone.com/Fezayq

Jelly / GolfScript, 18 16 byte

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

Verifica

Il test di tutti i programmi coinvolti con i flussi di byte esatti può essere eseguito solo 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

Gelatina

Con la code page di Jelly , il programma ha il seguente aspetto.

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

Questo stampa ( provalo online! )

":n`":n`

che è un quine in GolfScript ( provalo online! ), ma un errore parser in Jelly ( provalo online! ).

GolfScript

In Latin-1, il programma ha il seguente aspetto, con un carattere DEL non stampabile tra }e þ.

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

Questo stampa ( provalo online! )

ÿÌÌ

oppure, visualizzato con la codepage di Jelly,

”ṘṘ

che è una quine in Jelly ( provalo online! ), ma stampa solo un avanzamento riga in GolfScript ( provalo online! ).

JavaScript / C 278 byte

Con uno strabiliante 278 byte:

//\
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));");}//*/

The C quine:

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

Quine 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 / Fission, 35 byte

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

Provalo in Befunge | Provalo in Fissione

In Befunge questo produce il quine Fission :

'!+OR"

In Fission questo produce il quine Befunge :

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

Python / Retina, 70 65 64 66 byte

Ho usato la stessa strategia che avevo usato nel mio precedente poliglotta Python / Retina .

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

Prova in Python | Prova a Retina

#è un commento in Python, quindi stampa semplicemente il retino di Retina in Python. In Retina, il primo stadio (2 righe) non fa nulla, perché non #verrà trovato alcun input. La fase successiva non sostituisce nulla con la base del quine Python. Il terzo stadio sostituisce ogni punto e virgola con il #print _%pezzo. L'ultima fase rimuove tutto #.

Quine in Retina:

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

Quine in Python:

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

I quines utilizzati possono essere visti in questa sfida . Retina Quine è un errore in Python e Python Quine non ha output in Retina.

Python 3 / Python 2, 62 byte

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

Provalo in Python 2 , Python 3 .

Basato sul quine Python qui . Il fattore distintivo tra le due versioni è quello che fanno int(-1/2): in Python 2, /è la divisione intera (arrotondamento per difetto), con un risultato di -1; in Python 3, /è la divisione in virgola mobile ( -0.5), che si inttronca in 0.

Costruiamo una stringa _in tre parti. '_=%r;print(_%%_['e 'int(-1/2):])'sono sempre gli stessi. La parte interessante è '~'*-~int(-1/2):

• In Python 2 -~int(-1/2)è 0, e la tilde non viene aggiunta alla stringa;
• In Python 3 -~int(-1/2)è 1, e la tilde viene aggiunta alla stringa.

Pertanto, Python 2 genera il quine di Python 3

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

e Python 3 genera il quine di Python 2

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

In ogni versione, viene [ :]valutata l'espressione all'interno 0, che rende la sezione include l'intera stringa, mentre nella lingua sbagliata a cui valuta -1, che rende la sezione include solo l'ultimo carattere, troncando l'output in modo che non sia un quine completo.

Brain-Flak , Brainfuck 4617 4009 byte

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

Provalo online!

Provalo online!

Sta per arrivare la spiegazione, sto ancora giocando a golf