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

Tarefa dos Policiais

• Primeiro, escreva um quine no idioma de sua escolha.
• Em seguida, embaralhe o quine. Certifique-se de fazer isso bem, pois os ladrões tentarão decifrá-lo e encontrar o código-fonte original! Observe que o código codificado não precisa funcionar.
• Poste uma resposta neste tópico. Inclua o idioma, a contagem de bytes e o código codificado.

Seu programa pode não ser impresso no STDERR.

Aqui está um exemplo de envio de policial:

Python, 29 bytes

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

Tarefa de ladrões

Para o tópico dos ladrões, clique aqui .

Submissões seguras

Se o seu envio ainda não tiver sido quebrado após uma semana de postagem, você poderá adicionar a solução e especificar que ela é segura. Caso contrário, seu envio ainda poderá estar quebrado.

Pontuação

Isso é código-golfe , então o usuário com o envio seguro com o menor número de bytes será o vencedor desta seção.

Entre os melhores

Aqui está um trecho de pilha para gerar um quadro de referência para esse desafio. Para que seja exibido corretamente, formate seu envio da seguinte maneira:

# Language Name, N bytes

... other stuff ...

Se o seu envio for quebrado, formate assim:

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

... other stuff ...

Se o seu envio for seguro, formato como este:

# 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}((@))((@)){{{>>{{{{{{}}}}}}}}}\\\\\\\;;;(@)((@)()),,;;

Minha estratégia é que todos os mais curtos fiquem rachados e ninguém se incomoda com isso, considerando quanto tempo é ... Também acho que devo observar que este é um programa completo, não apenas uma função.

JavaScript, 1574 bytes, Seguro!

Passei muito tempo nisso. Veja a ofuscação.

(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

Aqui está a fonte 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. Rachado

It'D-whoLl&w#ck'f0Gz

Não tente decifrar isso. Seria completamente nevoeiro.

Carga insuficiente , 20 bytes, rachado!

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

Eu embaralhei isso aleatoriamente na ordem dos personagens, porque o que poderia ser mais embaralhado do que aleatório?

Um interpretador de Underload escrito corretamente falha quando vê uma nova linha no nível superior do programa. Como de costume em competições de golfe, não há nova linha no final do programa; Estou apenas colocando este lembrete aqui, porque é muito fácil adicionar um por engano ao copiar o programa para um intérprete.

Retina , 20 bytes, Rachado

S`(\?)\1*

S`(\?)\1*

O programa (e saída) contém exatamente dois feeds de linha.

Você pode experimentar o Retina online aqui.

Uma pequena dica:

No processo de projetar esse policial, encontrei um novo e mais curto retina quine, que postarei em nosso desafio ao quine assim que essa resposta estiver quebrada ou segura.

CJam, 39 bytes, Seguro

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

Solução:

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

Usa alguma codificação básica para ofuscação. No entanto, como os personagens estão todos em ASCII, eu pensaria que alguém seria capaz de descobrir o 32fm95b??b??f+:cque seria suficiente para forçar o resto.

Pitão, 38 bytes, Seguro

Não é bem jogado, mas funciona.

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

Versão não classificada:

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

Vim, 22 bytes, Rachado!

pit^[^[p00tqqqq^V"ltxltx"

o ^[ são a chave de escape literal, e ^Vé Ctrl-V, e, portanto, são considerados como um byte, e são mantidos juntos no código mexidos.

Python 2, 54 bytes, Rachado!

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

JavaScript, 147 bytes, Rachado por ETHProductions

Ficarei muito impressionado se alguém conseguir quebrar isso ...

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

Solução pretendida:

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, quebrado por nimi

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

Esta é uma expressão Haskell válida que imprime:

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

Então, se Ric estuda, ele pode ir à festa de circo gostoso! Ou seja, se ele descobrir onde está Syrirrr .

V , 20 bytes - Seguro!

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

Observe a nova linha à direita.

Eu não tinha muita certeza de como embaralhá-los, então apenas classifiquei os caracteres pelo valor ASCII.

Diferentemente da maioria das respostas em V, essa contém zero caracteres não imprimíveis. Aqui está um hexdump:

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

Código sem codificação:

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

Experimente online!

Lado não sobre este link. Nas versões anteriores do V, uma nova linha era sempre impressa automaticamente, e é por isso que esta versão tem a nova linha à direita. O intérprete na época em que escrevi isso era uma solução válida, embora agora você possa remover a nova linha para torná-la válida.

Explicação:

éñ                      " 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

Outro quine de Haskell, desta vez com um bom e estranho 99 bytes.

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

Experimente em Ideone. Os espaços em "g <$> w" devem ser removidos, eu os coloquei lá porque, caso contrário, os <, $ e> desaparecem (provavelmente sendo interpretados como tag html). A sequência sem sentido é uma sequência do programa com cada caractere mapeado para seu sucessor, incluindo um final "(que é possível incluir na sequência sem escapar porque foi mapeado #). A função auxiliar %pega a string e mapeia cada caractere para seu predecessor usando pred(yield code"), depois anexa a string original (yield code"gibberish_code) e o último caracter da string decodificada (yield code"gibberish_code"). Para converter um caractere cem uma string, normalmente seria suficiente colocá-lo em uma lista, [c]pois strings em Haskell são simplesmente listas de caracteres, no entanto, o sucessor de[ é\ , que precisaria ser escapado na sequência codificada pelo sucessor.pure é usado o que eleva tipos arbitrários para uma Mônada (a qual a Mônada usar é deduzida do contexto).

PHP, 110 bytes, Cracked

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

Javascript ES6, 49 bytes (cracked)

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

Is it bad if I focused more on forming coherent words in the scrambled solution?

In any case, this is my first Cops and Robbers challenge.

Update: see comments for cracked code.

FurryScript, 199 bytes, Safe!

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

Should be fairly easy to crack.

Unscrambled Code

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!#

Just the regular quine, but with two subroutines and some more code to swap the strings.

Vim, 17 bytes

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

The <CR> is Enter (^M or ^J) in the input and an added newline in the output. It is not the implicit end of file newline (see :help 'eol'). The 17 bytes are what is added to an empty buffer. (Newlines in a text editor are weird; let me know if this isn't clear.)

><>, 36 bytes, Cracked!

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

Befunge-93, 15 bytes, Cracked!

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

Try it online!

Python 2, 105 bytes, Cracked!

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

The other one was cracked, so this one is more difficult.

print'To find the solution, get to work!'

Ruby, 53 bytes - Cracked

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

The \n are literal newlines.

QB64, 89 bytes

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

Some salient points:

• The code will not work in QBasic: it uses QB64-specific features
• Syntax expansion is off
• No dollar signs and only one quotation mark
• "Poetry" would be a stretch, but it does rhyme

Befunge-93, 24 bytes

I'm afraid this is a bit late, but I wanted to attempt one without the g command.

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

Try it online!

OIL, 77 bytes, Safe

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

Good luck with that.

Solution, "commented" (remove comments before running or it won't work):

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

So to summarize, it works by first printing two zeros, and then comparing every line starting with the third one with zero, and if it isn't zero, printing it, else exiting (since OIL reads zero from any empty/non-existent cell). Any variable lines contain the value they have when they are printed (since I'm lazy, I obtained this by first making a near-quine where those cells have some arbitrary non-zero value, and using the result, which is a quine).

Jelly, 3 bytes, Cracked!

Ṙ”Ṙ

Try it online!

Here is the solution:

What, you want the solution? Find it!