Questo è il filo dei ladri. Il thread della polizia va qui .

Scrivi un codice che abbia lo stesso numero di byte della posta del poliziotto e dove i caratteri rivelati sono identici. Il codice deve produrre 1nel suo stato iniziale e produrre i numeri 2, 3 ..quando vengono apportate singole modifiche.

Il vincitore sarà il ladro che ha incrinato il maggior numero di post.

Esempio di post:

MyLang, 9 byte, 8 numeri (incluso il link per rispondere), nome utente di Cop.

Codice originale:

abc1efghi

Codice che produce 1 - 8:

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

Le spiegazioni sono incoraggiate. Il formato esatto del posto di ladro è facoltativo.

Retina, 2 byte, 10 numeri, di Martin Ender .

Codice originale:

1

Questo sostituisce l'input vuoto con il numero 1.

Codice che produce 1 - 10 (mostrando le nuove righe \nper comodità):

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

Per 2 e successivi, contiamo il numero di stringhe vuote nella fase precedente. Per 2, c'è una stringa vuota prima e dopo l'1. Per 3 c'è una stringa vuota prima di quelle, tra quelle e dopo quelle. Funziona fino a 10.

Provalo online

Perl, 12 byte, 10 numeri, ais523

Codice originale:

____;say__-9

Codice che produce 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

Spiegazione:

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 byte, 10 numeri, per ETHproductions .

Codice originale:

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

Altri numeri

 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)

Spiegazione

Array(2)crea una matrice con due celle vuote. Il .joinmetodo unisce tutti gli elementi in un array usando un delimitatore, che lo converte in una stringa. Nel codice originale, il delimitatore era 3. Ciò significa che le due celle vuote nell'array vengono unite insieme 3come loro delimitatore. Questo valuta "3", senza nulla su entrambi i lati del 3perché l'array è vuoto. E poiché il lengthdi "3"è1 , questo valore viene inviato alla console.

Per gli altri numeri, aggiungo un'altra cifra al delimitatore che unisce gli elementi dell'array. Quindi, questo aumenta la sua lunghezza, alerting così con valori crescenti. Si noti che il valore numerico del delimitatore non è importante, lo è solo la sua lunghezza.

Snippet di snack!

Nota: l' ho usato al console.logposto del alertmio frammento di snack per ovvie ragioni. Inoltre, l'output dalla console viene visualizzato nello snippet.

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)

Ottava, 17 byte, 10 numeri, di 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 byte, 10 numeri, per 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 byte, 10 numeri, 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 byte, 10 numeri, di Dada

Codice originale:

say_!"___"%""_

Codice che produce 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

Sento che non è quello che stavi cercando.

JavaScript, 22 byte, 10 numeri, di Arnauld

Programma originale:

alert(0_6_4_>_0_2_0_7)

Cracked:

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 parte difficile è occuparsi di >, che ha una precedenza molto bassa. Ho provato a cambiarlo in un >>, ma è più facile assorbirlo semplicemente calcolando inutilmente un falso booleano (la 42>101210sezione) che è numericamente 0 e genera semplicemente i numeri da 1 a 10 con operatori con una precedenza ancora inferiore di >. Ho usato ^, bit per bit o x, perché può generare i numeri da 1 a 10 abbastanza facilmente (convenientemente, i 6 e 7 nell'input originale mi permettono di semplificare l'espressione fino a 6^7cui è 1).

JavaScript, 9 byte, Hedi

Codice originale:

alert(+1)

modifiche:

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

Ottava, 55 byte, 10 numeri, flawr

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

La finale 1può essere ciclicata fino a 9, quindi cambiare +1in +2.

Python 3, 16 byte, 10 numeri, di Sp3000

È stato divertente.

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

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

Sfrutta il fatto (che non sapevo fino ad ora) che un letterale esadecimale finisca non appena 0-9a-fA-Fsi incontra un personaggio che non viene incontrato - quindi 0xforè un modo molto subdolo di scrivere 15 or. Successivamente, si trattava di trovare il giusto valore congruente a 10 modulo 15.

JavaScript, 22 byte, 10 numeri di Arnauld

Codice originale :

alert(__14_337__xc_de)

Modificato :

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

Immagino che questa non sia la soluzione prevista, ma spero che non sia troppo lontano ...

Ottava, 32 byte, 10 numeri, di Luis Mendo

Codice originale:

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

Codici modificati:

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

Esistono molti modi per apportare modifiche qui (ad esempio s=2e +0all'inizio).

Modifica: un'alternativa più probabile:

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 byte, 10 numeri, di Oliver

Codice originale:

 1: 3628801zï0>

Altri numeri

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

Spiegazione

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

Per riassumere, premi 3628801, prendi il suo reciproco e arrotondalo all'intero più vicino (valuta a0 ). Quindi incrementare lo stack. TADA!

Provalo online! Per output = 1 Quindi aggiungere tutti gli >s che si desidera a seconda del numero che si desidera produrre.

JavaScript, 12 byte, 10 numeri, Hedi

Codice originale:

alert(+[+1])

Da 2 a 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])

C'è così tanto che puoi fare con questo codice ...

Gelatina, 7 byte, 10 numeri, Jonathan Allan

Codice originale:

“1‘ỌȮḊ‘

Poi:

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

Puoi controllare l'ultimo su TryItOnline!

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

Ottava, 21 byte, 10 numeri, di Stewie Griffin

È fprstata una bella disguida =) Ma adoro la (1') -> 2(1') -> 2+(1')sequenza!

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'))

Esagonia, 7 byte, 10 numeri, di Martin Ender

Originale:

1<@|!__

Codice che produce 1 - 10:

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

1: provalo online!
9: provalo online!
10: provalo online!

Ecco l'esagono per i primi 9 programmi (dove # è il numero che si desidera stampare):

 # <
@ | !
 ) .

Il bordo della memoria è appena impostato sul valore che si desidera stampare, deviato su SE e stampato.

E l'esagono per 10:

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

Qui, ho aggiunto un personaggio alla fine che ha aumentato la dimensione esadecimale. Innanzitutto, il bordo della memoria è impostato su 9, il puntatore viene deviato verso SE, la memoria viene incrementata, si avvolge, il puntatore viene deviato sul SW, il valore viene stampato e il programma termina.

Ecco una seconda soluzione:

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

1: provalo online!
9: provalo online!
10: provalo online!

L'esagono per 1 - 9 (questa volta *è il numero da stampare):

 * <
@ | !
 $ )

Funziona come 1 - 9 sopra.

L'esagono per 10:

 9 #
@ | !
 $ )

Questo colpisce 9quindi #il puntatore dell'istruzione a quello in basso a destra, la memoria viene incrementata a 10, $salta sopra !, il puntatore viene invertito verso est dove salta )e termina.

C #, 90 byte, 10 numeri, Scepheo

Originale:

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

Primo:

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

Poi:

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();}}

Rubino, 81 byte, 10 numeri, istocratico

Codice originale:

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

Cracked:

x=/$/=~%q
)

p x

Questo è stato difficile. Molti personaggi rivelati si sono rivelati aringhe rosse! /non è divisione ma parte di un regex letterale. %non è mod ma fa parte di una sintassi letterale stringa non comune. Questo programma stampa semplicemente la lunghezza di una stringa delimitata da newline. I programmi successivi possono essere ottenuti inserendo caratteri aggiuntivi nella seconda riga.

Ottava, 25 byte, 10 numeri, di 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 byte, 10 numeri, di JHM

Codice originale:

봃法희
반자뭉

Modificata:

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

Ottava, 24 byte, 9 numeri, per 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))%

Ottava, 24 byte 9 10 numeri

Nota: questo crack è per la prima versione del post del poliziotto (pubblicato lo snippet sbagliato), con il codice rivelato simile al seguente: ___a__repmat(__one__),__) . La versione corretta è sopra.

Codice originale:

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

Versioni modificate che stampano 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 byte, 10 numeri, ETHProductions

Codice originale:

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

programmi:

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

Ottava, 21 byte, 9 numeri, per flawr

Mi è davvero piaciuto questo ... Clever :)

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 byte, 9 numeri, per DLosc

Codice originale:

Write 49+_

Per produrre i numeri da 1 a 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 è il codice ascii di 1. _contiene 0 per impostazione predefinita (quindi 49+_ = 1). E Writestampa il carattere corrispondente al codice ASCII del suo argomento. Abbastanza diretto.

Python 2, 49 byte, 10 numeri, AlexRacer

Forse (solo forse) la soluzione voluta, ma in tal caso, molti byte avrebbero potuto essere eliminati:

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 byte, 10 numeri, James Holderness

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

Provalo online!

Probabilmente non è la soluzione prevista.

Quello che ho fatto è stato sbarazzarmi del fastidioso 25 ( 5:*) moltiplicandolo per 0. Se poi mettiamo 9a all'inizio, allora gli output saranno 9 - Ndove devono essere generati Nda un singolo comando. L'unico problema è -1quello di ottenere 10, ma provare a leggere un numero intero se non c'è input spinge convenientemente a -1.

05AB1E, 5 byte, 10 numeri, per Adnan .

Codice originale:

…[==1

1-10:

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

Spiegazione:

…[==   3 char string
    1  Push number

05AB1E, 6 byte, 10 numeri, Adnan

Codice originale:

¼ [==q

Continuare ad aggiungere ¼all'output fino a 10:

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

Provalo online

Come funziona:

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