En esta pregunta, le pedí que adivinara un anagrama quine basado en su salida. Sin embargo, parece que todavía no tenemos una pregunta sobre golf para un anagrama quine. Por lo tanto, su tarea será hacer la anagrama de anagrama más corta que pueda.

¿Qué es un anagrama quine?

Un anagrama quine es un programa no vacío que imprime un anagrama de su código fuente, que no sea su fuente original.

Aquí hay un ejemplo de una anagrama quine en Python 2:

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

No deberías leer tu propia fuente para este desafío.

Pyth , 2 bytes

)(

Salidas

()

Pruébalo en línea!

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

V , 4 bytes

2ii2

Salidas:

i2i2

Pruébalo en línea!

> <> , 9 8 7 bytes

Golfé 1 byte gracias a @WheatWizard al usarlo !e incrementarlo para obtener"

Golfé 1 byte gracias a @ ConorO'Brien usando en #lugar de<!

":1->o#

Pruébalo en línea!

Salidas "#o>-1:.

Explicación

":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 bytes

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

Pruébalo en línea!

Puede que no sea la versión más corta, pero al menos funciona.

Dato curioso , el código de salida puede ejecutarse (y termina).

Salida

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

Explicación

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

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

Python 3, 32 bytes

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

Impresiones p"r"i"n"t"2(")*p"r"i"n"t"2(")*\n, salida ordenada:\n""""""""""""(())**22iinnpprrtt

Rubí , 8 bytes.

p"p*2"*2

Pruébalo en línea!

Esto imprime

"p*2p*2"

Explicación

Esto funciona de manera similar a la respuesta de Python en la pregunta. Hará la cadena y p*2p*2luego usar Ruby pimprimirá la representación de la cadena.

JavaScript (ES6), 40 32 bytes

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

Sin perder el tiempo con Function.toString tampoco. Como beneficio adicional, el código dentro de la cadena casi parece legal. Editar: guardado 8 bytes usando en +lugar de repeat(2).

Klein , 7 + 6 = 13 bytes

Aquí hay una respuesta basada en la respuesta> <> .

":1+@!

Pruébalo en línea!

Esto salidas

:1+@!"

Japt , 10 9 bytes

Encontré una mejor manera :-)

Q+2ç"Q+2ç

Salidas "Q+2çQ+2ç. ¡Pruébelo en línea!

Explicación

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

También podría ser Qi2ç"Qi2ç, que imprime Qi2çQi2ç". Este está más cerca del estándar Japt quine:

"iQ ²"iQ ²

Pero no creo que haya una forma fácil de poner las comillas en el medio de la cadena para una quine de 9 bytes.

Rubí, 20 bytes.

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

Esto salidas

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

Aprovechando la %q(...)sintaxis de cadenas de Ruby , que admite paréntesis anidados.

Retina , 8 bytes

_

$nn$

Pruébalo en línea!

Huellas dactilares

n$_
n$

Ambos contienen uno _, dosn , dos$ y tres avances de línea.

Tenga en cuenta que un avance de línea seguido de casi cualquier otro carácter es una solución trivial, pero es cuestionable si es válido, porque el segundo carácter solo se codifica a sí mismo y el avance de línea realmente no codifica ninguno de los caracteres de salida.

Explicación

_

Reemplace la entrada vacía con a _.

$nn$

_Haga coincidir una cadena vacía, que ocurre antes o después de e inserte un salto de línea ( $n), an ny a $. Como nos inserta en primer lugar que _, esto se suma a cada uno de esos personajes en dos ocasiones, por lo que el ny $cuenta para el$n , y obtenemos dos de los tres avances de línea que necesitamos en la salida. El tercer avance de línea se imprime porque Retina imprime un avance de línea final de forma predeterminada.

También podríamos usar n$n$en esta etapa, que luego imprimiría:

n
$_n
$

Python Repl, 4 bytes

Esta es mi primera solución de Code Golf, así que espero que cumpla con las reglas. En el intérprete interactivo Python 2 o 3:

>>> (1),
(1,)

La salida es un anagrama de la entrada.

Otro:

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

En Python 2:

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

En Python 3:

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

Actualización 2017-06-15: Otro más:

>>> 01.
1.0

Haskell , 38 39 bytes

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

Pruébalo en línea! Salida:

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

Editar: +1 byte porque anteriormente olvidé la nueva línea implícita de print.

Alternativa: (Mismo recuento de bytes pero no contiene ASCII-owl)

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

Pruébalo en línea!

Salida:

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

Groovy, 24 20 bytes

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

-4 gracias a CalculatorFeline, ¡el espacio en blanco no era necesario después de todo!

Salida:

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

Explicación:

Cierre anónimo que, cuando se llama, vuelve {""*""2""}dos veces (concatenado).

05AB1E , 10 bytes

'∞∞''∞'JJ∞

Pruébalo en línea!

Salida:

∞∞''JJ''∞∞

Explicación:

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 bytes

"_`"_`

Pruébalo en línea!

Huellas dactilares

_`"_`"

Explicación

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

Bash, 36 bytes

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

Esto salidas

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

(y crea el archivo fcomo un efecto secundario, pero eso está permitido por meta ).

Tanto el programa como la salida tienen una nueva línea final.

Proceso de reflexión: pensé que la forma más fácil de generar una cadena dos veces, aparte de asignarla a una variable, era hacer

tee f<<<string
cat f

La cadena necesita ser citada porque contendrá espacios y <caracteres, así que tuve

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

que casi funciona, excepto que no genera las comillas. Afortunadamente, Bash admite la concatenación literal de cadenas simplemente colocándolas una al lado de la otra, por lo "''"que al agregar a la herejía e insertar ""dentro de la parte de comillas simples se obtiene esta solución.

PHP , 44 bytes

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

Pruébalo en línea!

CJam , 8 bytes

"2*`"2*`

Pruébalo en línea!

Explicación

Similar al ejemplo de Python en la pregunta

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

La salida es "2*`2*`".

Befunge, 11 bytes

' 2+">:#,_@

Huellas dactilares:

+2 '@_,#:>"

Explicación:

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

QBIC , 8 bytes

?A+@?A@+

Me acabo de dar cuenta cómo hacer un quine adecuada en QBIC. Para hacer un anagrama, simplemente cambie los caracteres en el literal de cadena. Hay 24 anagramas posibles de esta manera.

Befunge-98 , 8 bytes

"'$<@,k7

Pruébalo en línea!

Ohmios , 14 bytes

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

Pruébalo en línea!

Salida:

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

Explicación

"æ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 bytes

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

Salidas:

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

Retazo:

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

console.log(f());

Fisión 2 , 9 8 6 bytes

R"'!+O

Pruébalo en línea!

Explicación

Se crea un átomo en R, que se mueve hacia la derecha. Este átomo se encuentra con un ", que comienza el modo de impresión. En el modo de impresión, se imprimen todos los caracteres (hasta la coincidencia "). Esto significa que se imprime '!+ORen este caso. Luego, todo lo que queda es imprimir ", lo que se hace con los caracteres restantes. '!establece la masa del átomo al código de caracteres de !, y+ incrementa al código de caracteres de" . Entonces, el código de caracteres es emitido porO y se destruye el átomo, finalizando el programa.

(En realidad, esto es solo una rotación de la quine más corta)

Mathematica, 2 bytes

.0

Salida:

0.

Un número que comienza con un punto decimal como .123se interpreta como 0.123, por lo que .0se interpreta como 0.0. Como la parte del número después del punto decimal es cero, Mathematica no lo imprime.

JavaScript (otro más), 11 bytes

f=_=>'=f'+f

Llamado con f()salidas

=f_=>'=f'+f

f=_=>'=f'+f

console.log(f());

Python 3, 31 bytes

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

Stax , 8 4 bytes

.S.S

¡Ejecute y depure en línea!

Un puerto directo de esta respuesta .

Versión anterior, 8 bytes

..b..LbL

¡Ejecute y depure en línea!

Versión alternativa con un truco bastante barato que se puede aplicar a quines adecuados en casi cualquier idioma.

"43bL"34bL

¡Ejecute y depure en línea!

Porque "34bL"34bL es una quine adecuada en Stax.

Otra versión más, que usa solo literales de cadena de un solo carácter.

''c'Lc'cccLcLL

¡Ejecute y depure en línea!

Explicación

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

"34çJ∞"34çJ∞

Salidas:

34çJ∞""∞Jç43

Pruébalo en línea!

"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