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

Écrivez un code qui a le même nombre d'octets que le message du policier et où les caractères révélés sont identiques. Le code doit produire 1dans son état initial et produire les nombres 2, 3 ..lorsque des modifications uniques sont effectuées.

Le vainqueur sera le voleur qui a le plus craqué les posts.

Exemple de message:

MyLang, 9 octets, 8 chiffres (y compris le lien pour répondre), nom d'utilisateur de Cop.

Code d'origine:

abc1efghi

Code qui produit 1 - 8:

1: abc1efghi
2: abc2efghi
3: abc2efghij
4: kbc2efghij
5: kbc23fghij
6: kbc23fghi
7: kbc63fghi
8: kbc63fhi

Des explications sont encouragées. Le format exact de la publication du voleur est facultatif.

Retina, 2 octets, 10 chiffres, par Martin Ender .

Code d'origine:

1

Cela remplace l'entrée vide par le chiffre 1.

Code qui produit 1 - 10 (montrant les nouvelles lignes comme \npour plus de commodité):

1 : \n1
2 : \n1\n
3 : \n11\n
4 : \n111\n
5 : \n1111\n
6 : \n11111\n
7 : \n111111\n
8 : \n1111111\n
9 : \n11111111\n
10: \n111111111\n

Pour 2 et plus, nous comptons le nombre de chaînes vides dans l'étape précédente. Pour 2, il y a une chaîne vide avant et après le 1. Pour 3, il y a une chaîne vide avant celles, entre celles et après celles. Cela fonctionne jusqu'à 10.

Essayez-le en ligne

Perl, 12 octets, 10 chiffres, par ais523

Code d'origine:

____;say__-9

Code qui produit 1 - 10:

wait;say$!-9
wait;say$!-8
wait;say$!-7
wait;say$!-6
wait;say$!-5
wait;say$!-4
wait;say$!-3
wait;say$!-2
wait;say$!-1
wait;say$!-0

Explication:

wait;         # waits for a child process to end (there is no child so it just returns)
     say      # put the following on the screen:
        $!    # current value of the C errno. In this case, ECHILD (No child processes)
              # which has a value of 10
          -9  # minus 9

JavaScript, 30 octets, 10 chiffres, par ETHproductions .

Code d'origine:

1: alert(Array(2).join(3).length)

Autres numéros

 2: alert(Array(2).join(31).length)
 3: alert(Array(2).join(314).length)
 4: alert(Array(2).join(3141).length)
 5: alert(Array(2).join(31415).length)
 6: alert(Array(2).join(314159).length)
 7: alert(Array(2).join(3141592).length)
 8: alert(Array(2).join(31415926).length)
 9: alert(Array(2).join(314159265).length)
10: alert(Array(2).join(3141592653).length)

Explication

Array(2)crée un tableau avec deux cellules vides. La .joinméthode joint tous les éléments d'un tableau à l'aide d'un délimiteur, qui le convertit en chaîne. Dans le code d'origine, le délimiteur était 3. Cela signifiait que les deux cellules vides de la matrice étaient jointes et utilisées 3comme délimiteur. Cela évalue "3", sans rien de chaque côté du 3car le tableau est vide. Et puisque le lengthof "3"est 1, cette valeur est sortie sur la console.

Pour les autres nombres, j'ajoute 1 chiffre supplémentaire au délimiteur qui joint les éléments du tableau. Par conséquent, cela augmente sa longueur, donc alertavec des valeurs croissantes. Notez que la valeur numérique du délimiteur n'est pas importante, seule sa longueur l'est.

Snack Snippet!

Remarque: J'ai utilisé console.logau lieu de alertdans mon Snack Snippet pour des raisons évidentes. En outre, la sortie de la console s'affiche dans l'extrait de code.

console.log(Array(2).join(3).length)
console.log(Array(2).join(31).length)
console.log(Array(2).join(314).length)
console.log(Array(2).join(3141).length)
console.log(Array(2).join(31415).length)
console.log(Array(2).join(314159).length)
console.log(Array(2).join(3141592).length)
console.log(Array(2).join(31415926).length)
console.log(Array(2).join(314159265).length)
console.log(Array(2).join(3141592653).length)

Octave, 17 octets, 10 chiffres, par Stewie Griffin

original:
_i_(__i__(2_5_))

solution:
fix( 'i'-(2*52))
fix( 'j'-(2*52))
fix( 'k'-(2*52))
fix( 'l'-(2*52))
fix( 'm'-(2*52))
fix( 'n'-(2*52))
fix( 'o'-(2*52))
fix( 'p'-(2*52))
fix( 'q'-(2*52))
fix( 'r'-(2*52))

Python 2, 17 octets, 10 chiffres, par xnor

print len(['  '])
print len(*['  '])
print len(*['   '])
print len(*['    '])
print len(*['     '])
print len(*['      '])
print len(*['       '])
print len(*['        '])
print len(*['         '])
print len(*['          '])

repl.it

Python 2, 9 octets, 10 chiffres, xnor

print 8/8
print 18/8
print 28/8
print 38/8
print 38/7
print 38&7
print 31&7
print 31&72
print 31&73
print 31&74

Perl, 14 octets, 10 chiffres, par Dada

Code d'origine:

say_!"___"%""_

Code qui produit 1 - 10:

1. say"!"+1#"%""r
2. say"!"+2#"%""r
3. say"!"+3#"%""r
4. say"!"+4#"%""r
5. say"!"+5#"%""r
6. say"!"+6#"%""r
7. say"!"+7#"%""r
8. say"!"+8#"%""r
9. say"!"+9#"%""r
10. say"1"+9#"%""r

J'ai l'impression que ce n'est pas ce que vous vouliez.

JavaScript, 22 octets, 10 chiffres, par Arnauld

Programme original:

alert(0_6_4_>_0_2_0_7)

Fissuré:

1. alert(0+6^42>101210^7)
2. alert(0+5^42>101210^7)
3. alert(0+4^42>101210^7)
4. alert(0+3^42>101210^7)
5. alert(0+2^42>101210^7)
6. alert(0+1^42>101210^7)
7. alert(0+0^42>101210^7)
8. alert(0+0^42>101210^8)
9. alert(0+0^42>101210^9)
10. alert(0+3^42>101210^9)

La partie la plus difficile est de faire face à la >, qui a une très faible priorité. J'ai essayé de le changer en an >>, mais il est plus facile de simplement l'absorber en le faisant calculer inutilement un faux booléen (la 42>101210section) qui est numériquement 0, et générer simplement les nombres de 1 à 10 avec des opérateurs avec une priorité encore plus faible que >. J'ai utilisé ^, xor au niveau du bit, car il peut générer les nombres de 1 à 10 assez facilement (commodément, les 6 et 7 dans l'entrée d'origine me permettent de simplifier l'expression jusqu'à 6^7ce que soit 1).

JavaScript, 9 octets, Hedi

Code d'origine:

alert(+1)

Modifications:

alert(1+1)   // 2
alert(2+1)   // 3
alert(3+1)   // 4
alert(4+1)   // 5
alert(5+1)   // 6
alert(6+1)   // 7
alert(7+1)   // 8
alert(8+1)   // 9
alert(9+1)   // 10

Octave, 55 octets, 10 chiffres, flawr

(o=@(O,o)(@(O,o)o{2-O} ) (0<O,{ (yo=O-1)+1,@()1}))(1,o)

La finale 1peut être parcourue jusqu'à 9, puis changez la +1en +2.

Python 3, 16 octets, 10 chiffres, par Sp3000

C'était amusant.

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

print(1%0xfor t)
print(2%0xfor t)
...
print(8%0xfor t)
print(84%0xfor t)
print(85%0xfor t)

Exploite le fait (que je ne connaissais pas jusqu'à présent) qu'un littéral hexadécimal se termine dès qu'un caractère qui n'est pas 0-9a-fA-Frencontré - 0xforest donc une façon très sournoise d'écrire 15 or. Après cela, il s'agissait de trouver la bonne valeur congruente à 10 modulo 15.

JavaScript, 22 octets, 10 chiffres par Arnauld

Code d'origine :

alert(__14_337__xc_de)

Modifié :

alert(00140337-0xc0de) // 1
alert(00140337-0xc0dd) // 2
alert(00140337-0xc0dc) // 3
alert(00140337-0xc0db) // 4
alert(00140337-0xc0da) // 5
alert(00140337-0xc0d9) // 6
alert(00140337-0xc0d8) // 7
alert(00140337-0xc0d7) // 8
alert(00140337-0xc0d6) // 9
alert(00140337-0xc0d5) // 10

Je suppose que ce n'est pas la solution prévue, mais j'espère que ce n'est pas trop loin ...

Octave, 32 octets, 10 chiffres, par Luis Mendo

Code d'origine:

nnz(isprime(floor(s=3):i*-2i))+1

Codes modifiés:

2:  nnz(isprime(floor(s=3):i*-3i))+1
3:  nnz(isprime(floor(s=3):i*-5i))+1
4:  nnz(isprime(floor(s=3):i*-9i))+1
5:  nnz(isprime(floor(s=3):i*-9i))+2
6:  nnz(isprime(floor(s=3):i*-9i))+3
7:  nnz(isprime(floor(s=3):i*-9i))+4
8:  nnz(isprime(floor(s=3):i*-9i))+5
9:  nnz(isprime(floor(s=3):i*-9i))+6
10: nnz(isprime(floor(s=3):i*-9i))+7

Il existe de nombreuses façons d'apporter des modifications ici (par exemple s=2 et +0au début).

Edit: Une alternative plus probable:

nnz(isprime(floor(s=2):i*-2i))+0
nnz(isprime(floor(s=2):i*-2i))+1
nnz(isprime(floor(s=2):i*-2i))+2
nnz(isprime(floor(s=2):i*-2i))+3
nnz(isprime(floor(s=2):i*-2i))+4
nnz(isprime(floor(s=2):i*-2i))+5
nnz(isprime(floor(s=2):i*-2i))+6
nnz(isprime(floor(s=2):i*-2i))+7
nnz(isprime(floor(s=2):i*-2i))+8
nnz(isprime(floor(s=2):i*-2i))+9

05AB1E , 11 octets, 10 chiffres, par Oliver

Code d'origine:

 1: 3628801zï0>

Autres numéros

 2: 3628801zï0>>
 3: 3628801zï0>>>
 4: 3628801zï0>>>>
 5: 3628801zï0>>>>>
 6: 3628801zï0>>>>>>
 7: 3628801zï0>>>>>>>
 8: 3628801zï0>>>>>>>>
 9: 3628801zï0>>>>>>>>>
10: 3628801zï0>>>>>>>>>>

Explication

3628801                        # push this number
       z                       # find its reciprocal
        ï                      # round it to the nearest integer (becomes 0)
         0                     # push 0
          >>>>                 # increment by 1 for each `>` present (this is for 4)
                               # implicit output

Pour le résumer, poussez 3628801, prenez sa réciproque et arrondissez-la à l'entier le plus proche (évalue à 0). Incrémentez ensuite la pile. TADA!

Essayez-le en ligne! Pour sortie = 1 Ensuite, ajoutez autant de >s que vous le souhaitez en fonction du nombre que vous souhaitez sortir.

JavaScript, 12 octets, 10 chiffres, Hedi

Code d'origine:

alert(+[+1])

2 à 10:

alert(+[1+1])
alert(+[2+1])
alert(+[3+1])
alert(+[4+1])
alert(+[5+1])
alert(+[6+1])
alert(+[7+1])
alert(+[8+1])
alert(+[9+1])

Il y a tellement de choses que vous pouvez faire avec autant de code ...

Gelée, 7 octets, 10 chiffres, Jonathan Allan

Code d'origine:

“1‘ỌȮḊ‘

Ensuite:

“1‘‘ỌȮḊ‘
“1‘‘‘ỌȮḊ‘
“1‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌvḊ‘

Vous pouvez vérifier le dernier sur TryItOnline!

“2‘ỌȮḊ‘
“3‘ỌȮḊ‘
...
“9‘ỌȮḊ‘
“9‘ỌvḊ‘

Octave, 21 octets, 10 chiffres, par Stewie Griffin

Le fprétait un beau = Égarement) Mais j'aime la (1') -> 2(1') -> 2+(1')séquence!

original:
disp(fpr___f__e_(_'_)     % original
disp(fprintf= e=(1'))     % my solution
disp(fprintf= e=2(1'))
disp(fprintf= e=2+(1'))
disp(fprintf= e=3+(1'))
disp(fprintf= e=4+(1'))
disp(fprintf= e=5+(1'))
disp(fprintf= e=6+(1'))
disp(fprintf= e=7+(1'))
disp(fprintf= e=8+(1'))
disp(fprintf= e=9+(1'))

Hexagonie, 7 octets, 10 chiffres, par Martin Ender

Original:

1<@|!__

Code qui produit 1 - 10:

1<@|!).
2<@|!).
3<@|!).
4<@|!).
5<@|!).
6<@|!).
7<@|!).
8<@|!).
9<@|!).
9<@|!).!

1: Essayez-le en ligne!
9: Essayez-le en ligne!
10: Essayez-le en ligne!

Voici l'hex pour les 9 premiers programmes (où # est le numéro que vous souhaitez imprimer):

 # <
@ | !
 ) .

Le bord de la mémoire est juste réglé sur la valeur que vous souhaitez imprimer, dévié vers le SE et imprimé.

Et l'hex pour 10:

  9 < @
 | ! ) .
! . . . .
 . . . .
  . . . 

Ici, j'ai ajouté un personnage à la fin qui a augmenté la taille de l'hex. Tout d'abord, le bord de la mémoire est réglé sur 9, le pointeur est dévié vers le SE, la mémoire est incrémentée, s'enroule, le pointeur est dévié vers le SW, la valeur est imprimée et le programme se termine.

Voici une deuxième solution:

1<@|!$)
2<@|!$)
3<@|!$)
...
8<@|!$)
9<@|!$)
9#@|!$)

1: Essayez-le en ligne!
9: Essayez-le en ligne!
10: Essayez-le en ligne!

L'hex pour 1 - 9 (cette fois *est le nombre à imprimer):

 * <
@ | !
 $ )

Cela fonctionne de la même manière que 1 - 9 ci-dessus.

L'hex pour 10:

 9 #
@ | !
 $ )

Cette frappe a 9ensuite #basculé le pointeur d'instruction vers le coin inférieur droit, la mémoire est incrémentée à 10, $saute par-dessus !, le pointeur est inversé vers l'est où il saute )et se termine.

C #, 90 octets, 10 chiffres, Scepheo

Original:

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

Première:

using System;class D{public D(){Console.Write(+1);}};class C{static void Main(){new D();}}

Ensuite:

using System;class D{public D(){Console.Write(1+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(2+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(3+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(4+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(5+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(6+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(7+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(8+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(9+1);}};class C{static void Main(){new D();}}

Ruby, 81 octets, 10 chiffres, histocrate

Code d'origine:

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

Fissuré:

x=/$/=~%q
)

p x

Ce fut une question délicate. De nombreux personnages révélés se sont avérés être des harengs rouges! /n'est pas une division, mais fait partie d'un littéral d'expression régulière. %n'est pas un mod mais une partie d'une syntaxe littérale de chaîne inhabituelle. Ce programme affiche simplement la longueur d'une chaîne délimitée par des retours à la ligne. Les programmes suivants peuvent être obtenus en insérant des caractères supplémentaires dans la deuxième ligne.

Octave, 25 octets, 10 chiffres, par Luis Mendo

mean(repmat(1,ones(1,1)))
mean(repmat(2,ones(1,1)))
mean(repmat(3,ones(1,1)))
mean(repmat(4,ones(1,1)))
mean(repmat(5,ones(1,1)))
mean(repmat(6,ones(1,1)))
mean(repmat(7,ones(1,1)))
mean(repmat(8,ones(1,1)))
mean(repmat(9,ones(1,1)))

아희 (Aheui), 19 octets, 10 chiffres, par JHM

Code d'origine:

봃法희
반자뭉

Modifié:

2
봃法희
반반뭉
3
봃法희
반밬뭉
4
봃法희
반밭뭉
5
봃法희
반발뭉
6
봃法희
반타뭉
7
봃法희
반밝뭉
8
봃法희
반밣뭉
9
봃法희
반밢뭉
10
봃法희
반다뭉

Octave, 24 octets, 9 chiffres, par flawr

max(repmat(1,ones(),1))%
max(repmat(2,ones(),1))%
max(repmat(3,ones(),1))%
max(repmat(4,ones(),1))%
max(repmat(5,ones(),1))%
max(repmat(6,ones(),1))%
max(repmat(7,ones(),1))%
max(repmat(8,ones(),1))%
max(repmat(9,ones(),1))%

Octave, 24 octets 9 10 chiffres

Remarque: Cette fissure concerne la première version du message de la police (a publié le mauvais extrait), avec le code révélé ressemblant à ceci: ___a__repmat(__one__),__) . La version correcte est ci-dessus.

Code d'origine:

+mean(repmat(1,ones(),1))

Versions modifiées qui impriment 2-10

1+mean(repmat(1,ones(),1))
2+mean(repmat(1,ones(),1))
3+mean(repmat(1,ones(),1))
4+mean(repmat(1,ones(),1))
5+mean(repmat(1,ones(),1))
6+mean(repmat(1,ones(),1))
7+mean(repmat(1,ones(),1))
8+mean(repmat(1,ones(),1))
9+mean(repmat(1,ones(),1))

JavaScript, 15 octets, 10 chiffres, ETHProductions

Code d'origine:

alert( +"+1"+0)  // Prints 1

Programmes:

alert( +"+1"+1)  // Prints 2
alert( +"+1"+2)  // Prints 3
alert( +"+1"+3)  // Prints 4
alert( +"+1"+4)  // Prints 5
alert( +"+1"+5)  // Prints 6
alert( +"+1"+6)  // Prints 7
alert( +"+1"+7)  // Prints 8
alert( +"+1"+8)  // Prints 9
alert( +"+1"+9)  // Prints 10

Octave, 21 octets, 9 chiffres, par flawr

J'ai vraiment apprécié celui-ci ... intelligent :)

a='repmat(1one'(1,8)
a='repmat(2one'(1,8)
a='repmat(3one'(1,8)
a='repmat(4one'(1,8)
a='repmat(5one'(1,8)
a='repmat(6one'(1,8)
a='repmat(7one'(1,8)
a='repmat(8one'(1,8)
a='repmat(9one'(1,8)

Acc !! , 10 octets, 9 nombres, par DLosc

Code d'origine:

Write 49+_

Pour produire les nombres 1 à 9:

Write 49+_
Write 49+1
Write 49+2
Write 49+3
Write 49+4
Write 49+5
Write 49+6
Write 49+7
Write 49+8

49 est le code ascii de 1. _contient 0 par défaut (donc 49+_ = 1). Et Writeimprime le caractère correspondant au code ascii de son argument. Assez simple.

Python 2, 49 octets, 10 chiffres, AlexRacer

Peut-être (juste peut-être) la solution envisagée, mais si c'est le cas, de nombreux octets auraient pu être utilisés:

y=10-6;s='0901100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0902100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0903100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0904100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0905100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0906100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0907100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0908100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0909100000';print int(s[8-8+y-2+0+0:y])
y=10-4;s='0909100000';print int(s[8-8+y-2+0+0:y])

Befunge-93 , 11 octets, 10 chiffres, James Holderness

905:**-8-.@
905:**-7-.@
905:**-6-.@
905:**-5-.@
905:**-4-.@
905:**-3-.@
905:**-2-.@
905:**-1-.@
905:**-0-.@
905:**-~-.@

Essayez-le en ligne!

Probablement pas la solution envisagée.

Ce que j'ai fait, c'est de me débarrasser du satané 25 ( 5:*) en le multipliant par 0. Si nous mettons ensuite un 9au début, les sorties seront là 9 - Noù il faut générer à Npartir d'une seule commande. Le seul problème est -1d'obtenir 10, mais essayer de lire un entier s'il n'y a pas d'entrée pousse commodément a -1.

05AB1E, 5 octets, 10 chiffres, par Adnan .

Code d'origine:

…[==1

1-10:

…[==1
…[==2
…[==3
…[==4
…[==5
…[==6
…[==7
…[==8
…[==9
…[==T

Explication:

…[==   3 char string
    1  Push number

05AB1E, 6 octets, 10 chiffres, Adnan

Code d'origine:

¼ [==q

Continuez à ajouter ¼des pour produire jusqu'à 10:

¼¼ [==q
¼¼¼ [==q
¼¼¼¼ [==q
¼¼¼¼¼ [==q
¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼¼ [==q

Essayez-le en ligne

Comment ça marche:

¼        # Increment counter_variable to count_of(¼), it's printed at some point...
  [      # Infinite loop start
   ==    # Print nothing because stack is empty
     q   # Quit