Ceci est le fil des flics. Pour le fil des voleurs, cliquez ici .

Tâche des flics

• Tout d'abord, écrivez une quine dans la langue de votre choix.
• Ensuite, brouillez le quine. Assurez-vous de bien faire cela car les voleurs tenteront de le déchiffrer et de trouver le code source d'origine! Notez que le code brouillé n'a pas besoin de fonctionner.
• Postez une réponse sur ce fil. Incluez la langue, le nombre d'octets et le code brouillé.

Votre programme peut ne pas imprimer sur STDERR.

Voici un exemple de soumission de flic:

Python, 29 octets

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

Tâche des voleurs

Pour le fil des voleurs, cliquez ici .

Soumissions sécuritaires

Si votre soumission n'a pas encore été piratée après une semaine de publication, vous pouvez ajouter la solution et spécifier qu'elle est sûre. Si vous ne le faites pas, votre soumission peut encore être piratée.

Notation

Il s'agit de code-golf , donc l'utilisateur avec la soumission sûre avec le moins d'octets sera le gagnant de cette section.

Classement

Voici un extrait de pile pour générer un tableau d'apprentissage pour ce défi. Pour qu'il s'affiche correctement, veuillez formater votre soumission comme suit:

# Language Name, N bytes

... other stuff ...

Si votre soumission est piratée, veuillez formater comme ceci:

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

... other stuff ...

Si votre soumission est sûre, formatez comme ceci:

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

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

Ma stratégie consiste à faire craquer tous les courts et personne ne s'en soucie compte tenu de la durée ... De plus, je suppose que je dois noter que c'est un programme complet, pas seulement une fonction.

JavaScript, 1574 octets, sûr!

J'ai passé trop de temps là-dessus. Voici l'obscurcissement.

(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

Voici la source 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 octets. Fissuré

It'D-whoLl&w#ck'f0Gz

N'essayez pas de casser cela. Cela détruirait complètement les brouillards.

Sous-charge , 20 octets, fissurée!

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

J'ai brouillé cela en randomisant l'ordre des caractères, car quoi de plus brouillé que aléatoire?

Un interpréteur Underload correctement écrit se bloque lorsque vous voyez une nouvelle ligne au niveau supérieur du programme. Comme d'habitude dans les compétitions de golf, il n'y a pas de nouvelle ligne à la fin du programme; Je place simplement ce rappel ici car il est très facile d'en ajouter un par erreur lors de la copie du programme vers un interprète.

Rétine , 20 octets, fissurée

S`(\?)\1*

S`(\?)\1*

Le programme (et la sortie) contient exactement deux sauts de ligne.

Vous pouvez essayer Retina en ligne ici.

Un petit indice:

Dans le processus de conception de ce flic, j'ai trouvé une nouvelle quine de rétine la plus courte, que je posterai à notre défi de quine une fois que cette réponse sera fissurée ou sûre.

CJam, 39 octets, sûr

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

Solution:

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

Utilise un codage de base pour l'obscurcissement. Cependant, comme les personnages sont tous en ASCII, j'aurais pensé que quelqu'un pourrait trouver ce 32fm95b??b??f+:cqui serait suffisant pour forcer le reste.

Pyth, 38 octets, sûr

Pas tout à fait au golf, mais ça marche.

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

Version non triée:

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

Vim, 22 octets, fissuré!

pit^[^[p00tqqqq^V"ltxltx"

Les ^[sont la clé d'échappement littérale, et ^Vsont Ctrl-V, et sont donc comptées comme un octet, et sont conservées ensemble dans le code brouillé.

Python 2, 54 octets, fissuré!

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

JavaScript, 147 octets, fissuré par ETHProductions

Je serai très impressionné si quelqu'un réussit à résoudre ce problème ...

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

Solution envisagée:

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 octets, craqué par nimi

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

Il s'agit d'une expression Haskell valide qui affiche:

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

Donc, si Ric étudie, il peut aller à la délicieuse fête du cirque de bonbons! Autrement dit, s'il comprend où se trouve Syrirrr .

V , 20 octets - Sûr!

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

Notez la nouvelle ligne de fin.

Je ne savais pas vraiment comment les brouiller, alors j'ai juste trié les caractères par valeur ASCII.

Contrairement à la plupart des réponses V, celle-ci ne contient aucun caractère non imprimable. Voici un hexdump:

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

Code décrypté:

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

Essayez-le en ligne!

Côté pas sur ce lien. Dans les versions précédentes de V, une nouvelle ligne était toujours automatiquement imprimée, c'est pourquoi cette version a la nouvelle ligne de fin. L'interprète au moment où j'ai écrit ceci était un quine valide, bien que maintenant vous puissiez simplement supprimer la nouvelle ligne pour la rendre valide.

Explication:

éñ                      " 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 octets, sûr

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

Un autre quine Haskell, cette fois avec un joli impair de 99 octets.

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

Essayez-le sur Ideone. Les espaces dans "g <$> w" doivent être supprimés, je les y mets car sinon les <, $ et> disparaissent (probablement interprétés comme balise html). La chaîne de charabia est une chaîne du programme avec chaque char mappé à son successeur, y compris une finale "(qu'il est possible d'inclure dans la chaîne sans s'échapper car elle est mappée #). La fonction d'assistance %prend la chaîne et mappe chaque caractère à son prédécesseur à l'aide de pred(rendement code"), puis ajoute la chaîne d'origine (rendement code"gibberish_code) et le dernier caractère de la chaîne décodée (rendement code"gibberish_code"). Pour convertir un char cen une chaîne, il suffit normalement de le mettre dans une liste [c]car les chaînes dans Haskell sont simplement des listes de char, mais le successeur de[is \, qui aurait besoin d'être échappé dans la chaîne codée par le successeur, donc pureest utilisé à la place qui lève des types arbitraires dans une Monade (laquelle Monade à utiliser est déduite du contexte).

PHP, 110 octets, fissuré

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

Javascript ES6, 49 octets (craqué)

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

Est-ce mauvais si je me concentre davantage sur la formation de mots cohérents dans la solution brouillée?

En tout cas, c'est mon premier défi Cops and Robbers.

Mise à jour : voir les commentaires pour le code fissuré.

FurryScript, 199 octets, sûr!

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

Devrait être assez facile à casser.

Code décrypté

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

Juste le quine régulier, mais avec deux sous-programmes et un peu plus de code pour échanger les chaînes.

Vim, 17 octets

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

L' <CR>entrée est ( ^Mou ^J) dans l'entrée et une nouvelle ligne ajoutée dans la sortie. Ce n'est pas la nouvelle ligne implicite de fin de fichier (voir :help 'eol'). Les 17 octets sont ce qui est ajouté à un tampon vide. (Les retours à la ligne dans un éditeur de texte sont bizarres; faites-moi savoir si ce n'est pas clair.)

> <> , 36 octets, fissuré!

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

Befunge-93, 15 octets, fissuré!

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

Essayez-le en ligne!

Python 2, 105 octets, fissuré!

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

L'autre a été fissuré, donc celui-ci est plus difficile.

print'Pour trouver la solution, mettez-vous au travail! '

Ruby, 53 octets - Cracké

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

Ce \nsont des nouvelles lignes littérales.

QB64 , 89 octets

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

Quelques points saillants:

• Le code ne fonctionnera pas dans QBasic: il utilise des fonctionnalités spécifiques à QB64
• L'extension de la syntaxe est désactivée
• Aucun signe dollar et un seul guillemet
• "Poésie" serait un tronçon, mais ça rime

Befunge-93, 24 octets

Je crains que ce soit un peu tard, mais je voulais en essayer un sans la gcommande.

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

Essayez-le en ligne!

HUILE , 77 octets, sûr

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

Bonne chance avec ça.

Solution, "commentée" (supprimez les commentaires avant d'exécuter ou cela ne fonctionnera pas):

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

Donc, pour résumer, cela fonctionne en imprimant d'abord deux zéros, puis en comparant chaque ligne commençant par la troisième avec zéro, et si ce n'est pas zéro, l'imprimant, sinon en sortant (puisque OIL lit zéro de tout vide / inexistant) cellule). Toutes les lignes variables contiennent la valeur qu'elles ont lorsqu'elles sont imprimées (puisque je suis paresseux, j'ai obtenu cela en faisant d'abord une quasi-quine où ces cellules ont une valeur arbitraire non nulle et en utilisant le résultat, qui est une quine) .

Gelée , 3 octets, fissurée!

Ṙ”Ṙ

Essayez-le en ligne!

Voici la solution:

Quoi, vous voulez la solution? Trouve le!