Le quine méta-polyglotte

18

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 , 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!

Pavel
la source
1
Un quine est fondamentalement un méta-méta-méta-méta-méta-méta-méta-etc. programme
quand même
Comment compter les octets si les deux langues utilisent des encodages de caractères différents? Vous devriez probablement marquer en caractères plutôt qu'en octets
Luis Mendo
1
Si j'exécute le quine en langue A pour générer un quine pour la langue B, cela devrait-il être exécutable en A?
corvus_192
2
@LuisMendo Lorsque j'écris un polyglotte pour des langues avec des encodages différents, je suppose qu'ils reçoivent tous les deux le même flux d'octets (pas des encodages différents des mêmes caractères).
Martin Ender
1
@ Pavel J'ai écrit un défi similaire ici , mais il a été fermé en double.
Oliver Ni

Réponses:

5

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.

Dennis
la source
Juste curieux, au sens large, quelle est la différence entre CJam et GolfScript, et pourquoi votre code fonctionne-t-il?
Pavel
CJam a été fortement inspiré par GolfScript et est principalement rétrocompatible. Une grande différence est que GolfScript, par défaut, ajoute un saut de ligne à la sortie, contrairement à CJam, ce que j'exploite ici. J'ajouterai une explication détaillée dès que possible.
Dennis
1
"0$p"0$~a:n;.
jimmy23013
@ jimmy23013 Nice, merci! J'avais joué avec a:n, mais l'utilisation pne m'est pas venue à l'esprit.
Dennis
8

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.

Martin Ender
la source
4
+1 pour l'émoticône{'_'~}
betseg
5
détruit l'atome Je préfère ne pas être près de moi quand cela se produit
Luis Mendo
6

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

cliffroot
la source
4

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! ).

Dennis
la source
1
Bon vieux ”ṘṘ, donc ØVdevrait être parti, non?
Erik the Outgolfer
3

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


la source
Sainte mère des quines ...
MD XF
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.

mbomb007
la source
Pouvez-vous ajouter une explication à votre réponse sur le fonctionnement de la métaquine?
Pavel
@ Pavel l'a ajouté.
mbomb007
1

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.

DLosc
la source
1

Brain-Flak , brainfuck 4617 4009 octets

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

Essayez-le en ligne!

Essayez-le en ligne!

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

Post Rock Garf Hunter
la source
Cela génère une quine brainfuck dans brainfuck, et une quine Brain-Flak dans Brain-Flak. Il devrait générer un quine brainfuck lorsqu'il est exécuté dans Brain-Flak et un quine Brain-Flak lorsqu'il est exécuté dans brainfuck.
Pavel
Je vais le refaire. Je suis désolé d'avoir du mal à suivre les As et Bs
Post Rock Garf Hunter