Este es el hilo de los ladrones. Para el hilo de la policía, haga clic aquí .

Tarea de policías

Para el hilo de la policía, haga clic aquí .

Tarea de ladrones

• Encuentra una presentación sin descifrar en el hilo de la policía. (Una presentación solo se puede descifrar una vez).
• Descifra el código para encontrar una quine que funcione.
• Publique una respuesta en el hilo de los ladrones. Incluya el idioma, el recuento de bytes, el usuario que publicó el código codificado, un enlace a esa respuesta y el código descifrado.

Aquí hay un ejemplo de presentación de ladrón:

Python, 29 bytes, Oliver

_='_=%r;print _%%_';print _%_

Puntuación

El usuario con más grietas será el ganador de esta sección.

Vim, 22 bytes, Loojvo

qtiqtqx0l"tp^V^[^[qx0l"tp

Pruébalo en línea!

Explicación:

qt                  " Start recording in register 'q'
  i                 " Enter insert mode
   qtqx0l"tp        " Enter this string
            ^V^[    " Enter a literal 'esc' character
                ^[  " Exit insert mode
                  q " Stop recording

En este punto, el búfer se ve así:

qtqx0l"tp^[

Y el cursor está en la última columna (la tecla 'esc').

x                   " Delete the esc character
 0l                 " Move to the second character on this line
   "tp              " And paste register 't'

Baja carga , 20 bytes, ais523

(:a~*(*S)):a~*(*S)*S

Pruébalo en línea!

Explicación

La quine básica en Underload es esta:

(:aSS):aSS

Así es como funciona:

                                  Stack:               Output:
(:aSS)      # Push string.        (:aSS)
      :     # Duplicate.          (:aSS) (:aSS)
       a    # Wrap in (...).      (:aSS) ((:aSS))
        S   # Print.              (:aSS)               (:aSS)
         S  # Print.                                   (:aSS):aSS

El primer problema fue reducir la cantidad Sque necesitamos, porque solo tenemos 3 para usar aquí. Podemos hacer esto haciendo uso de swapping ( ~) y concatenation ( *):

(:a~*S):a~*S

Aquí, en lugar de imprimir dos veces, juntamos la (...)versión y la versión simple de la cadena e imprimimos eso solo una vez.

El rompecabezas más grande es cómo imprimir un número impar de *y S. Ni siquiera estoy seguro de cómo llegué a la solución final, pero resulta que podemos hacerlo colocando la cola de la salida en una cadena separada. Esa cadena en sí está duplicada en la primera cadena, pero los contenidos no lo están, lo que nos da las ocurrencias adicionales de *y Sque necesitamos. Aquí hay un desglose de la solución final:

                        Stack:                       Output:
(:a~*(*S))              (:a~*(*S))              
          :             (:a~*(*S)) (:a~*(*S))              
           a            (:a~*(*S)) ((:a~*(*S)))
            ~           ((:a~*(*S))) (:a~*(*S))
             *          ((:a~*(*S)):a~*(*S))
              (*S)      ((:a~*(*S)):a~*(*S)) (*S)
                  *     ((:a~*(*S)):a~*(*S)*S)
                   S                                 (:a~*(*S)):a~*(*S)*S

MATL, 20 bytes, Luis Mendo

'wo&GzL0fk'tl#DwI-ch

Pruébalo en línea!

Nunca he usado MATL antes, por lo que mi comprensión puede estar ligeramente apagada, pero así es básicamente cómo funciona:

'wo&GzL0fk' This is a string representation of the code, offset by 3
t           Creates a duplicate copy of the string
l#D         Adds quotes to the second copy
w           Swap the unquoted version to the top of the stack
I-          Offset the characters in that version by 3
c           Convert back to characters
h           Join with the quoted string

Python 2, 54 bytes, Loojvo

l= ['l=', ';print l[0],`l`,l[1]'] ;print l[0],`l`,l[1]

Me costó encontrarlo, ya que casi nunca he tocado Python

Retina, 20 bytes, Martin Ender

\)1S*`\(?
\)1S*`\(?

Pruébalo en línea

Encontré esto simplemente jugando intentando crear una quine. Encontré la "quine más corta" que él insinuó al principio (o una similar, al menos), simplemente experimentando (14 bytes):

\)1S*`
\)1S*`

Pruébalo en línea

Me tomó alrededor de media hora a una hora. Muy inteligente, Martin!

JavaScript ES6, 49 bytes, Mama Fun Roll

function f(){return    `${(((((k=>f+'')(f)))))}`}

Casi la función estándar de JS quine, con un poco de ofuscación.

> <> , 36 bytes, Erik el golfista

'''000**rd3*:::?!;od0.!!+..233??dfrr

Pruébalo en línea!

Estoy bastante seguro de que esta no es la solución prevista. Sin embargo,> <> quines hace que sea bastante fácil deshacerse de la mayoría de los caracteres no deseados, excepto el '. Afortunadamente, también :hizo que fuera bastante fácil cuidarlos.

Explicación

'''                                    Push everything except these quotes onto the stack.
   000**                               In effect, pushes a zero.
        r                              Reverse the stack.
         d3*                           Push 39 (the quote character).
            ::                         Make two copies. The stack now holds
                                       a null-terminated representation of the
                                       entire code.
                                       The print loop begins here...
              :                        Duplicate top of stack.
               ?!;                     Terminate if zero.
                  o                    Otherwise, print.
                   d0.                 Jump back to position 13, i.e. the
                                       beginning of the print loop.
                      !!+..233??dfrr   Unused characters.

JavaScript, 147 bytes, jrich

+function e(){window[(w=[``>``]+``)[i=9/9]+w[i+i]+"ert"]('+'+e+'()');"  +./;;;;;=======>[]````````ccddddddeeeeeeeefiinnnnoooooorrrrrrrsttuwwx{}"}()

Con todos esos caracteres adicionales, esta definitivamente no es la solución deseada :-)

Haskell, 86 bytes, Laikoni

y!r=r:y:r:[y]>>=id;main=putStr$[succ$'!']!"y!r=r:y:r:[y]>>=id;main=putStr$[succ$'!']!"

Buena idea para obtener la "vía succ$'!'(ascii char after !). Faltaban algunos caracteres para obtenerlos de la forma habitual, es decir, implícitamente a través de showo print.

Befunge , 15 bytes, James Holderness

<:0:+1_@#%9,:g-

Pruébalo en línea!

Explicación

El problema aquí es que el ciclo termina cuando el carácter actual es divisible por 9, que es solo el caso -. Por lo tanto, eso tiene que ir al final.

<                 Run code from right to left.
              -   There will always be 2 zeros on top of the stack at this
                  point, and this just reduces them to 1 zero.
             g    Get the character at the coordinates given by the top
                  two stack values, (0, 0) initially.
           ,:     Print a copy of that character.
         %9       Modulo 9.
      _@#         Terminate if that is 0.
    +1            Increment the x coordinate.
   :              Duplicate it.
 :0               Push two zeros.

PHP, 110 bytes, Oliver

<?php $x='<?php $x=0; echo strtr($x, array(chr(39).$x.chr(39)));'; echo strtr($x, array(chr(39).$x.chr(39)));

Gracias, me divertí y el strtr([])truco fue nuevo para mí y espero que me ahorre algunos bytes en el futuro.

Jalea , 3 bytes, Erik el golfista

”ṘṘ

Pruébalo en línea!

Realmente no hay tantas opciones ... (Además, esta es la quine estándar).

Python 2, 105 bytes, Erik el golfista

a='a=%r;print a%%a ###(((())))**-01::@@@@@[[]]gggiiirrr~';print a%a ###(((())))**-01::@@@@@[[]]gggiiirrr~

Es solo la quine de formato de cadena Python estándar ...

Rubí, 53 bytes, wat

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

Solo una modificación del estándar heredoc quine:

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