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

Tarea de policías

• Primero, escriba una frase en el idioma que elija.
• A continuación, revuelva la quine. ¡Asegúrate de hacerlo bien ya que los ladrones intentarán descifrarlo y encontrar el código fuente original! Tenga en cuenta que el código codificado no necesita funcionar.
• Publique una respuesta en este hilo. Incluya el idioma, el recuento de bytes y el código codificado.

Es posible que su programa no imprima en STDERR.

Aquí hay un ejemplo de envío de policía:

Python, 29 bytes

nt _%=_r;_riinp;pr_='t _%%%_'

Tarea de ladrones

Para el hilo de los ladrones, haga clic aquí .

Envíos seguros

Si su envío aún no se ha descifrado después de una semana de publicación, puede agregar la solución y especificar que es segura. Si no lo hace, su envío aún puede estar descifrado.

Tanteo

Este es el código de golf , por lo que el usuario con el envío seguro con la menor cantidad de bytes será el ganador de esta sección.

Tabla de clasificación

Aquí hay un fragmento de pila para generar un tablero de aprendizaje para este desafío. Para que se muestre correctamente, formatee su envío de esta manera:

# Language Name, N bytes

... other stuff ...

Si su envío se agrieta, formatee así:

# Language Name, N bytes, [Cracked!](link)

... other stuff ...

Si su envío es seguro, formatee así:

# Language Name, N bytes, Safe!

... other stuff ...

<script>site = 'meta.codegolf'; postID = 5686; isAnswer = false; QUESTION_ID = 99469;</script><script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)</code></pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>

C #, 288 bytes

Stag is a great shoW.        "="=""="="Agent"plastic"Was"tryin"to"Release"an"Astroid"."$Money$"st@le"tigers"and"Agent"plastic"got"mad"."$Money$"sic","man","t0tally"rad"."Sistrs"Rms"titAnic";"Civic"Ace"in"{sC@m}{hic}{vicis}..{cats}sAc}((@))((@)){{{>>{{{{{{}}}}}}}}}\\\\\\\;;;(@)((@)()),,;;

Mi estrategia es que todos los cortos se quiebren y nadie se preocupe por esto considerando cuánto tiempo es ... También supongo que debo tener en cuenta que este es un programa completo, no solo una función.

JavaScript, 1574 bytes, ¡Seguro!

Pasé demasiado tiempo en esto. Contempla la ofuscación.

(notice that an unmatch parenthesis remains throughout the entire text.

dear "sir",

|    i cannot express my loathing to you and your things. they truly are a loathsome sight. (regar'less of their quality, they function as the most appalling devices...)[1]

|    these avocads of thine possession are most unpleasent. (ce n'est pas faux.) Queer; Careful; An' in total repulsing. in this form, those are not seulement cringe... So; CAB's is quite Cruel. (Cruel indeed...)

|    intention is not great (heh, intention, ;}) run, no, run, since {tu est le ;AqC;};

{{{{============================================}}}}

[1]: see? am i not insane? You may dictate the opposite, so i dictate thus.

9 + 4 is 13. Y is this. Y + 4 is 9 + 9 minus one. N is this. f(x) is {x + x}, so f(N) is N plus N is N + N is 3.

:^) i'm cruel; not so cruel.)
                                  rrrrrrrrrr 0nnnccnnggrrrrttssBBC
{({[}(<[<))(((((){{})}[}][[]{}(]))))|} f f r 0nnnccnngrrrrrttesBBA
())(((()))))()))()()()((((()))}{{})((} f f r 0nnnccnngrrrrrttesBBY
]]}(([][]{{{}}})()({}(){}{()}{}()[])][ f f r 4nnnccnngrrrrrttesBSY
))({})(}{)({{{{(()))())))))))()))()()( f f r 4nnnccnngrrrrrtpesqSY
)()()((((((((((Z))))))))()(()((()((((( f f r 5nnnccnngrrrrrtlefoSY
(((;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;''' f f r 3nnncccngrrrrxtleifSY
''''''''''''''''''',,,,,,,,[[[[[[]]]]] f f r 3nnncccngrrrrxtleifZQ
[ ] ] + + + + + + + + + + + + + + + ++ f f r 9nnncccggrrrrxtleifZQ
+ + + + too not fun...fffffffffffffuuu f f r 5nnncccggrrrrxtlli0ZQ
uuuuuuuuuuuu.. | | | |99S            ) f f r 0nnncccggrrrrxxll01QQ

Aquí está la fuente original!

function Y(x){return x.charCodeAt()};
function Q(x){return String.fromCharCode(x)};
N=Array.prototype;
function B(f,g,h){return function(){
  return f(g.apply(h||this,arguments));
}};
function S(f,h){return function(){
  return f.apply(h||this,N.reverse.call(arguments))}}
function id(x){return x};
function format(){
  args = N.slice.call(arguments);
  str = args.shift(); res = []+[];
  for(i = 0; i < str.length; i++){
    c = function(){return str[i]};
    if(B(Y,c) == 95){
      res += args.shift();
    } else if(S(B)(c,Y)() == 94){
      res += q = B(id,Q)(34);
      res += args.shift();
      res += q;
    } else if(Y(c()) == 39){
      i++;
      res += c() == ([][0]+[])[1] ? Q(10) : []+[];
    } else res += c();
  }
  return res;
}
console.log(format(Z="function Y(x){return x.charCodeAt()};'nfunction Q(x){return String.fromCharCode(x)};'nN=Array.prototype;'nfunction B(f,g,h){return function(){'n  return f(g.apply(h||this,arguments));'n}};'nfunction S(f,h){return function(){'n  return f.apply(h||this,N.reverse.call(arguments))}}'nfunction id(x){return x};'nfunction format(){'n  args = N.slice.call(arguments);'n  str = args.shift(); res = []+[];'n  for(i = 0; i < str.length; i++){'n    c = function(){return str[i]};'n    if(B(Y,c) == 95){'n      res += args.shift();'n    } else if(S(B)(c,Y)() == 94){'n      res += q = B(id,Q)(34);'n      res += args.shift();'n      res += q;'n    } else if(Y(c()) == 39){'n      i++;'n      res += c() == ([][0]+[])[1] ? Q(10) : []+[];'n    } else res += c();'n  }'n  return res;'n}'nconsole.log(format(Z=^,Z))",Z))

MATL , 20 bytes. Agrietado

It'D-whoLl&w#ck'f0Gz

No intentes descifrar esto. Despertaría totalmente las nieblas.

¡Carga insuficiente , 20 bytes, agrietada!

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

Lo codifiqué aleatorizando el orden de los personajes, porque ¿qué podría ser más codificado que aleatorio?

Un intérprete de Underload escrito correctamente se bloquea al ver una nueva línea en el nivel superior del programa. Como es habitual en las competiciones de golf, no hay una nueva línea al final del programa; Solo estoy colocando este recordatorio aquí porque es muy fácil agregar uno por error al copiar el programa a un intérprete.

Retina , 20 bytes, agrietada

S`(\?)\1*

S`(\?)\1*

El programa (y salida) contiene exactamente dos avances de línea.

Puedes probar Retina en línea aquí.

Una pequeña pista:

En el proceso de diseño de este policía, encontré una nueva quina de retina más corta, que publicaré en nuestro desafío de quina una vez que esta respuesta esté descifrada o sea segura.

CJam, 39 bytes, seguro

!""$)+023345679:AEORYZZ\_```bbceeffimmz

Solución:

")A!0z`eZOmRZ$Yei`E"_`\32fm95b67b43f+:c

Utiliza alguna codificación base para ofuscación. Sin embargo, dado que todos los personajes están en ASCII, habría pensado que alguien podría descubrir 32fm95b??b??f+:ccuál sería suficiente para forzar al resto.

Pyth, 38 bytes, seguro

No del todo golf, pero funciona.

````::""@@@@++++22ggKKKKKKKKNNNNZZZZ

Versión sin clasificar:

K"K++@KZ:`K@`NZNgK2"++@KZ:`K@`NZNgK2

¡Vim, 22 bytes, agrietado!

pit^[^[p00tqqqq^V"ltxltx"

El ^[son la tecla de escape literal, y ^Ves Ctrl-V, por tanto, se cuentan como un byte, y se mantienen juntos en el código revueltos.

Python 2, 54 bytes, ¡Agrietado!

=l`;lrt,]l n`p,i=,' 1,1'lnt[ll[;,0  ]['r[`][`0'ipll] ]

JavaScript, 147 bytes, agrietadas por ETHProductions

Estaré muy impresionado si alguien logra descifrar esto ...

   """"''''((((()))))+++++++++.//99;;;;;;=========>>[[[[[]]]]]``````````````cccdddddddeeeeeeeeeeeffiiiiiiinnnnnnnoooooooorrrrrrrrsttttuuwwwwwwx{{}}

Solución prevista:

e=o=>{n=o;``[r=`constructor`][r](`return e=>{`+o+`}`)````};d=e+"";e`for(i in window)if(/ert/.exec(i))w=window[i];w('e='+d+';d=e+"";e'+d[9]+n+d[9])`

Haskell, 86 bytes, descifrado por nimi

putStr$"Study:ric====>>>>yummy:candy:circus:party:in:syrirrr!!!!!!$[;['=['[$]']='];]$"

Esta es una expresión válida de Haskell que imprime:

Study:ric====>>>>yummy:candy:circus:party:in:syrirrr!!!!!!$[;['=['[$]']='];]$

Entonces, si Ric estudia, ¡puede ir a la deliciosa fiesta de dulces de circo! Es decir, si descubre dónde está Syrirrr .

V , 20 bytes - ¡Seguro!

"$ 033lpqxx | áäéééñññ

Tenga en cuenta la nueva línea final.

No estaba realmente seguro de cómo mezclarlos, así que simplemente ordené los caracteres por valor ASCII.

A diferencia de la mayoría de las respuestas V, esta contiene cero caracteres no imprimibles. Aquí hay un hexdump:

0000000: 2224 3033 336c 7071 7878 7ce1 e4e9 e9e9  "$033lpqxx|.....
0000010: f1f1 f10a                                ....

Código descifrado:

éññ3äl0éé $ áx3 | "qpñx

Pruébalo en línea!

Lado no sobre este enlace. En versiones anteriores de V, una nueva línea siempre se imprimía automáticamente, razón por la cual esta versión tiene la nueva línea final. El intérprete en el momento en que escribí esto era una quine válida, aunque ahora puede eliminar la nueva línea para que sea válida.

Explicación:

éñ                      " Insert a 'ñ' character
  ñ              ñ      " Put all of the following into register 'q' and run it when it's done recording
   3äl                  " Make 3 copies of the character under the cursor
      0                 " Move to the first column
       éé               " Insert an 'é' character
         $              " Move to the last column
          áx            " Append an 'x'
            3|          " Move to the third column
              "qp       " Paste register 'q' (all of the commands we just ran)
                  x     " Delete a character

Haskell, 99 bytes, seguro

"super.quine?"=>#$$$%%%%%&&(())))**++++,,,,/;<<==>>STaabbdeffggghhhjlmmnoppqqrrsssttttuuuvvwwwwxxxx

Otra cita de Haskell, esta vez con unos bonitos 99 bytes impares.

g% w = (g <$> w) ++ w ++ puro (g.last $ w); main = putStr $ pred% "h & x>) h =%? x * ,, x ,, qvsf) h / mbtu% x * qvuTus% qsfe & # "

Pruébalo en Ideone. Los espacios en "g <$> w" deben eliminarse, los puse allí porque de lo contrario desaparecerán <, $ y> (lo más probable es que se interprete como etiqueta html). La cadena de galimatías es una cadena del programa con cada carácter asignado a su sucesor, incluido un final "(que es posible incluir en la cadena sin escapar porque está asignado a #). La función auxiliar %toma la cadena y asigna cada carácter a su predecesor usando pred(rendimiento code"), luego agrega la cadena original (rendimiento code"gibberish_code) y el último carácter de la cadena decodificada (rendimiento code"gibberish_code"). Para convertir un char cen una cadena, normalmente sería suficiente ponerlo en una lista, [c]ya que las cadenas en Haskell son simplemente listas de char, sin embargo, el sucesor de[ es\, que necesitaría escapar en la cadena codificada por el sucesor, por lo que en su lugar purese usa lo que eleva los tipos arbitrarios a una Mónada (qué Mónada usar se infiere del contexto).

PHP, 110 bytes, agrietado

php$=))$)<9 php .(().)'heroes ?  $0(9carrot3?$;<.()trash3,.((3=)catarrh$$9 (,'9cry(3);  ;;tryccchhhrrrrxxxxxx

Javascript ES6, 49 bytes (descifrado)

{{$((((((('`fuck rent =+> turn off fin`')))))))}}

¿Es malo si me enfoco más en formar palabras coherentes en la solución codificada?

En cualquier caso, este es mi primer desafío de policías y ladrones.

Actualización : vea los comentarios para el código descifrado.

FurryScript, 199 bytes, ¡seguro!

UT  TTEDU DT   T U T D   ES DGT GEL L   GL
-<<<<<<+++++++[[[[#BESTQUINEEVER!#BESTQUINEEVER!#BESTQUINEEVER!#BESTQUINEEVER!#BESTQUINEEVER!#]]]]+++++++>>>>>>-

X   XG WPW   SS  X  PW S US WWTLWP  XS  PE

Debería ser bastante fácil de descifrar.

Código descifrado

BESTQUINE[ DUP LT +SW +GT +< BESTQUINE#> ]
EVER![ DUP EX+ SW EX- LT +SW +GT +< EVER!#> ]
<BESTQUINE[ DUP LT +SW +GT +< BESTQUINE#> ]> BESTQUINE#
<EVER![ DUP EX+ SW EX- LT +SW +GT +< EVER!#> ]> EVER!#

Solo la quine regular, pero con dos subrutinas y algo más de código para intercambiar las cadenas.

Vim, 17 bytes

<CR>""&(())::::\npps

El <CR>es Enter ( ^Mo ^J) en la entrada y una nueva línea agregada en la salida. Es no el fin implícito de la nueva línea de archivos (ver :help 'eol'). Los 17 bytes son lo que se agrega a un búfer vacío. (Las nuevas líneas en un editor de texto son extrañas; avíseme si esto no está claro).

> <> , 36 bytes, ¡Agrietado!

!!!'''***+...00002333:::;???dddforrr

Befunge-93, 15 bytes, ¡Agrietado!

:::@#%+-_,<910g

Pruébalo en línea!

Python 2, 105 bytes, ¡Agrietado!

    ######%%%%''(((((((())))))))****--0011::::;;==@@@@@@@@@@[[[[]]]]aaaaaaggggggiiiiiiiinnpprrrrrrrrrtt~~

El otro estaba roto, por lo que este es más difícil.

print'Para encontrar la solución, ¡ponte a trabajar! '

Ruby, 53 bytes - Agrietado

**TEN sTupID,sTupID NET,"TIN"<22"DEN"<<It<DEtINDE\n\n

El \nson literales saltos de línea.

QB64 , 89 bytes

(_+cad:effecs:fact), =+cred:scarf:attaccd?, =+eff4c3d:cars:craccd?, (_+csc:f4c3d:fact), "

Algunos puntos destacados:

• El código no funcionará en QBasic: utiliza características específicas de QB64
• La expansión de sintaxis está desactivada
• Sin signos de dólar y solo una comilla
• "Poesía" sería una exageración, pero sí rima

Befunge-93, 24 bytes

Me temo que esto es un poco tarde, pero quería intentar uno sin el gcomando.

<<_:@00278899p,**++###>!

Pruébalo en línea!

ACEITE , 77 bytes, seguro

0
0
1
1
1
1
1
1
1
1
1
2
2
4
4
4
6
8
10
11
11
11
12
17
18
18
18
18
22
26
26
32

Buena suerte con eso.

Solución "comentada" (elimine los comentarios antes de ejecutar o no funcionará):

0 # nop twice
0
1 # copy element from cell 1 to 1 (so do nothing again)
1
1
4 # print what's in cell 1 (a zero)
1
11 # print a newline
4 # and the same thing again; printing zero and a newline
1
11
1 # copy what's in cell 2 (a 1) into cell 2
2
2
1 # copy what's in cell 12 (two lines before; a 2) into cell 18
12
18
10 # check if the value in the cell of the following line (starting with 2; we'll jump back here)
18 # (this is cell 18)
1 # is equal-ish to the one in cell 1 (a zero)
32 # if yes, jump somewhere
22 # otherwise jump one cell ahead
1 # copy what's currently in cell 18 (first a 2) into cell 26
18
26
4 # print cell 26
26
8 # increment cell 18
18
11 # print a newline
6 # and jump back to cell 17
17

Para resumir, funciona primero imprimiendo dos ceros, y luego comparando cada línea que comienza con la tercera con cero, y si no es cero, imprimiéndola, de lo contrario saliendo (ya que OIL lee cero de cualquier vacío / inexistente celda). Todas las líneas variables contienen el valor que tienen cuando se imprimen (dado que soy vago, obtuve esto haciendo primero un quine casi donde esas celdas tienen algún valor arbitrario distinto de cero, y usando el resultado, que es un quine) .

¡Jalea , 3 bytes, agrietada!

Ṙ”Ṙ

Pruébalo en línea!

Aquí está la solución:

¿Qué, quieres la solución? ¡Encuéntralo!