Note : Ce défi est maintenant fermé aux nouvelles soumissions de flic. Ceci afin de garantir que personne ne puisse poster des soumissions qui ne sont pas craquées parce qu'il n'y a plus assez de voleurs intéressés par le défi.

Dans ce jeu de flics-and-robbers, chaque flic écrira un programme simple pour donner une sortie unique. Ils vont ensuite rendre publiques quatre choses à propos de leur programme:

1. La langue
2. La durée du programme
3. La sortie désirée
4. Une version brouillée du code source

Ensuite, les cambrioleurs doivent déchiffrer le code source afin que leur programme fonctionne comme l’original.

Règles du flic

Vous devez écrire un programme simple, que les voleurs essaieront de recréer.

Votre programme d'origine doit avoir une fonctionnalité simple: lors de son exécution, il génère une seule chaîne / nombre et s'arrête. Il devrait donner le même résultat, quel que soit le moment, le lieu où il est exécuté, et ne devrait pas dépendre de bibliothèques supplémentaires ou d’Internet.

Votre programme et votre sortie doivent utiliser un fichier ASCII imprimable (nouvelles lignes et espaces autorisés). La sortie ne doit pas comporter plus de 100 caractères et le programme doit prendre moins de 5 secondes environ pour s'exécuter sur une machine raisonnable. Vous n'êtes également pas autorisé à utiliser le hachage (ou d'autres fonctions cryptographiques) dans votre programme.

Ensuite, vous fournissez une version brouillée du code source et la sortie requise. Vous pouvez brouiller votre code source comme bon vous semble, tant que les caractères sont conservés.

Votre score est le programme le plus court que vous avez soumis et qui n'a pas été fissuré. Après une période d'une semaine, une soumission non fissurée sera immunisée. Afin de réclamer cette immunité, vous devez modifier votre réponse pour indiquer la réponse correcte. (Précision: jusqu'à ce que vous révéliez la réponse, vous n'êtes pas à l'abri et vous pouvez toujours être fissuré.) Le score le plus bas l'emporte.

Exemple Simple Réponses Cop

Perl, 20

ellir"lnto Wo d";prH

Hello World

Ou...

Perl, 15

*3i)xp3rn3*x3t(

272727

Règles de voleur

Les voleurs publieront leurs tentatives de crack en tant que réponses dans un fil séparé, situé ici .

Vous avez une tentative de casser chaque soumission. Votre tentative de cracking sera une version non cryptée du code source. Si votre proposition correspond à la description (mêmes caractères, même résultat, et bien sûr, votre langue) et que vous êtes la première proposition correcte, vous gagnez un point. Il est important de noter que votre programme ne doit pas nécessairement correspondre exactement à l'original, utilisez simplement les mêmes caractères et disposez des mêmes fonctionnalités. Cela signifie qu'il pourrait y avoir plus d'une réponse correcte.

Le voleur avec le plus de points (réussies) gagne.

Exemple Simple Voleur Réponses

Votre programme était print "Hello World";. (Bien queprint"Hello World" ; pourrait également avoir fonctionné.)

Votre programme était print(3**3x3)x3

Soumissions sécurisées

1. ASP / ASP.Net, 14 (Jamie Barker)
2. Befunge-98, 15 (FireFly)
3. GolfScript, 16 ans (Peter Taylor)
4. CJam, 19 ans (DLosc)
5. GolfScript, 20 (utilisateur23013)
6. Perl, 21 ans (primo)
7. Python, 23 (mbomb007)
8. Ruby, 27 ans (histocrate)
9. SAS, 28 ans (ConMan)
10. Ruby, 29 ans (histocrate)
11. Python, 30 (mbomb007)
12. JavaScript, 31 (hsl)
13. Ruby, 33 ans (histocrate)
14. Marbelous, 37 (es1024)
15. Ruby, 43 ans (histocrate)
16. PHP, 44 (Kenorb)
17. Ruby, 45 ans (histocrate)
18. Marbelous, 45 (es1024)
19. Python 2, 45 (Emil)
20. PHP, 46 ans (Ismael Miguel)
21. Haskell, 48 ans (nooodl)
22. Python, 51 (DLosc)
23. Python, 60 (Sp3000)
24. Python 2, 62 (poisson vaseux)
25. JavaScript, 68 (Jamie Barker)
26. Mathematica, 73 (Arcinde)
27. Haskell, 77 ans (fier fierté)
28. Python, 90 (DLosc)
29. C ++, 104 (utilisateur23013)
30. ECMAScript 6, 116 (Mateon1)
31. C ++ 11, 121 (es1024)
32. Herbe, 134 (utilisateur23013)
33. PowerShell, 182 (christopherw)

Soumissions non résolues

En ordre chronologique Cette liste est une gracieuseté de nombreux utilisateurs.

• CoffeeScript, 96 (soktinpk)
• Python 3, 70 (Sp3000)
• TinyMUSH 3.1, 20 (Muqo)
• GolfScript, 32 (désintégration bêta)
• Python 2, 101 (Mateon1)
• Lua, 49 ans (ChipperNickel)
• Python, 61 ans (imallett)
• Java 6+, 218 (nhahtdh)
• CJam, 51 ans (Martin Büttner)
• J, 22 (FireFly)
• Marbelous, 106 (es1024)
• Marbelous, 107 (es1024)
• JavaScript, 79 (FireFly)
• CJam, 47 (utilisateur23013)
• Rust, 118 + Clojure, 106 + autres (Vi.) - version 2
• Marbelous, 144 (es1024)
• Python 2, 80 (MrWonderful)
• Perl, 53 (DLosc)
• Perl, 26 ans (primo)
• Mathematica, 31 (Arcinde)
• Marbelous, 144 (es1024)
• Assemblée, 78 (krzygorz)
• J, 14 (algorithmshark)
• Java 8, 157 (TheBestOne)

Un petit outil pour vérifier les solutions, gracieuseté de n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

$(function(){function e(){var e=$("#ignore-space").is(":checked");var t=$("#source").val().split("").sort();var n=$("#editor").val().split("").sort();var r,i=0;for(r=0;r<t.length;){if(t[r]==n[i]){t.splice(r,1);n.splice(i,1)}else if(t[r]>n[i]){i++}else{r++}}$("#display").val(t.join(""));n=n.join("");if(e){n=n.replace(/[\r\n\t ]/g,"")}if(n.length!=0){$("#status").addClass("bad").removeClass("good").text("Exceeded quota: "+n)}else{$("#status").addClass("good").removeClass("bad").text("OK")}}$("#source, #editor").on("keyup",function(){e()});$("#ignore-space").on("click",function(){e()});e()})

textarea{width:100%;border:thin solid emboss}#status{width:auto;border:thin solid;padding:.5em;margin:.5em 0}.bad{background-color:#FFF0F0;color:#E00}.good{background-color:#F0FFF0;color:#2C2}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<h3>Scrambled Source</h3>
<textarea id="source" class="content" rows="10"></textarea>
<h3>Unused Characters</h3>
<textarea id="display" class="content" rows="10" readonly></textarea>
<h3>Your Solution</h3>
<input type="checkbox" id="ignore-space" name="ignore-space"/>
<label for="ignore-space">Ignore space characters</label>
<div id="status" class="good">OK</div>
<textarea id="editor" class="content" rows="10"></textarea>

Python 3, taille 74 ( fissuré )

Python n'était plus le même après avoir été rééduqué par Big Brother.

Contribution:

print(war is peace)
print(freedom is slavery)
print(ignorance is strength)

Il y a deux nouvelles lignes à la fin des lignes 1 et 2.

Sortie:

True
True
True

Notez que chacun Trueest dans sa propre ligne.

Python 3, taille 12 ( fissuré )

print (abcd)

Mon programme ne produit aucune sortie et aucune erreur.

CJam, taille 20 ( fissuré) )

Code

"Stop, Hammer time!"

Sortie

2.956177636986737

Python 2, taille 50

Fissuré

Nous connaissons déjà la réponse à la question, mais quelle est la question?

Code

print *********************--///222222222222222222

Notez qu'il n'y a pas d'espaces de fin ni de nouvelles lignes. Le seul caractère d'espacement est l'unique espace aprèsprint .

Sortie

42

J'ai essayé d'équilibrer la longueur du code et les difficultés, mais cela ne me surprendrait pas si je le manquais un peu. Espérons que cela suffira à décourager la force brute, au moins.

Pyth - 71 fissuré

Code

C-3P0: "Sir, the possibility,..."* 
Han Solo: "Never Tell Me The Odds!"

Sortie

3720

* À l'origine, George Lucas avait demandé à Han d'interrompre C3-PO. **

** Il a appelé cela sa plus grande idée depuis Jar-Jar.

Note intéressante: malgré tous les changements que Pyth a subis, il reste une réponse valable ici!

Original

ts,*s,y30 l" : : i i Han Solo "eP-C"h"TsrhT

Explication

Les caractères restants vont sur la ligne suivante. Pyth n'interprète que la première ligne d'un fichier.

ts,faire un 2-tuple et obtenir leur somme -1.
*multiplier:
s,y30 l"..."additionner le 2-tuple contenant 2 * 30 et la longueur de la chaîne (18).
eP-C"h"Tobtenir le plus grand facteur premier de la valeur asci de h moins 10 (47).
srhTobtenir la somme des nombres de 0 à 10.

Au total, cela ne fait que calculer: (30 * 2 + 18) * (47) + 55-1. Après avoir lu la réponse de @ isaacg, j'ai remarqué qu'il existe une solution extrêmement simple: *h30tC"y"31 * 120.

Mis à jour

*h30tC"y" "-P:Sir, e possibilit,...
Han Solo: Never Tell Me The Odds!"
Fonctionne toujours même après tout ce temps ...

Désolé pour la mauvaise mise en forme des explications, je ne sais pas comment utiliser les blocs de spoiler: S (@ Sp3000 l’a rendu un peu plus agréable pour vous, cependant)

Maintenant, vous pouvez utiliser Pyth en ligne! Essayez ici. Merci @isaacg :)

CJam, taille 51 [SAFE]

Code

main(int argc,char* argv){printf("Hello, World!");}

Sortie

55
2292213229222231957511222223333751125537511222222135723331131931959319319

Vous pouvez jouer avec cela dans l'interprète en ligne .

Cela devrait être plus craquable qu'il n'y paraît.

Allusion

Commencez par la deuxième ligne de la sortie. Quelques chiffres n'apparaissent pas dans tout cela, et d'autres souvent avec méfiance. Pourquoi cela pourrait-il être? Si vous pouvez déchiffrer cela, le reste devrait presque tomber en place.

Solution

"that rrrrraging london Hail!v"{elccimf(;W))},(*,pa

Le temps a dû être très mauvais quand j'ai trouvé cet anagramme ...

L'allusion était supposée indiquer que la deuxième ligne est composée de factorisations primaires bien écrasées. J'espérais qu'à partir de là, il serait possible de déterminer combien de caractères et quels caractères entreraient dans la chaîne, ne laissant que quelques caractères à la fin.

Befunge-98, taille 15 [SAFE]

Code

"quick"
*+.@\_j

Sortie

3314

Original

"u_ji@q.+k*c
"

Une caractéristique curieuse mais quelque peu connue de Befunge est que vous pouvez terminer une chaîne avec la même citation qui la commence, ce qui en substance pousse toute la ligne (à l'exception de la citation) sur la pile. En tant que tour supplémentaire, je ré-utiliser la même chaîne à nouveau , en utilisant upour inverser le pointeur d'instruction. Ensuite, ce n’est qu’une arithmétique: l’idée centrale est de résumer toutes ces valeurs (ce qui est fait en utilisant kpour répéter l’ +opération).

GolfScript (16 bytes) [SAFE]

%%()*../1129n{}~

Production attendue:

-117345085515973157874551915956356303213327583847247840186528288852476459638212404362749

Source primaire:

n)~{.*911%(}./2%

Ruby, 17 ans ( fissuré) )

Aller pour quelque chose de vraiment court cette fois.

inprt N=2,*'~~~%'

Sortie:

2
2

Python, 69 caractères [ fissuré par grc ]

Brouillé:

((((((((((((())))))))))))),,,,accdddiiiiillmmnopprrrrrssssssttttttttu

Sortie:

1083

Celui-ci est juste un amusement sans danger :) Testé sur CPython 2.7.8, 3.3.2 et pour le plaisir de le faire PyPy3 2.3.1.

Explication

Utilise des fonctions intégrées str, dict, listpour construire une chaîne et applique ensuite mapavec ordpour convertir la chaîne à une liste de ints, qui sont ensuite summed.

Python, taille 56 ( fissuré )

Code

for i in "iprint()".join(([2,3,7,0,9,chr((-7+732^70)])))

Sortie

hi mom

Python 3, 70 caractères

Brouillé:

""(((())))****++++222222222;;;;;=======cccccccccceeeiinnpprrttxxxxxxxx

Sortie (99 caractères):

388626024960000000000026872002432000000000000676169243200000000000007317718780000000000000028820330

Mise à jour

Cela fait une semaine, alors plutôt que d'afficher la réponse, voici un indice:

Essayez de prendre la racine carrée du nombre et de travailler à partir de là

Pyth , 11

\\,,"$: Ndw

Sortie:

",input(),"

JavaScript, 94 fissuré par FireFly

alert(' '' '''((()))+++,,,,,,,,,,,,,000111111114444577888;;;;;======[[[]]]aaafhinorrrrvvvxx||)

Sortie

fun in the sun

Original

a=alert;v='';r=[1,7,8,14,11,8,14,10,0,5,14,4,7,8];for(x in r)v+=('h'+(1==0)+a)[r[x]]||'';a(v);

Ruby, 38 ans - fissuré par Martin Büttner

print(succ(downcase!))$$$..[[]]6e0<><_

Sortie:

u

Original:

$6.pincdwnca[]rescue$><<$!.to_s[((0))]

Python 3, taille 16 ( fissuré )

Code:

help tim__rolo__

Sortie (avec nouvelle ligne à la fin):

Hello world!

Perl - 47 ( fissuré par grc )

Code (il y a un espace là aussi)

 """"$$$$$$((()))**....///;;[[]]~==01finoprrstx

Sortie:

012345012345012345012345012345

Vous pouvez le lancer en ligne ici et ça marche sous strictet warnings.

Ruby, 33 ans - fissuré par l'utilisateur23013

enpsttux [[[]]]++\-\**????$$$$...

Sortie:

[*]

Original:

puts ?[+[*?*..?]][$$-$$]+?\\.next

Python2, 132 caractères

____        ,,,,:::''""""""""""((()))[[]]\\\0126aaaabcccceeeeeeeeeEffggiiiiiilllllmmmmnnnnnnooooopppppqqrrrrrrrrrssssStttttttuuvxxyy

Sortie (avec une nouvelle ligne):

chance

Version mise à jour, 96 caractères

Réponse à la version originale suggéré le execau lieu de compile+ eval, voici donc une version simplifiée:

____       :::''""(())[[]]\\\0126aaabcccceeeeeeeeEffiimmnnnnooopppqqrrrrrrrrrssStttttttuuxxxxyy

Mise à jour: fissuré

Entièrement fissuré par Alex Van Liew et KennyTM . Les solutions originales étaient (faites défiler à droite pour révéler le spoiler):

                                                                                                                                eval(compile('try: compile("from __future__ import braces","","single")\nexcept SyntaxError as q:\n\tprint q[0][6:12]',"","single"))
                                                                                                                                exec('try:exec("from __future__ import braces")\nexcept SyntaxError as q:\n\tprint q[0][6:12]')
                                                                                                                                The hint meant "Consider {}, which are not present in the source code".

Ruby, 29 [sûr]

J'essaie de voir à quel point je peux être bref en Ruby sans me faire craquer.

Code

paper view
otool
$()**,.8<<=>

Sortie

[0][0, 3][0, 3, 6][0, 3, 6, 9][0, 3, 6, 9, 12][0, 3, 6, 9, 12, 16][0, 3, 6, 9, 12, 16, 20]

Original

eval <<p*8 o=*o,$>.write(o) p

Explication

La première ligne crée un heredoc qui commence à la ligne suivante et est délimitée par la fin p, puis concatène la chaîne résultante à 8 reprises. Comme il se termine par une nouvelle ligne, cela crée effectivement une boucle. Le code en boucle attribue un tableau à la variable o, composé des éléments entre o.to_a(via le *raccourci), suivi de la sortie de $<.write(o), qui convertit est vide et écrit ne génère rien et retourne 0. Chaque tour suivant génère le tableau d'octets Les manches. L'utilisation d'un heredoc délimité par p crée des méthodes leurres pour la sortie , cela ne fonctionnera pas dans les caractères brouillés, car vous avez besoin du nombre de bytec.o en chaîne, l’imprime au format STDOUT et renvoie le nombre d’octets imprimés. Une variable affectée pour la première fois estnil à évaluer le côté droit, donc lors du premier passage*op et$><<

PHP, taille 49 [ Cracked by Martin Büttner ]

Code

sub(print2w, $+expect+$+one+$+str+$+in=$@~main$);

Sortie

{main}

MATLAB, 41 octets

Craqué par feersum

((((((snowy leopards can like magic))))))

Sortie

1

Perl, 36 ← fissuré par grc

Code

$$$()++..112279;;<<=__ffiinooprrrt{}

Sortie

perl

Testé ici

Haskell, 100 caractères (non valide, sortie trop longue)

Code

//Sup
tl=[]
while(syn==(+j)) tl+=b.a();
//(: #jquery :)\\
$("#jquery").on("click", j=>alert(j==m))

Sortie:

"\er\\e\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\"\\\\\\\\\\\\\"\\\\\\\

Original

(#)=(>);(//)=(++)
l=j.show
main=putStr.l.l$l"eer"
j[]="\\"
j(y:u)=let(q,c)=break(#y)u in y:j c//j q

J, 22 octets

Code

!%()1348:::bbceehorvxx

Sortie (97 caractères)

1226317306651180983274420265228191056569220222873505571155987454033425908908110103433163350999040

Je m'attends à ce que ce soit pratiquement impossible ...

CJam, 32 octets ( fissuré) )

Source brouillée

"Beware the Jabberwock, my son!"

Sortie

4074552392882954617076720538102062920

Pyth - 35 - Cracked

Dans l'esprit de @ MartinBüttner:

Code

"Programming Puzzles and Code Golf"

Sortie

4.459431618637297

Essayez de le décoder en ligne ici.

TinyMUSH 3.1 , 20

Brouillé:

(#ret,#3!#+#2i\2#,@)

Sortie:

3210

Python 3, longueur 110 [ fissuré par grc ]

Scrambled ( \ndénote une nouvelle ligne)

\n\n\n   ""((((())))),.......9::;===IOS[]__addeeegghiiiiiiiiijllmmnnoooooooppprrrrsssssssssstttttttttttuuuuuvwyyy

Sortie:

The better is Flat dense. break never of be do at never. If bad it honking

En voici un autre amusant - qui n'est pas censé être dur, mais qui est quelque chose d'inhabituel et de mystérieux. :)

Explication

Les mots au hasard sont tirés du zen de Python (PEP 20), qui est automatiquement imprimé via l'œuf de Pâques import this. Le passage est juste chaque neuvième mot, comme le suggère le 9::[]présent.
Pour extraire chaque neuvième mot sans imprimer automatiquement le passage lors de l'importation, nous redirigeons sys.stdoutvers a StringIO().

Javascript, 29 - Fissuré

Exécuter dans une console de navigateur Chrome

Code

23*47,(no,(.][j,i|i,j][.),on)

Sortie

181

Code d'origine

[,,,].join(3)|[,4,].join(7)*2