Este é o fio dos ladrões. Para o tópico dos policiais, clique aqui .

Tarefa dos Policiais

Para o tópico dos policiais, clique aqui .

Tarefa de ladrões

• Encontre um envio sem rachaduras no tópico da polícia. (Um envio pode ser quebrado apenas uma vez.)
• Decifre o código para encontrar uma solução funcional.
• Poste uma resposta no tópico dos ladrões. Inclua o idioma, a contagem de bytes, o usuário que postou o código codificado, um link para essa resposta e o código codificado.

Aqui está um exemplo de envio de ladrão:

Python, 29 bytes, Oliver

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

Pontuação

O usuário com mais rachaduras será o vencedor desta seção.

Vim, 22 bytes, Loojvo

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

Experimente online!

Explicação:

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

Nesse ponto, o buffer fica assim:

qtqx0l"tp^[

E o cursor está na última coluna (a tecla 'esc').

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

Subcarga , de 20 bytes, ais523

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

Experimente online!

Explicação

A solução básica em Underload é esta:

(:aSS):aSS

Aqui está como funciona:

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

A primeira questão foi reduzir o número de Sque precisamos, porque só temos três para uso aqui. Podemos fazer isso usando swapping ( ~) e concatenation ( *):

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

Aqui, em vez de imprimir duas vezes, (...)juntamos a versão e a versão simples da sequência e a imprimimos apenas uma vez.

O maior quebra-cabeça é como imprimir um número ímpar de *e S. Nem tenho certeza de como cheguei à solução final, mas podemos fazer isso colocando a cauda da saída em uma sequência separada. Essa seqüência em si é duplicada na primeira corda, mas o conteúdo não for, o que nos dá as ocorrências extras de *e Snós precisamos. Aqui está um detalhamento da solução 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

Experimente online!

Eu nunca usei o MATL antes, então meu entendimento pode estar um pouco errado, mas é basicamente assim que 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]

Tive dificuldade em encontrá-lo, já que basicamente quase nunca toquei em python

Retina, 20 bytes, Martin Ender

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

Experimente online

Eu descobri isso simplesmente brincando, tentando criar uma solução. Eu encontrei o "quine mais curto" que ele sugeriu no início (ou um similar, pelo menos), simplesmente experimentando (14 bytes):

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

Experimente online

Levei cerca de meia hora a uma hora. Muito esperto, Martin!

JavaScript ES6, 49 bytes, Mama Fun Roll

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

Praticamente a função JS padrão quine, com um pouco de ofuscação.

> <> , 36 bytes, Erik , o jogador de golfe

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

Experimente online!

Tenho certeza de que essa não é a solução pretendida. No entanto,> <> quines tornam bastante fácil se livrar da maioria dos caracteres indesejados, exceto o '. Felizmente, :tornou muito fácil cuidar deles também.

Explicação

'''                                    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{}"}()

Com todos esses caracteres extras, essa definitivamente não é a solução pretendida :-)

Haskell, 86 bytes, Laikoni

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

Boa idéia para obter a "via succ$'!'(ascii char depois !). Havia alguns caracteres ausentes para obtê-los da maneira usual, ou seja, implicitamente via showou print.

Befunge , 15 bytes, James Holderness

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

Experimente online!

Explicação

O problema aqui é que o loop termina quando o caractere atual é divisível por 9, o que é apenas o caso -. Portanto, isso precisa ir no 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)));

Obrigado, me diverti e o strtr([])truque foi novo para mim, que espero que me salve alguns bytes no futuro.

Geléia , 3 bytes, Erik , o jogador de golfe

”ṘṘ

Experimente online!

Na verdade, não existem muitas opções ... (Além disso, este é o quine padrão).

Python 2, 105 bytes, Erik , o jogador de golfe

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

É apenas o padrão de formatação de string Python quine ...

Ruby, 53 bytes, wat

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

Apenas uma modificação do heredoc quine padrão:

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