Dans cette question, je vous ai demandé de deviner une quine d'anagramme en fonction de sa sortie. Cependant, il semble que nous n'ayons pas encore de question demandant de jouer au golf une quine d'anagramme. Votre tâche consistera donc à créer la plus courte anagramme possible.

Qu'est-ce qu'une anagramme quine?

Une anagramme quine est un programme non vide qui imprime une anagramme de son code source, autre que sa source d'origine.

Voici un exemple de séquence d'anagrammes en Python 2:

print`'`print`*2'*2`

Vous ne devez pas lire votre propre source pour ce défi.

Pyth , 2 octets

)(

Les sorties

()

Essayez-le en ligne!

)  # Ends statement, does nothing in this program
 ( # Create an empty tuple
   # Implicitly print the empty tuple

V , 4 octets

2ii2

Les sorties:

i2i2

Essayez-le en ligne!

> <> , 9 8 7 octets

Golfé 1 octet grâce à @WheatWizard en l'utilisant !et en l'incrémentant pour obtenir"

Golfé 1 octet grâce à @ ConorO'Brien en utilisant #au lieu de<!

":1->o#

Essayez-le en ligne!

Sorties "#o>-1:.

Explication

":1->o#"        Push this string (note that the IP wraps around)
:               Duplicate the top value of the stack (35 from the "#")
1-              Subtract one from it to get 34 ('"')
>o#             Print every character on the stack until the program cannot pop any more and still tries to pop a value from the stack afterwards
                The program exits with an error from not being able to pop a value from an empty stack

Brainfuck, 158 octets

>>--<<-[[<+>->+>->+++<<<]>-]<<<<<<[--->>.<<]>>++<<<[->>>.<<<]>>-<<<[--->>>.<<<]>>>--<<<<[++>>>>.<<<<]>>>>+++>--.[---<.>]>+.......++.......<<<>>>>>>>>>-----+++

Essayez-le en ligne!

Ce n'est peut-être pas la version la plus courte, mais au moins cela fonctionne.

Fait amusant , le code de sortie peut en fait être exécuté (et il se termine).

Sortie

<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>--------------------------++++++++++++++++++<....................[[[[[[[]]]]]]]

Explication

>>--<<-[[<+>->+>->+++<<<]>-]    Initializes the tape with the
                                help of a recurrence relation.
<<<<<<[--->>.<<]>>++<<<[->>>
.<<<]>>-<<<[--->>>.<<<]>>>--    Prints the characters using
<<<<[++>>>>.<<<<]>>>>+++>--.    classic loops.
[---<.>]>+.......++.......

<<<>>>>>>>>>-----+++            Junk to complete the anagram.

Python 3, 32 octets

print ("" "p" r "i" n "t" 2 (") *" "" * 2)

Impressions p"r"i"n"t"2(")*p"r"i"n"t"2(")*\n, sortie triée:\n""""""""""""(())**22iinnpprrtt

Ruby , 8 octets

p"p*2"*2

Essayez-le en ligne!

Cela imprime

"p*2p*2"

Explication

Cela fonctionne de manière similaire à la réponse python de la question. Il va faire la chaîne p*2p*2puis en utilisant Ruby paffichera la représentation de la chaîne.

JavaScript (ES6), 40 32 octets

f=($=`($)=>{$=$+"${"``"}$"}`)=>$+$

Pas besoin de jouer avec Function.toString non plus. En prime, le code à l'intérieur de la chaîne semble presque légal. Modifier: 8 octets enregistrés en utilisant +au lieu de repeat(2).

Klein , 7 + 6 = 13 octets

Voici une réponse basée sur le réponse> <> .

":1+@!

Essayez-le en ligne!

Cette sorties

:1+@!"

Japt , 10 9 octets

J'ai trouvé un meilleur moyen :-)

Q+2ç"Q+2ç

Sorties "Q+2çQ+2ç.Testez-le en ligne!

Explication

Q+2ç"Q+2ç    // Implicit: Q = quotation mark
    "Q+2ç    // Take this string.     Q+2ç
  2ç         // Repeat it twice.      Q+2çQ+2ç
Q+           // Prepend a quote.      "Q+2çQ+2ç
             // Implicit: output result of last expression

Pourrait aussi être Qi2ç"Qi2ç, qui imprime Qi2çQi2ç". Celui-ci est plus proche du quine Japt standard:

"iQ ²"iQ ²

Mais je ne crois pas qu'il existe un moyen facile de caler le guillemet au milieu de la chaîne pour un quine de 9 octets.

Rubis, 20 octets

$><<%q($><<%q()*2)*2

Cette sorties

$><<%q()*2$><<%q()*2

Profitant de la %q(...)syntaxe de chaîne de Ruby , qui prend en charge les parenthèses imbriquées.

Rétine , 8 octets

_

$nn$

Essayez-le en ligne!

Impressions

n$_
n$

Les deux contiennent un _, deux n, deux $et trois sauts de ligne.

Notez qu'un saut de ligne suivi de presque n'importe quel autre caractère est une solution triviale, mais il est douteux qu'il soit valide, car le deuxième caractère ne s'encode que lui-même et le saut de ligne n'encode vraiment aucun des deux caractères de sortie.

Explication

_

Remplacez l'entrée vide par un _.

$nn$

Correspond à une chaîne vide, qui se produit avant ou après le _et insérez un saut de ligne ( $n), un net un $. Depuis que nous avons inséré cela pour la première fois _, cela ajoute deux fois chacun de ces caractères, de sorte que le net prend en $compte le $n, et nous obtenons deux des trois sauts de ligne dont nous avons besoin dans la sortie. Le troisième saut de ligne est imprimé car Retina imprime un saut de ligne de fin par défaut.

Nous pourrions également utiliser n$n$à cette étape, qui imprimerait alors:

n
$_n
$

Python Repl, 4 octets

Ceci est ma première solution Code Golf, donc j'espère qu'elle répond aux règles. Dans l'interpréteur interactif Python 2 ou 3:

>>> (1),
(1,)

La sortie est une anagramme de l'entrée.

Un autre:

>>> 2*'2*'
'2*2*'

En Python 2:

>>> type('rst <>'),
(<type 'str'>,)

En Python 3:

>> {1, 0}
{0, 1}

Mise à jour 2017-06-15: Encore une autre:

>>> 01.
1.0

Haskell , 38 39 octets

main=print$[0,0]>>"main=print$[0,0]>>"

Essayez-le en ligne! Sortie:

"main=print$[0,0]>>main=print$[0,0]>>"

Edit: +1 octet parce que j'avais déjà oublié le retour à la ligne implicite de print.

Alternative: (Même nombre d'octets mais ne contient pas de chouette ASCII)

main=print$e++e;e="main=print$e++e;e="

Essayez-le en ligne!

Sortie:

"main=print$e++e;e=main=print$e++e;e="

Groovy, 24 20 octets

{"""{""*""2""}"""*2}

-4 grâce à CalculatorFeline, l'espace blanc n'était pas nécessaire après tout!

Sortie:

{""*""2""}{""*""2""}

Explication:

Fermeture anonyme qui, lorsqu'elle est appelée, revient {""*""2""}deux fois (concaténée).

05AB1E , 10 octets

'∞∞''∞'JJ∞

Essayez-le en ligne!

Sortie:

∞∞''JJ''∞∞

Explication:

Code       | Explanation                | Stack
-----------+----------------------------+-------------------
'∞         | Push literal '∞'.          | ["∞"]
  ∞        | Mirror.                    | ["∞∞"]
   ''      | Push literal "'".          | ["∞∞","'"]
     ∞     | Mirror.                    | ["∞∞","''"]
      'J   | Push literal 'J'.          | ["∞∞","''","J"]
        J  | Join it all together.      | ["∞∞''J"]
         ∞ | Mirror.                    | ["∞∞''JJ''∞∞"]
-----------+----------------------------+-------------------
           | Implicit print.            | ∞∞''JJ''∞∞

CJam , 6 octets

"_`"_`

Essayez-le en ligne!

Impressions

_`"_`"

Explication

"_`"   e# Push this string.
_      e# Duplicate.
`      e# Stringify it, which wraps it in quotes.
       e# Implicitly print stack contents.

Bash, 36 octets

tee f<<<'tee f<<<""cat f'"''"
cat f

Cette sorties

tee f<<<""cat f''
tee f<<<""cat f''

(et crée le fichier fcomme effet secondaire, mais cela est autorisé par méta .)

Le programme et la sortie ont une nouvelle ligne de fin.

Processus de réflexion: je me suis dit que la façon la plus simple de produire une chaîne deux fois, en plus de l'attribuer à une variable, était de faire

tee f<<<string
cat f

La chaîne doit être citée car elle contiendra des espaces et des <caractères, donc j'ai eu

tee f<<<'tee f<<<cat f'
cat f

qui fonctionne presque, sauf qu'il ne produit pas les guillemets. Heureusement, Bash prend en charge la concaténation littérale des chaînes en les plaçant simplement les unes à côté des autres, donc l'ajout "''"à l'héritage et l'insertion ""à l'intérieur de la partie de guillemet simple donne cette solution.

PHP , 44 octets

<?=str_repeat('<?=\str_\repeat(\'\',2);',2);

Essayez-le en ligne!

CJam , 8 octets

"2*`"2*`

Essayez-le en ligne!

Explication

Similaire à l'exemple Python de la question

"2*`"     e# Push the string "2*`"
     2*   e# Repeat it twice
       `  e# Get its string representation (wrap in quotes)

La sortie est "2*`2*`".

Befunge, 11 octets

' 2+">:#,_@

Tirages:

+2 '@_,#:>"

Explication:

' 2+"        Put a " on the stack (32 + 2)
    "        Put the rest of the code on stack (wrap-around string)
     >:#,_   Print stack
          @  End

QBIC , 8 octets

?A+@?A@+

Je viens de découvrir comment faire une quine appropriée dans QBIC. Pour en faire une anagramme, il suffit de changer les caractères du littéral de chaîne. Il y a 24 anagrammes possibles de cette façon.

Befunge-98 , 8 octets

"'$<@,k7

Essayez-le en ligne!

Ohm , 14 octets

"æ3M.Cæ"æ3M."C

Essayez-le en ligne!

Sortie:

æ3M.CæC.M3æ"""

Explication

"æ3M.Cæ"æ3M."C
"æ3M.Cæ"       # Pushes "æ3M.Cæ"
        æ      # Palindrone of that string
         3M    # 3 times...
           ."   # Push " on the stack
             C  # Concatenate with the string above

JavaScript (ES6), 15 octets

f=(s='f=')=>f+s

Les sorties:

(s='f=')=>f+sf= 

Fragment:

f=(s='f=')=>f+s

console.log(f());

Fission 2 , 9 8 6 octets

R"'!+O

Essayez-le en ligne!

Explication

Un atome est créé à R, qui se déplace vers la droite. Cet atome rencontre alors un ", qui démarre le mode d'impression. En mode d'impression, tous les caractères (jusqu'à la correspondance ") sont imprimés. Cela signifie qu'il imprime '!+ORdans ce cas. Ensuite, tout ce qui reste est l'impression ", ce qui est fait par les caractères restants. '!définit la masse de l'atome sur le code de caractère de !et l' +incrémente sur le code de caractère de ". Ensuite, le code de caractère est sorti par Oet l'atome est détruit, mettant fin au programme.

(En fait, ce n'est qu'une rotation du quine le plus court)

Mathematica, 2 octets

.0

Sortie:

0.

Un nombre commençant par un point décimal tel que .123est interprété comme 0.123, .0est donc interprété comme 0.0. Étant donné que la partie du nombre après la virgule décimale est zéro, Mathematica ne l'imprime pas.

JavaScript (encore un autre), 11 octets

f=_=>'=f'+f

Appelé avec f(), sorties

=f_=>'=f'+f

f=_=>'=f'+f

console.log(f());

Python 3, 31 octets

a='a=%r;pritn(a%%a)';print(a%a)

Stax , 8 4 octets

.S.S

Exécutez et déboguez en ligne!

Un port direct de cette réponse .

Ancienne version, 8 octets

..b..LbL

Exécutez et déboguez en ligne!

Version alternative avec une astuce assez bon marché qui peut être appliquée aux quines appropriées dans presque toutes les langues.

"43bL"34bL

Exécutez et déboguez en ligne!

Car "34bL"34bL c'est un quine approprié à Stax.

Encore une autre version, utilisant uniquement des littéraux de chaîne à caractère unique.

''c'Lc'cccLcLL

Exécutez et déboguez en ligne!

Explication

.S.S        Generates powerset ["","S","S.","."]
            Implicit flatten and output

..b         Push string ".b"
   ..L      Push string ".L"
      b     Duplicate both strings
       L    Concatenate all 4 strings to a single one.

05AB1E , 13 octets

"34çJ∞"34çJ∞

Les sorties:

34çJ∞""∞Jç43

Essayez-le en ligne!

"34çJ∞"      # Push this string                 | [ 34çJ∞ ]
       34ç   # Push a quote (")                 | [ 34çJ∞, " ]
          J  # Join                             | [ 34çJ∞" ]
           ∞ # Mirror                           | [ 34çJ∞""∞Jç43 ]
             # Implicitly output with a newline