Golf un anagrama Quine

24

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.

Asistente de trigo
fuente
2
@LeakyNun No, no puede ser una quine.
Wheat Wizard
2
¿El código de salida tiene que ser un programa válido?
MD XF
1
@MDXF No, no lo hace.
Wheat Wizard
2
@Okx Debe seguir nuestros requisitos estándar para una quine (aparte de ser una quine).
Wheat Wizard
1
@LeakyNun Eso sí, ¡tampoco creo que los programas de 0 bytes tengan anagramas que difieran del original!
Neil

Respuestas:

29

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
Barra
fuente
3
¿Eso significa que descubriste que ()es un quine mucho más corto que el conocido jN*2]"jN*2] ?
Jim
1
@ Jim no, porque esto no es capaz de carga útil: c
Rod
9

V , 4 bytes

2ii2

Salidas:

i2i2

Pruébalo en línea!

Riley
fuente
2x inserto i2?
CalculatorFeline
1
Sí. 2 -> do the next thing twice i -> insert the following
Riley
Ah ya veo, pensé que era Vim.
Mago de trigo
@WheatWizard No, esta es una modificación trivial de la quine V estándar.
Riley
1
@isaacg: no, en Vim deberías presionar ESC una vez que hayas terminado, lo cual es un problema porque no hay caracteres ESC en la salida.
9

> <> , 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
Kritixi Lithos
fuente
":1+>o<!Es un poco más corto.
Wheat Wizard
@WheatWizard Gracias, ese fue un buen golf :)
Kritixi Lithos
1
Puede obtener 7 bytes:":1->o#
Conor O'Brien
@ ConorO'Brien Gracias por la sugerencia, eso es realmente inteligente.
Kritixi Lithos
Gracias :) Estoy gratamente sorprendido de que funcione mejor aquí que en el quine real
Conor O'Brien
9

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.
6 infinito 8
fuente
8

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

CalculadoraFeline
fuente
Vaya, versión anterior :(
CalculatorFeline
1
@Downvoter Por favor, anule la votación.
CalculatorFeline
7

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.

Asistente de trigo
fuente
Puedes usar en plugar de puts?! Tanto la pérdida de tiempo ...
Magia pulpo Urna
44
@carusocomputing No es exactamente lo mismo que pone. p xes equivalente aputs x.inspect
Conor O'Brien
6

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

Neil
fuente
1
¿Por qué no usar en *2lugar de .repeat(2), eso no funciona?
Magic Octopus Urn
1
@carusocomputing JavaScript no se sobrecarga *para cadenas
Conor O'Brien
1
@carusocomputing Eso me dio una idea, ¡gracias!
Neil
4

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.

ETHproducciones
fuente
Otro 10-byter:Q+"+Q² " ²
Conor O'Brien
@ ConorO'Brien Sí, y siempre puedes organizar los 4 caracteres dentro de la cadena en cada una de las 24 permutaciones posibles. También creo que siempre puedes reemplazar ambos espacios con nuevas líneas
ETHproductions
3

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.

Pomo de la puerta
fuente
3

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
$

Martin Ender
fuente
3

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
Coronel Panic
fuente
1
Creo que la última respuesta aquí viola las reglas de quine (todos los caracteres en la salida tienen el mismo propósito que el carácter coincidente en la entrada). Sin embargo, los otros están bien.
2

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="
Laikoni
fuente
Solo un anagrama quine en lugar de un quine verdadero ...
Feathercrown
2

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

Urna de pulpo mágico
fuente
1
Explicación por favor. Además, los bytes pueden (probablemente) guardarse usando el *2relleno entre comillas:{"""{""*""2""}"""*2}
CalculatorFeline
@CalculatorFeline es bastante autoexplicativo. Pero sí, esa es una idea <s> 100% </s> 9% mejor que la mía.
Magic Octopus Urn
3
En realidad, es solo un 9% mejor: P
CalculatorFeline
2

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''∞∞
Urna de pulpo mágico
fuente
2

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.
Martin Ender
fuente
Estaba a punto de publicar esto ... "` _ "_` también funciona
Luis Mendo
1

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.

Pomo de la puerta
fuente
1

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

Gato de negocios
fuente
1

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
MegaTom
fuente
Sí. Pero también lo hace ". ¿Cuál es la restricción sobre eso exactamente?
MegaTom
No creo que "se considere leer la propia fuente, es solo un literal de cadena. gSin embargo, está leyendo descaradamente su propia fuente.
Wheat Wizard
@WheatWizard está bien. Lo cambiaré.
MegaTom
":1+>:#,_@!También funciona pero no es más corto.
Wheat Wizard
' 2+"8k,@para 9 bytes
ovs
1

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.

Steenbergh
fuente
1

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
Datboi
fuente
1

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)

Luke
fuente
Creo que puede usar la quine estándar y cambiarla cíclicamente (por ejemplo R"'!+O, sin probar).
Martin Ender
@ MartinEnder: tienes razón. Actualizado. Gracias por ayudar.
Lucas
1

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.

Ben
fuente
1
No creo que esto sea válido. La definición de nuestro sitio requiere que las quines tengan un "codificador" y un "decodificador", esto prohíbe las quines de tipo literal solamente.
Wheat Wizard
Todas las reglas para quines se trasladan a este desafío.
Wheat Wizard
@WheatWizard: El .codifica en sí mismo, pero no creo que lo 0haga. Un 0 más allá del punto decimal no se puede ver como codificación de un cero inicial antes del punto decimal, este último es un efecto secundario de imprimir un flotante. Entonces, bajo las viejas reglas de quine, no hay problema aquí. (No estoy seguro de si las nuevas reglas han entrado en vigor todavía)
@ ais523 No lo sé. Quizás esto debería ser abordado por una meta pregunta.
Wheat Wizard
1

Python 3, 31 bytes

a='a=%r;pritn(a%%a)';print(a%a)
aaay aaay
fuente
1

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.
Weijun Zhou
fuente
0

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
Riley
fuente