Remarque: ce défi est terminé. Les soumissions sont toujours les bienvenues mais ne peuvent pas gagner.

C'est le fil des flics. Le fil des voleurs va ici .

Ecrivez un code qui affiche le nombre entier 1. Si vous ajoutez, supprimez ou remplacez un seul caractère (de votre choix), le code doit générer le nombre entier 2. Changez un autre caractère (le même ou un autre) et le code devrait sortir 3. Continuez comme cela autant que vous le pouvez, mais au maximum jusqu'à 10. Les formats de sortie par défaut tels que ans = 1sont acceptés. Vous pouvez ignorer la sortie vers STDERR (ou l’équivalent).

Vous devez révéler la langue, le nombre d'octets de votre code initial, le nombre d'entiers pour lesquels cela fonctionne, ainsi qu'un nombre facultatif de caractères du code initial. Remarque: vous ne devez révéler aucun caractère, mais rappelez-vous que le fait de révéler des caractères peut compliquer la tâche des voleurs, qui doivent utiliser le même personnage dans la même position. Vous pouvez choisir le caractère que vous utilisez pour désigner les caractères non révélés (par exemple, le trait de soulignement), mais veillez à le spécifier.

Les policiers peuvent fournir le code non fissuré après une semaine et appeler la présentation "SAFE". La soumission gagnante sera la soumission la plus courte non fissurée produisant le nombre 10. Si aucune soumission non fissurée ne peut imprimer 10, le code le plus court produisant 9 gagnera, et ainsi de suite. Notez que les voleurs n'ont pas à apporter les mêmes modifications que vous et qu'ils ne doivent pas reproduire le code exact (à moins que vous ne révéliez tous les caractères). Ils ne doivent reproduire que la sortie.

Les soumissions postées après le 24 novembre sont les bienvenues mais ne sont pas éligibles (car il y aura probablement moins de cambrioleurs).

Exemple de poste:

Le post suivant est une soumission dans la langue MyLang, il a une longueur de 9 octets et fonctionne pour les numéros 1 à 8.

MyLang, 9 octets, 8 chiffres

Cette soumission fonctionne pour 1 - 8. caractères sont indiqués par Non Révélés un trait de soulignement: _.

abc____i

Classement

Clause de non-responsabilité: le classement n'est pas testé et les soumissions non fissurées peuvent ne pas apparaître dans la liste.

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><style>table th,table td{padding: 5px;}th{text-align: left;}.score{text-align: right;}table a{display: block;}.main{float: left;margin-right: 30px;}.main h3,.main div{margin: 5px;}.message{font-style: italic;}#api_error{color: red;font-weight: bold;margin: 5px;}</style> <script>QUESTION_ID=99546;var safe_list=[];var uncracked_list=[];var n=0;var bycreation=function(x,y){return (x[0][0]<y[0][0])-(x[0][0]>y[0][0]);};var byscore=function(x,y){return (x[0][1]>y[0][1])-(x[0][1]<y[0][1]);};function u(l,o){jQuery(l[1]).empty();l[0].sort(o);for(var i=0;i<l[0].length;i++) l[0][i][1].appendTo(l[1]);if(l[0].length==0) jQuery('<tr><td colspan="3" class="message">none yet.</td></tr>').appendTo(l[1]);}function m(s){if('error_message' in s) jQuery('#api_error').text('API Error: '+s.error_message);}function g(p){jQuery.getJSON('//api.stackexchange.com/2.2/questions/' + QUESTION_ID + '/answers?page=' + p + '&pagesize=100&order=desc&sort=creation&site=codegolf&filter=!.Fjs-H6J36w0DtV5A_ZMzR7bRqt1e', function(s){m(s);s.items.map(function(a){var he = jQuery('<div/>').html(a.body).children().first();he.find('strike').text('');var h = he.text();if (!/cracked/i.test(h) && (typeof a.comments == 'undefined' || a.comments.filter(function(b){var c = jQuery('<div/>').html(b.body);return /^cracked/i.test(c.text()) || c.find('a').filter(function(){return /cracked/i.test(jQuery(this).text())}).length > 0}).length == 0)){var m = /^\s*((?:[^,;(\s]|\s+[^-,;(\s])+).*(0.\d+)/.exec(h);var e = [[n++, m ? m[2]-0 : null], jQuery('<tr/>').append( jQuery('<td/>').append( jQuery('<a/>').text(m ? m[1] : h).attr('href', a.link)), jQuery('<td class="score"/>').text(m ? m[2] : '?'), jQuery('<td/>').append( jQuery('<a/>').text(a.owner.display_name).attr('href', a.owner.link)) )];if(/safe/i.test(h)) safe_list.push(e);else uncracked_list.push(e);}});if (s.items.length == 100) g(p + 1);else{var s=[[uncracked_list, '#uncracked'], [safe_list, '#safe']];for(var i=0;i<2;i++) u(s[i],byscore);jQuery('#uncracked_by_score').bind('click',function(){u(s[0],byscore);return false});jQuery('#uncracked_by_creation').bind('click',function(){u(s[0],bycreation);return false});}}).error(function(e){m(e.responseJSON);});}g(1);</script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/Sites/codegolf/all.css?v=7509797c03ea"><div id="api_error"></div><div class="main"><h3>Uncracked submissions</h3><table> <tr> <th>Language</th> <th class="score">Score</th> <th>User</th> </tr> <tbody id="uncracked"></tbody></table><div>Sort by: <a href="#" id="uncracked_by_score">score</a> <a href="#" id="uncracked_by_creation">creation</a></div></div><div class="main"><h3>Safe submissions</h3><table> <tr> <th>Language</th> <th class="score">Score</th> <th>User</th> </tr> <tbody id="safe"></tbody></table></div>

Hexagonie , 18 octets, 10 chiffres, SAFE

Cette soumission fonctionne pour 1 - 10. caractères sont indiqués par Non Révélés un trait de soulignement: _.

.__{_]5[$@.;=@$!!1

Vous pouvez essayer Hexagony en ligne ici.

Ma solution:

1:   .<[{8]5[$@.;=@$!!10
2:   .<[{8]5[$@);=@$!!10
3:   2<[{8]5[$@);=@$!!10
4:   3<[{8]5[$@);=@$!!10
5:   4<[{8]5[$@);=@$!!10
6:   5<[{8]5[$@);=@$!!10
6:   7<[{8]5[$@);=@$!!10
8:   7<[{8]5[$@);=@$!!10
9:   8<[{8]5[$@);=@$!!10
10:  9<[{8]5[$@);=@$!!10

Hex pour la sortie 1:

Essayez-le en ligne!

Full Hex:
  . < [ 
 { 8 ] 5
[ $ @ . ;
 = @ $ ! 
  ! 1 0

Important parts:
  . < .
 . 8 . 5
. $ @ . ;
 . . $ .
  . 1 .

1. Au <bord de la mémoire est 0, alors il tourne.
2. Les coups 1
3. Saute à 5
4. Saute par-dessus 8, mais s'inverse à <et récupère 8le chemin du retour.
5. Frappe à 5nouveau
6. Saute par dessus 1
7. Frappe le <à ce stade, la valeur de la mémoire est 1585 qui, mod 256, se trouve être ASCII1
8. Enfin imprime et quitte avec ;@.

Hex pour la sortie 2:

Essayez-le en ligne!

Important parts:
  . < .
 . 8 . 5
. $ @ ) ;
 . . $ .
  . 1 .

Cela suit le même chemin, mais sur le chemin du retour, il frappe un )qui incrémente le bord de la mémoire à 1586, ou 2.

Hex pour la sortie 3-9:

Essayez-le en ligne!

Important parts:
  2 < [
 . . ] .
. $ . ) .
 . @ . !
  . 1 .

1. Frappe le 2
2. Maintenant, le bord de la mémoire est positif quand il arrive à <, donc il diminue.
3. Le ]change le pointeur d'instruction, mais revient immédiatement avec[
4. ) incrémente à 3
5. ! Impressions 3
6. $est laissé par les deux premiers chiffres, nous sautons par-dessus la fin ( @)
7. 1 change le bord de la mémoire, mais cela n'a pas d'importance maintenant.
8. < reflète le pointeur en arrière.
9. Encore une fois, cela 1n’a pas d’importance, car nous avons mis @fin au programme.

Rétine , 2 octets, 10 chiffres, fissuré

_1

Fonctionne de 1 à 10, _est un personnage caché. Cela ne devrait pas être trop difficile, mais j'espère que cela fournira un casse-tête quelque peu intéressant. :)

Vous pouvez essayer Retina en ligne ici.

Octave, 55 octets, 10 chiffres, fissuré

(o__(O_o_(@(__o)o__-O}_)_(0<O,{_(_o_O-1)+1_@(_1}_)(__o_

_ est le personnage inconnu.

Solution

(o=@(O,o)(@(O,o)o{2-O}())(0<O,{@()o(O-1)+1,@()1}))(0,o)% puis en changeant le tout dernier 0à 1,2,3etc

Étant donné x, ceci calcule de manière récursive x+1. Il est principalement composé de deux fonctions anonymes. On fournit une ifdéclaration pour ancrer la récursivité:

if_ = @( boolean, outcomes) outcomes{ 2 - boolean}();

Il s’agit simplement d’abuser du fait qu’une valeur booléenne est évaluée à 0ou 1. Cette fonction accepte une valeur booléenne et un tableau de cellules de deux fonctions et évalue l'une ou l'autre de ces deux fonctions en fonction de la valeur booléenne. La deuxième partie est la récursion proprement

plus_one = @(n,f) if_(0<n ,{@()f(n-1)+1, @()1})

dite : Comme une fonction quelconque est anonyme, vous ne pouvez pas y accéder directement depuis itsefl. C'est pourquoi nous avons besoin d'un deuxième argumentfpremière. Ensuite, nous fournirons un descripteur à la fonction instelf en tant que second argument. Ainsi, une fonction finale ressemblerait à ceci:

plus_one_final = @(n)plus_one(n,plus_one);

Ainsi, dans cette notation, ma soumission devient:

(plus_one=@(n,f)(@(boolean,outcomes)outcomes{2-boolean}())(0<n,{@()f(n-1)+1,@()1}))(n,f)

J'ai posé une question sur les ancres de récursivité pour les fonctions anonymes dans MATLAB il y a quelque temps sur stackoverflow .

Python 2, 9 octets, 10 chiffres, fissuré

print 8/8

Aucun caractère caché. Pouvez-vous le casser sans forcer brute?

Perl, 12 octets, 10 chiffres, fissuré!

Les traits de soulignement représentent des caractères inconnus.

____;say__-9

Probablement assez facile, et cela ne me surprendrait pas s'il y avait plusieurs solutions. Pourtant, il pourrait être amusant de craquer.

(La solution envisagée était la même que la fissure. Il s’agit fondamentalement d’affecter 10 à une variable à quatre caractères, ce qui est étonnamment difficile en Perl; contrairement à de nombreuses langues de golf, il n’a pas de variable qui commence utilement à dix.)

Perl, 46 octets, 10 chiffres, coffre-fort

Le problème

__b_b_\__}_b_b_b_0_;
$b[0]=10;$b{0}=1;say$b[0]

Les problèmes plus courts ont tendance à être résolus rapidement, alors j'ai pensé en essayer un plus long. Les plus longs ont aussi tendance à se fissurée si les gens laissent assez d'écart pour se faufiler quelque chose comme méchant sayou exit, donc toutes les lacunes ici sont courtes. Les caractères cachés sont représentés en utilisant _.

Ma solution

sub b{\@_}*b=b$b{0};
$b[0]=10;$b{0}=1;say$b[0]

Pour imprimer jusqu'à 2, 3, etc. jusqu'à 9, continuez à modifier le numéro attribué à $b{0} la deuxième ligne (c'est $b{0}=2-à- dire $b{0}=3, etc.). Le programme pour 9 ressemble à ceci:

sub b{\@_}*b=b$b{0};
$b[0]=10;$b{0}=9;say$b[0]

Ensuite, pour produire 10, commentez la première ligne en y ajoutant un #caractère.

Explication

La première chose à noter est que la solution ne se joue pas vraiment, à part la suppression des espaces: si nous l'établissons avec des espaces plus lisibles, nous obtenons ceci:

sub b { \@_ }
*b = b $b{0};
$b[0] = 10;
$b{0} = 1;
say $b[0];

Normalement, lorsque vous accédez aux arguments d'un sous-programme dans Perl, vous le faites en les copiant hors de @_. Il y a une bonne raison à cela: @_alias les arguments du sous-programme donné (ainsi, par exemple, (sub { $_[0] = 3 })->($x)sera assigné à $x), quelque chose qui n'est normalement pas souhaitable.

Bien que cela @_puisse sembler magique, il utilise en fait simplement une fonctionnalité standard des internes de Perl (qui est facilement disponible auprès de XS mais @_n’apparaît que dans quelques cas étranges en Perl pur, tel que lui-même): un tableau ne stocke pas directement ses éléments , mais plutôt par référence. Ainsi, lorsque nous appelons bdans la deuxième ligne ci-dessous, Perl génère un tableau (l'appelant @_) dont le premier élément est une référence au même stockage que celui $b{0}utilisé. (Les valeurs de hachage sont également stockées par référence; $ _ [0] et $ b {0} font référence au même stockage à ce stade.) Parce @_que rien de spécial ne se fait du point de vue des internes, nous pouvons prendre une référence comme avec tout autre tableau, il survit au sous-programme défini dans.

Les variables Perl font également référence au stockage de données par référence. Il y a longtemps, les gens utilisaient le code comme *x = *y;définir $xun alias $y(en leur faisant référence à la même chose), de même @xqu'un alias @y, %xun alias %y, etc. Cela brise plutôt l'invariant selon lequel les variables portant des noms similaires ne doivent pas nécessairement agir de la même manière, si bien que Perl moderne fournit une alternative; l'affectation d'une référence à un typeglob remplace uniquement la variable qui correspond au type de la référence (de même *x = \%y, alias %xpointerait sur le même stockage que, %ytout en laissant, par exemple, $xseul). Cette syntaxe ne se soucie pas de savoir si le stockage auquel vous appelez un alias a un nom, donc quand nous assignons la valeur de retour deb(qui est une référence de tableau qui maintient le tableau précédemment appelé @_vivant) *b, ce qui se produit @best modifié pour se transformer en alias la liste d'arguments à l'appel de b(tout en laissant %binchangé). Cela signifie, notamment, que $b[0]et $b{0}maintenant pointent vers le même stockage, et l' affectation à l' un sera donc changer l'autre. Tout est désormais parfaitement simple.

La documentation Perl ne parle pas vraiment de ce genre de détail, donc je ne suis pas surpris que quiconque ait eu le crack; La nature du fait @_de ne pas être tout à fait comme les autres tableaux n'est pas vraiment mise en avant, et la plupart des styles de codage visent à minimiser les effets que cela a plutôt que de les amplifier.

JavaScript, 30 octets, 10 chiffres, fissuré

alert(Array(_)________.length)

Cela ne devrait pas être trop difficile, mais j'espère que c'est assez difficile à relever. :) Les personnages non révélés sont marqués avec _.

Perl, 14 octets, 10 chiffres, fissuré

say_!"___"%""_

Fonctionne de 1 à 10. _sont des caractères cachés.

Je pense que cela ne devrait pas être trop difficile à résoudre. J'ai un disque plus dur, pour 22 octets, je le posterai si celui-ci est fissuré.

say"!"=~y"%""c

Et remplacer "!"par une chaîne de la longueur du numéro que vous souhaitez imprimer, par exemple !, !!, !!!, etc.

Cependant, ais523 a trouvé un autre moyen:

say"!"+1#"%""r

JavaScript, 22 octets, 10 chiffres, fissuré

Probablement assez facile à craquer.

alert(__14_337__xc_de)

_ être un personnage caché

Octave, 17 octets, 10 chiffres, fissuré

_od(3_13_13_7_1_)

Solution originale

mod(3*1361357,10)
...
mod(3*1361357,17)
mod(3*1361397,17)
mod(9*1361397,17)

_ est le personnage caché.

Gelée , 7 octets , 10 chiffres, fissuré

“1‘ỌȮḊ‘

Pas de joker.

La fissure réalisée (pour utiliser un eval avec un argument) était, comme beaucoup semblent être dans ce fil, pas le prévu.

La fissure prévue était:

“1‘ỌȮḊ‘ - (prints 1)
“1‘     - code page index list of characters "1": [49]
   Ọ    - cast to ordinals: ['1']
    Ȯ   - print (with no line feed) and return input: effectively prints "1"
        -     (but if left at this would then implicitly print another "1")
     Ḋ  - dequeue: []
      ‘ - increment (vectorises): []
        - implicit print: prints ""

“1‘ỌŒḊ‘ - (prints 2)
“1‘Ọ    - as above: ['1']
    ŒḊ  - depth: 1
      ‘ - increment: 2
        - implicit print: prints "2"

“1‘ỌŒḊ‘‘ - (prints 3)
“1‘ỌŒḊ‘  - as above: 2
       ‘ - increment: 3
         - implicit print: prints "3"

... keep adding an increment operator to print 4 - 10.

Befunge-93, 11 octets, 10 chiffres et plus, Cracked

Cette soumission fonctionne pendant au moins 1 à 10. Les caractères non révélés sont signalés par □.

□□5:**-□-.@

Essayez-le en ligne

Je dois dire que j’ai été impressionné par le fait que deux personnes ont pu proposer des solutions indépendantes à cet égard, mais ce n’était pas ce à quoi je s’attendais. Bien que Martin soit arrivé le premier, je donne la "victoire" à Sp3000 car sa solution est plus portable.

C’était bien ma solution:

g45:**-2-.@
g45:**-1-.@
g45:**-1\.@
g45:**-1\+.@
g45:**-2\+.@
...
g45:**-7\+.@

Etant donné qu’un underflow de pile dans Befunge est interprété comme égal à 0, il gsuffit alors que 0,0 renvoie la valeur ASCII de 'g', à savoir 103. 45:**-soustrait 100 en vous donnant 3. Ensuite, 2-vous donne 1.

Pour la troisième itération, la -soustraction ) est changé en une \instruction (swap), ainsi le 3 devient l'entrée de pile la plus haute. Et dans la quatrième itération, une +instruction (ajouter) est insérée, ajoutant ainsi le 3 au 1 donnant 4.

R, 21 octets, 10 chiffres fissurés

__i___________i______

Fonctionne pour 10 numéros. _est un personnage caché.

Solution originale:

which(letters%in%"a")
which(letters%in%"b")
etc.

Ruby, 16 octets, 10 chiffres, fissuré par xsot

x=##/=#%#
)
###x

# est n'importe quel personnage.

Octave, 32 octets, 10 chiffres. Fissuré

_n_(isprime(floor(s____i__ i____

_ est un personnage caché.

Vous pouvez essayer Octave en ligne ici .

Solution originale:

1: nnz(isprime(floor(sqrt(i):pi')))

2: nnz(isprime(floor('sqrt(i):pi')))

3: nnz(isprime(floor('sqrt(i):pia')))

4: nnz(isprime(floor('sqrt(i):piaa')))

...

Octave, 17 octets, 10 chiffres, fissuré

_i_(__i__(2_5_))

Les personnages non révélés sont marqués avec _.

Solution envisagée:

    fix(asind(2/59))
    fix(asind(3/59))
    fix(asind(4/59))
    fix(asind(5/59))
    fix(asind(6/59))
    fix(asind(7/59))
    fix(asind(8/59))
    fix(asind(9/59))
    fix(asind(9/55))
    fix(asind(9/50))

Octave, 19 octets, 10 numéros, fissuré

__sca__1_)___'-_6_'

_ est le personnage caché.

Solution envisagée:

pascal (10) ('a'-96)'

05AB1E , 5 octets, 10 chiffres, fissuré!

Pas très dur, mais amusant :)

_[==_

_est un personnage aléatoire. Utilise le codage CP-1252 . Essayez-le en ligne!

05AB1E , 6 octets, 10 nombres, fissuré

Essayez 2, cette fois sans la chaîne à trois caractères: p.

_ [==_

_est un personnage aléatoire. Utilise le codage CP-1252 . Essayez-le en ligne!

JavaScript, 22 octets, 10 chiffres, fissuré

alert(0_6_4_>_0_2_0_7)

_ est le personnage caché.

Astuce sur la solution envisagée

Le caractère à modifier pour générer tous les nombres est toujours le même.

JavaScript 21 octets, 10 numéros fissurés

alert(b_oa_"3____1"))

Les personnages non révélés sont marqués avec _

Fissuré

Ma version:

alert(btoa|"3"&("1"))
alert(btoa|"3"^("1"))
alert(btoa|"3"^("0"))
alert(btoa|"3"^("7"))
alert(btoa|"2"^("7"))
alert(btoa|"1"^("7"))
alert(btoa|"0"^("7"))
alert(btoa|"0"^("8"))
alert(btoa|"0"^("8"))
alert(btoa|"2"^("8"))

Python 3, 19 octets, 10 nombres, fissuré

print(??bin()?????)

Les personnages non révélés sont marqués avec ?. Testé en Python 3.5.2.

Python 3, 16 octets, 10 chiffres, fissuré

print(?%??f?r?t)

Les personnages non révélés sont marqués avec ?. C'est probablement un peu facile puisqu'il n'y a que cinq points d'interrogation, mais j'espère que ce sera amusant.

C #, 90 octets, 10 nombres, fissuré

using ______________________________________________;class C{static void Main(){_______;}}

Honnêtement, je ne sais pas à quel point c'est difficile à résoudre.

Edit: Oups, erreur de transcription. Un _trop peu après using.

Maintenant craqué par Hedi , qui a trouvé la solution voulue (à moins du nom de la classe).

JavaScript 33 octets, 10 numéros craqués x2

Oups je poste posté ma ligne pour générer 10 Qui Hedi craqué comme si c'était pour 1

alert(_to__"_Xc0__0_B6____Zp=="))

Version destinée à poster pour générer 1

alert(_to__"_Xc0__0_Bf____Zp=="))

Les personnages non révélés sont marqués avec _

alert(btoa|"0Xc0"-0xBf|!("Zp=="))
alert(btoa|"0Xc0"-0xBe|!("Zp=="))
alert(btoa|"0Xc0"-0xBd|!("Zp=="))
alert(btoa|"0Xc0"-0xBc|!("Zp=="))
alert(btoa|"0Xc0"-0xBb|!("Zp=="))
alert(btoa|"0Xc0"-0xBa|!("Zp=="))
alert(btoa|"0Xc0"-0xB9|!("Zp=="))
alert(btoa|"0Xc0"-0xB8|!("Zp=="))
alert(btoa|"0Xc0"-0xB7|!("Zp=="))
alert(btoa|"0Xc0"-0xB6|!("Zp=="))

Python, plus de 10 chiffres, 61 octets, fissuré!

Voici le code que j'ai posté:

try:x
except:print(__import__('sys').??c??n??()[????b????e???

Le code original était:

try:x
except:print(__import__('sys').exc_info()[2].tb_lineno)

Fondamentalement, il génère une erreur ('x' is not defined ), puis affiche la ligne sur laquelle l'erreur a été trouvée. Donc, continuez à ajouter des nouvelles lignes au début pour incrémenter le nombre.

Je savais que ce ne serait pas difficile à résoudre - je voulais juste une façon amusante d'imprimer des nombres - mais je ne m'attendais pas à ce que Sp3000 le reçoive si vite, c'est du talent professionnel!

05AB1E, 11 octets, fissuré!

3628801__0_

Fonctionne de 1-10. _est un personnage caché.

Solution envisagée:

3628801R¬0+ # 1
3628801R¬1+ # 2
3628801R¬2+ # 3
3628801R¬3+ # 4
3628801R¬4+ # 5
3628801R¬5+ # 6
3628801R¬6+ # 7
3628801R¬7+ # 8
3628801R¬8+ # 9
3628801R¬9+ # 10

Octave, 24 octets, 9 chiffres, fissuré

_a__repmat(__one___,__)_

_ est un personnage caché.

(Inspiré par le défi de @ LuisMendo .)

JavaScript, 9 octets, 10 chiffres, fissuré

alert(__)

_ est le personnage caché.

Octave, 25 octets, 9 chiffres. Fissuré

__a__repmat(__one___,__)_

_ est un personnage caché.