Questo è il filo della polizia. Per il thread dei ladri, fai clic qui .

Compito della polizia

• Innanzitutto, scrivi un quine in una lingua di tua scelta.
• Quindi, rimescola il quine. Assicurati di farlo bene poiché i ladri cercheranno di decodificarlo e trovare il codice sorgente originale! Si noti che il codice codificato non deve funzionare.
• Pubblica una risposta su questa discussione. Includi la lingua, il conteggio dei byte e il codice codificato.

Il programma potrebbe non essere stampato su STDERR.

Ecco un esempio di presentazione di un poliziotto:

Python, 29 byte

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

Compito dei ladri

Per il thread dei ladri, fai clic qui .

Invio sicuro

Se l'invio non è stato ancora risolto dopo una settimana di pubblicazione, è possibile aggiungere la soluzione e specificare che è sicura. In caso contrario, la tua richiesta potrebbe essere ancora violata.

punteggio

Questo è code-golf , quindi l'utente con l'invio sicuro con il minor numero di byte sarà il vincitore di questa sezione.

Classifica

Ecco uno snippet di stack per generare una lavagna per questa sfida. Affinché sia ​​visualizzato correttamente, formatta il tuo invio in questo modo:

# Language Name, N bytes

... other stuff ...

Se l'invio viene infranto, si prega di formattare in questo modo:

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

... other stuff ...

Se l'invio è sicuro, formatta in questo modo:

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

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

La mia strategia è che tutti quelli corti si rompano e nessuno se ne preoccupa considerando quanto è lungo ... Suppongo di dover notare che questo è un programma completo, non solo una funzione.

JavaScript, 1574 byte, sicuro!

Ho trascorso troppo tempo su questo. Ecco l'offuscamento.

(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

Ecco la fonte originale!

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 byte. Cracked

It'D-whoLl&w#ck'f0Gz

Non tentare di risolverlo. Abbatterebbe completamente le nebbie.

Sottocarico , 20 byte, Cracked!

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

L'ho rimescolato tramite la randomizzazione dell'ordine dei personaggi, perché cosa potrebbe essere più criptato che casuale?

Un interprete Underload correttamente scritto si arresta in modo anomalo quando viene visualizzata una nuova riga al livello superiore del programma. Come al solito nelle competizioni di golf, non c'è una nuova riga alla fine del programma; Sto inserendo questo promemoria qui perché è molto facile aggiungerne uno per errore quando si copia il programma su un interprete.

Retina , 20 byte, Cracked

S`(\?)\1*

S`(\?)\1*

Il programma (e l'output) contiene esattamente due avanzamenti di riga.

Puoi provare Retina online qui.

Un piccolo suggerimento:

Nel processo di progettazione di questo poliziotto, ho trovato una nuova quina più corta di Retina, che posterò alla nostra sfida di quine una volta che questa risposta sarà crackata o sicura.

CJam, 39 byte, sicuro

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

Soluzione:

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

Utilizza una codifica di base per l'offuscamento. Tuttavia, poiché i personaggi sono tutti in ASCII, avrei pensato che qualcuno sarebbe stato in grado di capire 32fm95b??b??f+:cquale sarebbe stato sufficiente per forzare il resto.

Pyth, 38 byte, Sicuro

Non abbastanza golf, ma funziona.

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

Versione non ordinata:

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

Vim, 22 byte, Cracked!

pit^[^[p00tqqqq^V"ltxltx"

La ^[sono la chiave escape letterale, ed ^Vè Ctrl-V, e sono quindi contati come un byte, e sono tenuti insieme nel codice criptato.

Python 2, 54 byte, Cracked!

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

JavaScript, 147 byte, Cracked di ETHProductions

Sarò molto colpito se qualcuno riuscirà a risolvere questo ...

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

Soluzione 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 byte, rotto da nimi

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

Questa è un'espressione Haskell valida che stampa:

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

Quindi, se Ric studia, può andare alla deliziosa festa del circo di caramelle! Cioè, se capisse dove si trova Syrirrr .

V , 20 byte - Sicuro!

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

Nota la nuova riga finale.

Non ero davvero sicuro di come mescolarli, quindi ho semplicemente ordinato i caratteri in base al valore ASCII.

A differenza della maggior parte delle risposte V, questa contiene zero caratteri non stampabili. Ecco un hexdump:

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

Codice non decodificato:

éññ3äl0éé $ AX3 | "qpñx

Provalo online!

Il lato non riguarda questo link. Nelle versioni precedenti di V, una nuova riga veniva sempre stampata automaticamente, motivo per cui questa versione ha la nuova riga finale. L'interprete al momento in cui ho scritto questo era un quine valido, anche se ora puoi semplicemente rimuovere la nuova riga per renderla valida.

Spiegazione:

éñ                      " 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 byte, sicuro

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

Un altro Haskell Quine, questa volta con 99 byte dispari.

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

Provalo su Ideone. Gli spazi in "g <$> w" devono essere rimossi, li ho messi lì perché altrimenti svaniscono <, $ e> (molto probabilmente interpretati come tag html). La stringa senza senso è una stringa del programma con ogni carattere mappato al suo successore, incluso un finale "(che è possibile includere nella stringa senza scappare perché è mappato a #). La funzione helper %prende la stringa e mappa ogni carattere al suo predecessore usando pred(cedendo code"), quindi aggiunge la stringa originale (cedendo code"gibberish_code) e l'ultimo carattere della stringa decodificata (cedendo code"gibberish_code"). Per convertire un carattere cin una stringa è normalmente sufficiente inserirlo in un elenco [c]poiché le stringhe in Haskell sono semplicemente elenchi di caratteri, tuttavia il successore di[è \, che dovrebbe essere evaso nella stringa codificata dal successore, quindi pureviene invece utilizzato che solleva tipi arbitrari in una Monade (che la Monade da usare viene dedotta dal contesto).

PHP, 110 byte, Cracked

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

Javascript ES6, 49 byte (crackato)

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

È male se mi concentro maggiormente sulla formazione di parole coerenti nella soluzione confusa?

In ogni caso, questa è la mia prima sfida a sbirri e poliziotti.

Aggiornamento : vedere i commenti per il codice crackato.

FurryScript, 199 byte, sicuro!

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

Dovrebbe essere abbastanza facile da decifrare.

Codice non criptato

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 il normale quine, ma con due subroutine e un po 'più di codice per scambiare le stringhe.

Vim, 17 byte

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

Il <CR>è Invio ( ^Mo ^J) in ingresso ed una aggiunta di nuova riga nell'output. E ' non è la fine implicito della nuova linea di file (vedi :help 'eol'). I 17 byte sono ciò che viene aggiunto a un buffer vuoto. (I newline in un editor di testo sono strani; fammi sapere se non è chiaro.)

> <> , 36 byte, Cracked!

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

Befunge-93, 15 byte, Cracked!

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

Provalo online!

Python 2, 105 byte, Cracked!

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

L'altro era rotto, quindi questo è più difficile.

stampa "Per trovare la soluzione, mettiti al lavoro!"

Rubino, 53 byte - Incrinato

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

L' \nsono a capo letterale.

QB64 , 89 byte

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

Alcuni punti salienti:

• Il codice non funzionerà in QBasic: utilizza funzionalità specifiche di QB64
• L'espansione della sintassi è disattivata
• Nessun segno di dollaro e solo un segno di virgolette
• "Poesia" sarebbe un tratto, ma fa rima

Befunge-93, 24 byte

Temo che sia un po 'tardi, ma volevo tentarne uno senza il gcomando.

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

Provalo online!

OLIO , 77 byte, Sicuro

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

Buona fortuna.

Soluzione "commentata" (rimuovere i commenti prima di eseguirlo o non funzionerà):

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

Quindi per riassumere, funziona prima stampando due zeri, quindi confrontando ogni riga che inizia con la terza con zero e, se non è zero, stampandola, altrimenti uscendo (poiché OIL legge zero da qualsiasi vuoto / inesistente cellula). Tutte le righe variabili contengono il valore che hanno quando vengono stampate (dato che sono pigro, l'ho ottenuto prima creando un quasi-quine in cui quelle celle hanno un valore arbitrario diverso da zero e usando il risultato, che è un quine) .

Gelatina , 3 byte, incrinata!

Ṙ”Ṙ

Provalo online!

Ecco la soluzione:

Cosa, vuoi la soluzione? Trovalo!