Ceci est le fil des flics. Le fil des voleurs va ici .

Écrivez un programme ou une fonction composé uniquement de caractères ASCII imprimables (à l'exclusion des tabulations et des sauts de ligne) qui génère au moins 5 caractères ASCII imprimables dans l'ordre croissant (de l'espace au tilde / 32 à 126). Les caractères peuvent être émis plusieurs fois, tant qu'ils sont adjacents les uns aux autres. Une seule nouvelle ligne de fin est acceptée. Vous devez fournir la sortie complète, et pour chaque 6 caractères de votre code, vous devez fournir un caractère dans votre code, à la position où il apparaît. Si votre code contient 5 caractères ou moins, vous ne devez révéler que la longueur. Vous ne devez pas révéler plus d'un caractère pour 6 dans votre code.

Donc, si votre code alphaprintersort l'alphabet de az, alors vous devez révéler 2 caractères de votre code (utilisez le soulignement pour les autres), par exemple:

al__________  // or
__p__p______  // or
__________er

Règles / spécifications:

• Vous ne pouvez pas ajouter d'espaces blancs à la fin qui n'ont pas de fonction.
• Vous ne pouvez pas utiliser de commentaires (mais les voleurs peuvent utiliser des commentaires lors du crack du code)
• Les primitives cryptographiques intégrées (y compris tout rng, chiffrement, déchiffrement et hachage) ne sont pas autorisées.
• Dans les langues où la sortie par défaut est comme dans MATLAB:, ans =alors cela est accepté, tant qu'il est clairement indiqué et montré qu'il ans =est sorti. Il convient également d'indiquer clairement si cela fait partie de la "production ascendante" ou non.
• La sortie doit être déterministe
• L'utilisation d'une langue non libre n'est pas acceptée
• La sortie ne doit pas nécessairement être composée de caractères consécutifs. Les deux abcdeet abcdgsont des sorties valides.
• Les caractères n'ont pas besoin d'être distincts tant que la sortie contient au moins 5 caractères. aaaaaet aaaccsont valides.
• Les réponses qui supposent un environnement REPL ne sont pas considérées comme des programmes ou des fonctions valides et ne sont donc pas autorisées.
• STDERR n'est pas considéré comme une sortie valide, mais les données peuvent être écrites dans STDERR.

Si les caractères révélés sont des traits de soulignement, vous devez l'identifier comme indiqué ci-dessous. Dans ce cas, les deuxième et sixième caractères sont soulignés, tandis que les autres sont inconnus.

_____________
 |   |

Remarque: Les voleurs n'ont qu'à trouver un code qui produit la même sortie. La langue, la longueur de la solution des voleurs et la position des personnages révélés doivent également correspondre.

Votre score est le nombre de caractères dans votre code. Le gagnant sera la soumission avec le score le plus bas qui n'a pas été cracké en 7 jours. Seules les soumissions publiées en 2015 (UTC) sont éligibles pour la victoire. Les soumissions postées plus tard sont les bienvenues, mais ne peuvent pas gagner.

Afin de réclamer le gain, vous devez révéler le code complet (après 7 jours).

Votre message doit être formaté comme ceci (nn est le nombre de caractères):

Langue, nn caractères

Sortie:

abcdefghijklmnopqrstuvwxyz

Code (12 caractères):

al__________

Si le code est cracké, insérez [Cracked] (lien vers le cracker) dans l'en-tête. Si la soumission est sûre, insérez «Sûr» dans l'en-tête et révélez le code complet dans votre réponse. Seules les réponses qui ont révélé le code complet seront éligibles pour le gain.

Hexagonie , 8 caractères, coffre-fort

_______.

impressions

123456

Vous pouvez essayer Hexagony en ligne

Solution

`&)!."@.

Il `s'agit simplement d'une mauvaise direction pour donner au code l'impression qu'il nécessite une longueur de côté 3. À moins que l'interpréteur ne soit exécuté avec -dle backtick, il est simplement supprimé du code source avant de déterminer la disposition. Ensuite, le code s'inscrit dans la longueur latérale 2:

 & )
! . "
 @ .

Cela déplace le pointeur de mémoire (MP) autour d'un hexagone de la grille de mémoire, tout en copiant la valeur sur le bord suivant, en l'incrémentant et en l'imprimant.

Voici à quoi ressemble la grille de mémoire, le MP commençant la position marquée:

Initialement, tous les bords sont nuls. Le premier &est un no-op, mais )incrémente le bord et !imprime le 1. Puis "se déplace vers la gauche (le bord marqué 2 ). Là, &copie une valeur. Puisque le bord est actuellement nul, le voisin gauche (dans le sens du MP) sera copié qui est celui que 1nous venons d'imprimer. )l'incrémente, !imprime le 2. Cela continue tant que nous visitons de nouveaux bords et que nous imprimons tous les chiffres jusqu'à 6. Lorsque nous atteignons le bord sur lequel nous avons commencé, &copiera le bon voisin à la place (car la valeur du bord est positive), de sorte que le bord redevient 0et le flux de contrôle passe à la dernière ligne, où@ termine le programme.

Essayez-le en ligne.

Perl, 46 caractères (sûr)

Sortie:

((()))*++,---../00011123445556667779::;;<<==??@@AAACEFGHHHIKKMMNOOOPPQQQRRSSSVWXXYY[[[\]]]^^^```aaeeffggghjjjnpppqqrttuwxxyzz{{{

Code:

print _______________________________________;

J'ai réussi à supprimer l'original en l'espace d'une semaine, mais je pense que c'est vrai:

print chr()x(($i=($i*41+7)%97)&3)for(40..123);

Brainfuck, 48 personnages, cracké par Mitch Schwartz

J'ai fait celui-ci pour les voleurs. Ce ne sera certainement pas la soumission gagnante :)

____[_____[_______]__]___[___________]___[_____]

Cela produit:

ABCDEFGHIJKLMNOPQRSTUVWXYZ

Solution:

++++[>++++[>++++<-]<-]+++[>++++++++<-]>++[>+.<-]

Je l'ai testé ici .

Astuce: N'essayez pas de trouver des programmes générés par des générateurs en ligne haha. Cela a été écrit à la main et ne peut être résolu que par une pensée logique :)

CJam, 13 caractères

_____________
  ||

impressions

7LLMYahnsuv

Vous pouvez essayer CJam en ligne.

Solution

{`__Jf^er$}_~

Je pensais que baser un flic sur une quine généralisée était assez intelligent et nouveau. Au moment où j'ai posté cela, je l'ai réalisé __et je suis ercomplètement inutile, c'est pourquoi j'ai posté le flic CJam de 8 octets pour un score plus compétitif. Pietu l'a craqué assez rapidement, donc j'avais peur qu'il le comprenne aussi. Je suppose que la translittération de caractères inutilement alambiquée l'a sauvé.

Quoi qu'il en soit, le code prend ses propres caractères (sauf le _~), XORs chacun avec 19 pour obscurcissement puis les trie.

Ce flic m'a conduit à la "découverte" du xorting , bien que je ne l'utilise pas ici (et il serait probablement presque impossible de l'utiliser avec une courte quine généralisée).

3SP bruyant , 89 caractères (sûr)

0 _____________________________ _ _ _ _ _ _ _ _ _ __2_2__________________________________

Programme original:

0 0 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 0 3 2 2 2 2 0 3 0 1

Ce programme imprime

 !"#$$

(notez l'espace principal), et rien d'autre!

Explication (* n fait référence à la nième cellule en mémoire):

0 0 0                                Increment *0 to 3 (via the 0s in *0, *1, and *2)
2 (32 times)                         Increment *3 to 32 (via the 0 in *2 and the 3 in *0)
                                      (Note that *3 mod 256 is the character that prints)
0                                    Increment *32 (via the 3 in *0 and the 32 in *3)
3                                    Increment *1 (via the 32 in *3 and the 1 in *32)
                                      (Note that printing is on when *1 mod 2 is 1,
                                       which means " " prints right here)
2 (4 times)                          Increment *3 to 36 (printing '!"#$')
0                                    Increment *36 (via *3) (printing "$" again)
3                                    Increment *1 to 2 (via *36) (printing turns off)
0                                    Increment *36 to 2 (via *3)
1                                    Increment *0 to 4 (via *2)

Les deux dernières commandes s'avèrent suffisantes pour empêcher 1 d'être incrémenté à nouveau lors des passages ultérieurs du programme, ce qui signifie que rien ne sera plus imprimé, bien qu'il continuera à définir toutes les adresses mémoire de * 36 à la valeur 36 pour toujours .

JavaScript (ES6), 60 caractères, fissuré par l'utilisateur 81655

Pas prometteur de gagner, mais j'espère que c'est amusant de craquer:

e_e_______a__a____e___e________e__o___________o______o______

Il s'agit d'une fonction qui renvoie:

    :ERacddeeeeeeffiinnnoorrrrst
^^^^ -> 4 whitespaces

modifier

user81655 l'a craqué caractère par caractère:

e=e=>{try{a}catch(e){return[...e.toString()].sort().join``}}

Matlab Octave, 27 caractères, coffre-fort

Défi

Concernant les nouvelles restrictions de langue: Il fonctionne également dans Octave.

____________3_3___4_3______

Sortie (en octave): ( ans =ne fait pas partie de la sortie, le premier caractère de la sortie est ")

ans = """""""""""""""""""""""""""""""""""""""""""########$$$$$$%%%%&&&&'''(()))**++,,-../001223456789:;<=>?@BCDFGHJKMNPRTUWY[]_acehjloq

Sortie (dans Matlab): ( ans = \n\nne fait pas partie de la sortie, la sortie n'est que la dernière ligne)

ans =

"""""""""""""""""""""""""""""""""""""""""""########$$$$$$%%%%&&&&'''(()))**++,,-../001223456789:;<=>?@BCDFGHJKMNPRTUWY[]_acehjloq

Solution

[fix((0:.07/3:3).^4+34),'']

Nous examinons essentiellement cette fonction, convertie en valeurs ASCII.

R, 60 octets, fissuré par plannapus

Sortie:

0123456789ABCDEFGHTUVWXYZdefghijklmnopqrstuvw

Code:

___(_(_:_____________]_____________6]_______s_4_____,___=___

Je pense que ce ne sera pas si difficile. Nous verrons.

Jolf , 27 personnages, fissuré par Adnan

________W___________--_____
                         |

impressions

abcdefghijklmnopqrst

Interprète .

Code d'origine:

on*2toHEWn)oH+H `pl$--$n}_H
on                          set n
  *2t                        to twenty
     oHE                    set H to the empty string
        Wn)                 while(n){
           oH+H             append to H
                `pl$--$n     get the nth character of the alphabet, decrement n before
                        }   }
                         _H print H reversed

Félicitations à Adnan! Tu me fais peur.

Ici, vous pouvez tester votre soumission, pour voir combien de caractères doivent être supprimés.

setInterval(function(){r=document.querySelector("textarea").value;document.getElementById("output").innerHTML=r.length/6-r.split("").filter(function(x){return x=="_"}).length|0},20)

*{font-family:Consolas,monospace}textarea{width:100%;resize:none;height:auto;min-height:1.2em;}b{color:red;}

<textarea>Example Program</textarea><div>You must reveal <b id="output">n</b> characters.</div>

Fortran, 45 caractères, coffre-fort

Sortie complète:

 !"$)0<Ka|

Le chat a tenté de le casser ici

Code (45 caractères):

pr_gr_m____________________/___3____________

Code du programme:

program t;print*,(char(i**3/8+33),i=1,9);end

PHP, 46 caractères, sûr

La source:

for(_______________________=________________);

Produit une chaîne de 84 caractères:

!!"#$%&'()*+,-./0123456789::;<=>?@AABCDEEFGHIIJKLLMNNOPPQRRSTTUUVWWXXYYZZ[[\\]]^^__`

Allusion

Qu'est-ce que tu as dit? Ma cousine est impliquée?

Code révélé

Cette méthode est relativement simple car elle imprime jusqu'à 64 caractères à partir de chr(32). La partie obscurcissante est que l'itérateur in'est pas incrémenté linéairement. Il est incrémenté de sa propre valeur de cosinus , ce qui entraînera des caractères répétés et manquants.

for(;$i<64;)echo chr(32+$i+=cos(deg2rad($i)));
for(_______________________=________________);

CJam, 8 octets, fissuré par Pietu1998

__:_____

impressions

%*;a|~

Vous pouvez essayer CJam en ligne .

05AB1E , 13 caractères, craqué par la quintopie

Je suis un idiot. J'ai oublié d'implémenter la fonction de puissance (-_-｡). Voici le code obscurci:

__D____<_____

Mon code d'origine était:

99DF2}r<F*}bR

Explication:

99DF2}r<F*}bR

99            # Pushes 99
  D           # Duplicates the top item
   F }        # Creates a for loop: For N in range(0, 99)
    2         # Pushes 2 (this will be done 99 times)
      r       # Reverses the stack
       <      # Decrement on the last item
        F }   # Creates a for loop: For N in range(0, 98)
         *    # Multiplies the last two item of the stack, which now looks like
              # [2, 2, 2, 2, 2, 2, 2, 2, ...]. Basically we're calculating 2^99
           b  # Converts the last item to binary
            R # Reverses the last item of the stack

Cela produira:

0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Oui, c'est 99 zéros suivis d'un 1.

Remarque , j'ai une fonction d'alimentation implémentée en ce moment. Cela pourrait donc se faire en six octets:

Y99mbR

Python 3.4, 127 caractères

Ceci est mon premier poste de cuivre. Je pense / j'espère que ce n'est pas trop difficile ou trop évident.

Le code obscurci:

_______inspect__________________getsource_____________________________________________print__________c*s_______________________

crée cette sortie (il y a 5 espaces au début; la longueur totale est de 7740 caractères):

     """"""""""""(((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))**********************...................................................................................................................;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;==============================[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppprrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Pyth, 17 caractères, craqué par Pietu1998

Sortie:

""''''''''''''''''''''0000000000111111111122222222223333333333XXXXXXXXXX[[[[[[]]]]]]

Code:

___________#____1

Ma solution:

Sjkm^dT%"'%#X"291

La solution de Pietu1998:

S`u]G6*T`t"#X0231

Malbolge, 254 personnages, cracké par Adnan

Code:

_____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ __

Sortie:

`AB\cd`

J'ai un peu triché en mettant un espace pour chaque 6ème personnage. Tant pis...

Code cracké d'Adnan:

('&%: ^"!65 4Xzyx w4-Qs rpo'K mlk"' ~Dfdc ba}v< ::8[Z XnVlq }0/mO ,*MbK JH^6# 4`C|0 ?U=Sw uPsaq L4on2 Mjjh, ged)c '<$$p ]!};Y WiVxS eRQ>= ).K]l Ij"Fh gfedc b,=;z L\q%H X3E2C /ng-k N*KJI 8%6#D ~2^Ai >g<<d tUr`6 oJ"!1 /|{CU f)d>b <A_^! \};Yj yUxTS dtsr` ML

Le code d'origine:

bCBA@ ?>=<; :9876 54321 0/.-, +*)(' &%$#" !~}|{ zyxwv utsrq ponml kjihg fedcb a`_^] \[ZYX WVUTS RQPON MLKJI HGFED CBA@? >=<;: 9y165 43210 /.-,+ *)('& }C#"! ~wv<z \xwvu tsrqp onmlk jihgf e^$ba `_^W\ UyYXW VUTSR QPONM FKJIH GFEDC BA@9] =<;:9 27654 3210) M:

J'ai de nouveau triché en utilisant un générateur text-to-Malbolge pour ce code.

Mathematica 10.1, 98 caractères, sûr

La sortie est ici . La sortie entière a 838 316 caractères et une nouvelle ligne de fin.

Code:

Print[""<>Chara__________________________________________________________________________________]

Oui, cela doit être exécuté dans 10.1. _(indice) Le programme original:

Print[""<>Characters@ToCamelCase@ExampleData@{"Text","DonQuixoteIEnglish"}~SortBy~ToCharacterCode]

MATL , 8 caractères, sûr

Une version stable du compilateur fonctionnant dans Octave devrait bientôt arriver. Pendant ce temps, cette validation GitHub fonctionne , et en particulier exécute le code d'origine qui produit la sortie indiquée

Cette soumission compte comme publiée le 28 décembre 2015, 15:30 UTC

Sortie:

$**0016688??@HHQ

Code (8 caractères):

_:______

Solution

6:9tX*Sc

Ce qu'il fait:

6:9          % numeric vector [6 7 8 9]
t            % duplicate
X*           % Kronecker tensor product
S            % sort in ascending order 
c            % convert to char. Implicit display

Labyrinthe , 5 octets, fissuré par Adnan

_____

impressions

000000

Mon code d'origine était:

<!!@ 

Notez l'espace de fin.

Je suppose que j'aurais dû opter pour plus de personnages et en révéler un !, car la solution d'Adnan ne se développe que linéairement lors de l'ajout de plus !, tandis que la mienne croît de manière quadratique.

PHP, 28 caractères

<?=________________________;

Sort la chaîne

abcdefghijklmnopqrstuvwxyz

ES6, 17 caractères, craqué par Cᴏɴᴏʀ O'Bʀɪᴇɴ

__=____=_________

Il s'agit d'une fonction qui renverra la chaîne

11233

JavaScript, 83 caractères, cracké par Martin Büttner

Sortie

Hi~~~

Code

_=____r____=u____=__s__=_________=__________________u_______A__________e______"_~_"

La sortie est dans la console JS d'un navigateur comme Chrome / Firefox.
Code d'origine (qui peut être invalide):

q=w=e=r=t=y=u=i=o=p=s=d=f=g=h=j=k=l=z=x=c=v=b=n=m="Huh"[0]+"Alarms in here"[7]+"~~~"

Pyth, 6 caractères, craqué par Pietu1998

Code:

S_____

Sortie:

.0113345678888999

Vous pouvez essayer Pyth ici

JavaScript ES6, 134 caractères

Huh boy, c'était amusant. Bonne chance!

_=_=_____l____.______.________(___}__;___=______ru____"_____+_[________]______!____]__[_________e________.__U_________)__________\_____

Les sorties:

((((((()))))))+...000000000000000000002233=>AAAAAAAAAAABBBBBCCCCCCCCCCCCCCCCCCDDDDDDDEEEEEEEEEEEEEEEEEEEFFFFFFFGHIIIIIIIIIIIIIIIIJJJJLLMMNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOPRRRRRRRSSSSTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUVVVVVVXXY[[[[[[[[]]]]]]]]````ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiinnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu{{{{{{}}}}}}

CJam, 12 caractères, fissuré par jimmy23013

Sortie

#$%&'()*+,-./:;<=>?@[\]^_`

Code

_:____#_____

Sérieusement , 7 octets, fissuré par Martin Büttner

______S

Sortie:

   deeknnoow

Cela ne devrait pas être trop difficile, même si le résultat n'est pas exactement ce que vous attendez.

Python 3, 58 caractères, cracké par Mitch Schwartz

Code:

______________print(_______(_______________________)_____)

import string; print (''. join (sorted (string.printable)) [5:])

Sortie:

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Befunge, 11 personnages, craquelé (en funge-98) par MegaTom

Sortie:

1223788

Code obscurci:

________.__

Une seule ligne, car les règles interdisent les sauts de ligne. Testé à l'aide de http://www.quirkster.com/iano/js/befunge.html .

Edit: Ceci est légalement fissuré car je n'ai pas spécifié de version, mais notez qu'il existe toujours une solution Befunge-93.

Perl 5, 30 octets, craqué par Adnan

Code:

print_________________________

Sortie:

9:;@AFGHLMNRSTYZ_`a

Fissuré:

Adnan a trouvé une fissure triviale : évidemment, je n'ai pas assez bien réfléchi à ce puzzle. J'en ai composé un autre à la place.

Python 2, 62 caractères, fissuré par Adnan

______________________________________________________________
         | |   ||                  |  |  ||

Cela ressemble un peu à une table.

Cela génère la chaîne abcde.

Code d'Adnan:

print "ab_c_de___".replace("_","")#___________________________

Mon code:

f=lamda _,__,___:"abcde"+'f'*sum(_,__,___)*000;print f(1,2,3);