Pendant mon temps sur PPCG, j'ai remarqué que les problèmes de quine et les problèmes de polyglotte sont très populaires. En outre, les méta-solutions aux problèmes, c'est-à-dire les scripts qui génèrent un programme qui est la solution à un problème, ont tendance à obtenir beaucoup de retours positifs de la communauté. Par conséquent, j'ai créé ce défi, qui met en œuvre ces trois idées.

Votre tâche alors, lecteur et passionné de golf de code , est de créer le plus court possible un script qui peut s'exécuter dans deux langues A et B pour générer des quines pour A et B. Lorsque votre programme est exécuté dans la langue A, il doit générer un programme qui est une quine en langue B mais pas en langue A et vice versa. Les langues A et B peuvent être des versions différentes de la même langue, à condition de garder à l'esprit que les quines générées ne devraient fonctionner que dans l'une des versions.

Gardez à l'esprit que les failles standard doivent être considérées comme fermées et que seules les quines appropriées sont autorisées.

Bonne chance, le moins de personnages gagne!

CJam 0.6.6 dev / GolfScript, 15 14 12 octets

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

Merci à @ jimmy23013 pour avoir joué au golf sur 2 octets!

Reste à mettre à jour.

Vérification

Étant donné que la soumission implique des espaces importants, il est préférable de comparer les 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$~et un saut de ligne arrière. Essayez-le en ligne!

Le programme généré s'imprime "`0$~"0$~avec le saut de ligne dans GolfScript ( essayez-le en ligne! ), Mais sans le saut de ligne dans CJam ( essayez-le en ligne! ).

Comment fonctionne la métaquine

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

Comment fonctionne le 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.

Contrairement à GolfScript, CJam n'imprime pas de saut de ligne par défaut, ce n'est donc pas une quine dans CJam.

GolfScript

Impressions GolfScript "`0$~"0$~, sans espaces blancs. Essayez-le en ligne!

Le programme généré s'imprime "`0$~"0$~sans espaces blancs dans CJam ( essayez-le en ligne! ), Mais GolfScript ajoute un saut de ligne ( essayez-le en ligne! ).

Comment fonctionne la métaquine

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

Comment fonctionne le quine

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

Contrairement à CJam, GolfScript ajoutera un saut de ligne au contenu de la pile, ce n'est donc pas une quine dans GolfScript.

CJam / Fission, 22 octets

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

Essayez-le dans CJam. Essayez-le à Fission.

Dans CJam, cela imprime le quine standard de fission :

'!+OR"

Essayez le quine Fission.

Dans Fission, cela imprime une "variante -less du quine CJam standard:

{'_'~}_~

Essayez le quine CJam.

Cela fonctionne également pour 22 octets (impression des mêmes quines):

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

Explication

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

Donc à la fin du programme, la pile contient la chaîne "'!+OR"et le caractère" , tous deux imprimés implicitement.

Dans Fission, le flux du programme commence à la Ravec un atome de droite. '"modifie simplement la masse des atomes ), 5et -sont ignorés pour diverses raisons. Ensuite, l'atome passe en mode d'impression sur "et s'imprime {'_'~}_~. ;détruit l'atome et termine le programme.

Clojure / Common Lisp, 274 octets

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

Quelques espaces ajoutés pour plus de lisibilité

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

Définit fondamentalement une macro qui renvoie une quine dans Clojure. Clojure nécessite des paramètres pour la définition de macro fournis en tant que vecteur ( []) tandis que Common Lisp (heureusement) l'ignore. Après cela, nous différons 2 langues en évaluant '()ce qui est égal nilet donc falsey en Common Lisp et est trueen Clojure. Ensuite, nous faisons des manipulations de chaînes en utilisant Clojure que Common Lisp n'essaie même pas d'évaluer comme il va dans une autre ifbranche. Clojure d'autre part essaie de vérifier si une autre branche est au moins correcte avant de s'exécuter donc a dû utilisereval à la fois pour être correct dans Clojure et pour sortir la chaîne correcte en Common Lisp.

Remarque: le simple retour de deux chaînes différentes peut probablement être plus court, mais il ne sera pas différent d'un défi polyglotte concernant la sortie de différentes chaînes dans différentes langues. ¯ \ _ (ツ) _ / ¯

Exécution de la source d'origine Clojure: https://ideone.com/SiQhPf

Exécution source commune Common Lisp: https://ideone.com/huLcty

Sortie de fermeture: ((LAMBDA (S) (PRINT (LIST S (LIST 'QUOTE S)))) '(LAMBDA (S) (PRINT (LIST S (LIST 'QUOTE S)))))

Sortie Lisp commune: ((fn [s] (print (list s (list (quote quote) s)))) (quote (fn [s] (print (list s (list (quote quote) s))))))

Sortie de Clojure exécutée en Common Lisp: https://ideone.com/T1DF7H

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

Jelly / GolfScript, 18 16 octets

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

Vérification

Le test de tous les programmes impliqués avec les flux d'octets exacts ne peut être effectué que localement.

$ 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ée

Avec la page de codes de Jelly , le programme se présente comme suit.

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

Ceci imprime ( Essayez-le en ligne! )

":n`":n`

qui est une quine dans GolfScript ( Essayez-le en ligne! ), mais une erreur d'analyse dans Jelly ( Essayez-le en ligne! ).

GolfScript

En Latin-1, le programme se présente comme suit, avec un caractère DEL non imprimable entre }et þ.

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

Ceci imprime ( Essayez-le en ligne! )

ÿÌÌ

ou, visualisé avec la page de codes de Jelly,

”ṘṘ

qui est une quine dans Jelly ( Essayez-le en ligne! ), mais imprime uniquement un saut de ligne dans GolfScript ( Essayez-le en ligne! ).

JavaScript / C 278 octets

À un nombre stupéfiant de 278 octets:

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

Le C quine:

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

Le 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 octets

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

Essayez-le à Befunge | Essayez-le à Fission

Dans Befunge, cela produit le quine de fission :

'!+OR"

Dans Fission, cela produit la quine Befunge :

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

Python / Retina, 70 65 64 66 octets

J'ai utilisé la même stratégie que celle utilisée dans mon précédent polyglotte Python / Retina .

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

Essayez en Python | Essayez dans la rétine

#est un commentaire en Python, il imprime donc simplement le quine Retina en Python. Dans Retina, le premier étage (2 lignes) ne fait rien, car aucun #ne sera trouvé dans l'entrée. L'étape suivante ne remplace rien par la base du quine Python. La troisième étape remplace chaque point-virgule par la #print _%pièce. La dernière étape supprime tout #.

Quine in Retina:

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

Quine en Python:

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

Les quines utilisées peuvent être vues dans ce défi . Le quine Retina est une erreur en Python, et le quine Python n'a pas de sortie dans Retina.

Python 3 / Python 2, 62 octets

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

Essayez-le en Python 2 , Python 3 .

Basé sur le quine Python ici . Le facteur de distinction entre les deux versions est ce qu'elles font avec int(-1/2): en Python 2, /est la division entière (arrondie vers le bas), avec un résultat de -1; en Python 3, /est la division en virgule flottante ( -0.5), qui inttronque à 0.

Nous construisons une chaîne _en trois parties. '_=%r;print(_%%_['et 'int(-1/2):])'sont toujours les mêmes. La partie intéressante est '~'*-~int(-1/2):

• En Python 2, -~int(-1/2)is 0et le tilde ne sont pas ajoutés à la chaîne;
• En Python 3, -~int(-1/2)is 1et le tilde sont ajoutés à la chaîne.

Ainsi, Python 2 génère le quine Python 3

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

et Python 3 génère le quine Python 2

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

Dans chaque version, l'expression à l'intérieur est [ :]évaluée à 0, ce qui fait que la tranche inclut la chaîne entière, tandis que dans la mauvaise langue, elle est évaluée à -1, ce qui fait que la tranche n'inclut que le dernier caractère, tronquant la sortie, ce n'est donc pas un quine complet.

Brain-Flak , brainfuck 4617 4009 octets

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

Essayez-le en ligne!

Essayez-le en ligne!

L'explication est en route, je joue encore au golf