Une métaquine est un programme qui n'est pas une quine, mais dont la sortie, lorsqu'elle est exécutée en tant que programme dans la même langue, est une quine.

Le but de ce défi est d'écrire une métaquine. C'est le code-golf , donc le code le plus court gagne, avec la première réponse utilisée comme bris d'égalité. Notez que seuls les programmes complets sont acceptables, en raison de la définition d'une quine.

Règles pour les quines

Seuls les vrais quines sont acceptés. Autrement dit, vous devez imprimer l'intégralité du code source textuellement dans STDOUT, sans :

• lire votre code source, directement ou indirectement.
• en s'appuyant sur un environnement REPL qui évalue et imprime simplement chaque expression que vous lui donnez.
• en s'appuyant sur des fonctionnalités linguistiques qui ne font qu'imprimer la source dans certains cas.
• en utilisant des messages d'erreur ou STDERR pour écrire tout ou partie du quine. (Vous pouvez écrire des choses dans STDERR ou produire des avertissements / erreurs non fatales tant que STDOUT est un quine valide et que les messages d'erreur n'en font pas partie.)
• le code source composé uniquement de littéraux (qu'il s'agisse de littéraux de chaîne, de littéraux numériques, etc.) et / ou de NOP.

Toute sortie non supprimable (comme les avis de droits d'auteur, les messages de démarrage / arrêt ou un saut de ligne de fin) peut être ignorée dans la sortie pour des raisons de validité du quine.

Exemple

Ignorer la règle qui interdit les programmes uniquement littéraux et le quining intégré, ce serait une métaquine dans Sérieusement:

"Q"

Le programme se compose du littéral de chaîne unique "Q", qui est implicitement imprimé en sortie. Lorsque la sortie ( Q) est exécutée, il s'agit d'une quine ( Qc'est la fonction de quine intégrée).

CJam, 6 octets

"_p"_p

Impressions

"_p"
_p

qui est la quine appropriée la plus courte dans CJam.

Testez-le ici.

Explication

Les deux programmes fonctionnent exactement de la même manière, car le saut de ligne à l'intérieur du quine approprié est un no-op et n'est inclus que parce qu'il est plus coûteux de le supprimer de la sortie. Fonctionnement des programmes:

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

Note latérale

La même chose fonctionne dans GolfScript que

".p".p

qui imprime

".p"
.p

avec un saut de ligne arrière, qui est à son tour l'un des quines connus les plus courts.

Pyth, 12 11 10 9 octets

Supprimé un octet de plus grâce à @ Pietu1998.

jN B".[9N

Ceci imprime

.[9N".[9N

qui est une quine en Pyth. Vous pouvez l'essayer ici .

Fission , 6 octets

!+OR"'

Impressions

'!+OR"

Quel est le quine de fission le plus court . Cela fonctionne parce que les changements cycliques du programme ne modifient pas sa sortie.

Essayez-le en ligne!

Javascript ES6, 21 octets

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

Banal.

Python 2, 29 octets

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

Il s'avère que le quine court en python bien connu est facilement transformé en métaquine :)

Et, puisque nous n'avons pas à nous soucier de faire correspondre la nouvelle ligne de fin, la métaquine est en fait plus courte!

Japt, 15 13 octets

Q+"+Q ³s7J" ²

Testez-le en ligne!

Ce programme produit

"+Q ³s7J"+Q ³s7J

qui est le quine le plus court connu de Japt.

Comment ça fonctionne

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

Version non concurrente, 11 octets

Q+"+Q ²é" ²

Je viens d'ajouter é une commande "rotation". Donc

"+Q ²é"+Q ²é

est maintenant un quine valide.

Rubis, 25 23

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

Génère la quine classique Ruby HEREdoc

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

Ancienne solution

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

Se génère lui-même sauf avec les guillemets simples remplacés par des guillemets doubles.

JavaScript, 50 octets

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

Basé sur le quine JS sans lecture de source le plus court connu de l'homme , mais 8 octets plus court. Impressions

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

ce qui est une quine.

Poisson (> <>), 17 octets

Cela fonctionne en utilisant la quine de poisson classique "r00g!;oooooooo|mais ajoute un {qui décale toute la pile vers la gauche afin que le programme d'origine ne soit pas une quine, mais sa sortie, lorsqu'elle est exécutée, l'est.

"{r00g!;oooooooo|

Les sorties:

"r00g!;oooooooo|

qui est une quine de poisson!

Gelée , 3 octets (non concurrent)

Malheureusement, les atomes requis sont environ 2 semaines plus jeunes que le défi.

Métaquine

”Ṙv

Essayez-le en ligne!

Comment ça fonctionne

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

”ṘṘ

Essayez-le en ligne!

Comment ça fonctionne

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

Puisque le second Ṙimprime les deux premiers caractères ( ”Ṙ), c'est une quine appropriée par notre définition.

Octopen-Baru, 22 octets

** Réponse non concurrente

愛[35211].pack歩U')

Sortie Ruby

puts [35211].pack(' U')

Quelles sorties 見. Ce qui est une quine à Octopen-Baru!

7 , 2 octets, défi de postdates de langue

Le programme est long de deux octets et peut être interprété de plusieurs manières; sous forme de vidage hexadécimal:

00000000: 4ff4                                     O.

comme page de code 437:

O⌠

ou, de façon plus lisible, en octal (que 7 utilisent nativement):

237723

Essayez-le en ligne!

Le fonctionnement est très simple: c'est la quine standard 7 avec un élément de pile sans opération inséré entre les deux moitiés, pour le rendre différent (dans ce contexte, 7sépare les éléments de pile). (J'aurais également pu l'insérer au début 723723. Je n'aurais pas pu l'interpréter à la fin parce que les 7 de fin sont comme des espaces de fin et ignorés dans l'encodage compressé, donc il ne serait pas différent du programme de sortie. )

Soit dit en passant, ce programme est un palindrome en hexadécimal, mais c'est surtout une coïncidence.

Sous-charge, 11 octets

(:aSS)::aSS

Assez simple. Il s'imprime (:aSS):aSS, qui est le quine standard de sous-charge.

Brachylog , 12 octets

"~k;?w₁"gjw₃

Essayez-le en ligne!

L'une des 132 variations de métaquine de même longueur sur la quine I traduit de la quine Brachylog v1 (sans tricher) de Fatalize. J'ai en fait écrit un programme (non-golfé et globalement idiot) pour les imprimer tous:

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

Essayez-le en ligne!

Il y a deux parties de la Quine originale qui pourrait être remplacé inconséquente: ;?peut être changée en gjou jḍ, et ₁peuvent être modifiés à ₃, ₅ou ₇. Si nous les conservons ou les modifions en dehors du littéral de chaîne d'une manière et à l'intérieur du littéral de chaîne d'une manière différente, la sortie ne correspondra pas à la source, car les variantes présentes dans le littéral de chaîne seront imprimées à l'intérieur et à l'extérieur de celui-ci. , résultant en un quine qui n'était pas le programme initial exécuté.

;?, gjEt jḍsont interchangeables , car les trois paires de la chaîne littérale avec elle - même: en raison de la mise en page du programme, la variable d'entrée ?est unifié avec la chaîne, de sorte que les ;?paires avec la chaîne elle - même; quelle que soit la disposition, gjencapsule la chaîne dans une liste qui est ensuite concaténée à elle-même; jḍconcatène également la chaîne à elle-même, puis la divise en deux.

Les windices impairs sont interchangeables car, même si à l'origine wils ne pouvaient prendre que 0 ou 1, avec 0 imprimant l'entrée vers wet 1 imprimant le premier élément formaté avec le second, l'inventaire des indices pour west devenu quelque chose qui fonctionne extérieurement comme un champ binaire: le bit inférieur de l'indice code s'il est direct ou formaté, le bit du milieu code si la variable de sortie dewn'est pas contraint ou défini sur l'entrée, et le bit élevé code si l'impression est effectuée immédiatement ou si elle est retardée jusqu'à la fin du programme afin qu'elle puisse faire l'objet d'un retour arrière. (Ces indices étaient ma première et jusqu'à présent la plus grande contribution à Brachylog.) Étant donné que la quine et la métaquine n'utilisent pas la variable de sortie et ne reviennent pas en arrière, les quatre indices impairs sont équivalents.

Befunge-93, 22 octets

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

Je viens de prendre le quine standard, de le mettre entre guillemets, de l'inverser (afin qu'il soit correctement chargé sur la pile), puis d'ajouter une impression de pile à la fin.

C'est 8 caractères ajoutés au quine normal, il est donc très possible qu'il y ait une meilleure solution.

Turtlèd , 52 octets (non concurrentiel)

1 de moins que le quine d'origine

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

Fonctionne de la même manière, sauf qu'il n'a pas de caractère à la fin, lors de l'exécution, il aura un caractère à la fin, qui n'affecte pas la sortie, car il écrit # sur un #. Notez que la sortie est légèrement différente de la quine que j'ai faite pour le défi de quine, mais fonctionne de la même manière: "écrit #, qui est son propre dernier caractère, comme la quine que j'ai faite. Consultez l'explication ici .

Lua, 45 octets

Quine code not mine.

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

aura pour résultat

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

ce qui est une quine. Heureux que ce ;soit facultatif à Lua.

Pushy , 7 octets

Non compétitif car la langue est postérieure au défi.

C'est le quine standard, mais avec les sauts de ligne supprimés. Les nouvelles lignes ne signifient rien dans Pushy, mais sont le séparateur standard de l'opérateur d'impression, et sont donc nécessaires pour une véritable quine.

95 34_"

Essayez-le en ligne! Cela produit:

95 34
_ "

Quelle est la quine la plus courte de Pushy - une explication sur comment cela fonctionne peut être trouvée ici .

Alternativement, H5-34_"fonctionne pour le même nombre d'octets.

Mousse , 14 octets

[. .'|: ~|]: ~

Ceci imprime la deuxième quine de mousse qui peut être trouvée ici . C'est en fait plus court car il y .aura toujours un espace entre chaque élément, mais la barre du troisième jeton me permet d'omettre l'espace avant celui-ci.

Husk , 6 octets

D"S+s¨

Essayez-le en ligne!

Imprime le quine Husk standard S+s"S+s".

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

Le quine a expliqué:

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