Este é o fio dos ladrões. A discussão dos policiais vai aqui .

Escreva um código que tenha o mesmo número de bytes que a publicação da polícia e onde os caracteres revelados são idênticos. O código deve produzir 1em seu estado inicial e produzir os números 2, 3 ..quando alterações únicas são feitas.

O vencedor será o ladrão que mais invadiu as postagens.

Exemplo de postagem:

MyLang, 9 bytes, 8 números (incluindo link para responder), nome de usuário da Cop.

Código original:

abc1efghi

Código que produz 1 - 8:

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

As explicações são incentivadas. O formato exato da postagem do ladrão é opcional.

Retina, 2 bytes, 10 números, de Martin Ender .

Código original:

1 1

Isso substitui a entrada vazia pelo número 1.

Código que produz 1 - 10 (mostrando novas linhas quanto \nà conveniência):

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

Para 2 em diante, contamos o número de cadeias vazias no estágio anterior. Para 2, existe uma string vazia antes e depois do 1. Para 3, existe uma string vazia antes das, entre essas e depois das. Isso funciona até 10.

Experimente online

Perl, 12 bytes, 10 números, por ais523

Código original:

____;say__-9

Código que produz 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

Explicação:

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 bytes, 10 números, por ETHproductions .

Código original:

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

Outros números

 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)

Explicação

Array(2)cria uma matriz com duas células vazias. O .joinmétodo une todos os elementos em uma Matriz usando um delimitador, que o converte em uma String. No código original, o delimitador era 3. Isso significa que as duas células vazias na matriz são unidas e usadas 3como delimitador. Isso avalia "3", sem nada nos dois lados do, 3porque a matriz está vazia. E, como o lengthde "3"é 1, esse valor é gerado no console.

Para os outros números, adiciono mais 1 dígito ao delimitador que une os elementos da Matriz. Portanto, isso aumenta seu comprimento, alertaumentando assim os valores. Observe que o valor numérico do delimitador não é importante, apenas seu comprimento.

Snack Snippet!

Nota: usei em console.logvez de alertno meu Snack Snippet por razões óbvias. Além disso, a saída do console é exibida no 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)

Oitava, 17 bytes, 10 números, de 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 bytes, 10 números, por 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 bytes, 10 números, 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 bytes, 10 números, por Dada

Código original:

say_!"___"%""_

Código que produz 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

Tenho a sensação de que não é isso que você estava procurando.

JavaScript, 22 bytes, 10 números, por Arnauld

Programa original:

alert(0_6_4_>_0_2_0_7)

Rachado:

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)

A parte difícil é lidar com o >, que tem uma precedência muito baixa. Tentei alterá-lo para an >>, mas é mais fácil absorvê-lo, tornando-o inutilmente calcular um falso booleano (a 42>101210seção) que é numericamente 0 e apenas gerar os números de 1 a 10 com operadores com uma precedência ainda mais baixa que >. Eu usei ^, bit a bit xor, porque ele pode gerar os números de 1 a 10 com bastante facilidade (convenientemente, os 6 e 7 na entrada original me permitem simplificar a expressão na 6^7qual é 1).

JavaScript, 9 bytes, Hedi

Código original:

alert(+1)

Modificações:

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

Oitava, 55 bytes, 10 números, falha

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

A final 1pode ter um ciclo de até 9 e depois alterar +1para +2.

Python 3, 16 bytes, 10 números, por Sp3000

Isso foi divertido.

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

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

Explora o fato (que eu não sabia até agora) de que um literal hexadecimal termina assim que um caractere que não 0-9a-fA-Fé encontrado - portanto, 0xforé uma maneira muito sorrateira de escrever 15 or. Depois disso, tratava-se de encontrar o valor certo congruente a 10 módulos 15.

JavaScript, 22 bytes, 10 números por Arnauld

Código original :

alert(__14_337__xc_de)

Modificado :

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

Acho que essa não é a solução pretendida, mas espero que não esteja muito longe ...

Oitava, 32 bytes, 10 números, de Luis Mendo

Código original:

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

Códigos modificados:

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

Existem muitas maneiras de fazer modificações aqui (por exemplo s=2e +0no começo).

Edit: Uma alternativa mais provável:

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 bytes, 10 números, de Oliver

Código original:

 1: 3628801zï0>

Outros números

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

Explicação

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

Para resumir, pressione 3628801, leve seu recíproco e arredonde-o para o número inteiro mais próximo (avalia para 0). Aumente a pilha. TADA!

Experimente online! Para saída = 1 Em seguida, adicione quantos >s desejar, dependendo do número que você deseja gerar.

JavaScript, 12 bytes, 10 números, Hedi

Código original:

alert(+[+1])

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

Há muito o que você pode fazer com esse código ...

Geléia, 7 bytes, 10 números, Jonathan Allan

Código original:

“1‘ỌȮḊ‘

Então:

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

Você pode conferir o último no TryItOnline!

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

Oitava, 21 bytes, 10 números, de Stewie Griffin

O fprfoi uma boa desorientação =) Mas eu amo o (1') -> 2(1') -> 2+(1')seqüência!

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

Hexagonia, 7 bytes, 10 números, de Martin Ender

Original:

1<@|!__

Código que produz 1 - 10:

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

1: Experimente Online!
9: Experimente online!
10: Experimente online!

Aqui está o hexadecimal para os 9 primeiros programas (em que # é o número que você deseja imprimir):

 # <
@ | !
 ) .

A borda da memória é configurada apenas para o valor que você deseja imprimir, desviado para o SE e impresso.

E o hexadecimal para 10:

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

Aqui, adicionei um caractere ao final que aumentou o tamanho hexadecimal. Primeiro, a borda da memória é configurada para 9, o ponteiro é desviado para o SE, a memória é incrementada, envolve-se, o ponteiro é desviado para o SW, o valor é impresso e o programa termina.

Aqui está uma segunda solução:

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

1: Experimente Online!
9: Experimente online!
10: Experimente online!

O hexadecimal para 1 - 9 (desta vez *é o número a ser impresso):

 * <
@ | !
 $ )

Isso funciona da mesma maneira que 1 - 9 acima.

O hexadecimal para 10:

 9 #
@ | !
 $ )

Isso acerta 9e #muda o ponteiro de instrução para o canto inferior direito, a memória é aumentada para 10, $pula sobre o !, o ponteiro é revertido para o leste, onde salta )e termina.

C #, 90 bytes, 10 números, Scepheo

Original:

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

Primeiro:

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

Então:

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 bytes, 10 números, histocrata

Código original:

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

Rachado:

x=/$/=~%q
)

p x

Este foi um assunto complicado. Muitos personagens que foram revelados acabaram sendo arenques vermelhos! /não é divisão, mas parte de um regex literal. %não é mod, mas parte de uma sintaxe literal de sequência incomum. Este programa simplesmente imprime o comprimento de uma string delimitada por novas linhas. Os programas subsequentes podem ser obtidos inserindo caracteres adicionais na segunda linha.

Oitava, 25 bytes, 10 números, de 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)))

A (Aheui), 19 bytes, 10 números, por JHM

Código original:

봃法희
반자뭉

Modificado:

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

Oitava, 24 bytes, 9 números, por 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))%

Oitava, 24 bytes 9 10 números

Nota: Este crack é para a primeira versão do post policial (postou o trecho errado), com o código revelado parecido com isto: ___a__repmat(__one__),__). A versão correta está acima.

Código original:

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

Versões modificadas que imprimem 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 bytes, 10 números, ETHProductions

Código original:

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

Programas:

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

Oitava, 21 bytes, 9 números, por flawr

Eu realmente gostei deste ... Inteligente :)

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 bytes, 9 números, por DLosc

Código original:

Write 49+_

Para produzir os números de 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 é o código ascii de 1. _contém 0 por padrão (assim 49+_ = 1). E Writeimprime o caractere correspondente ao código ascii de seu argumento. Bem direto.

Python 2, 49 bytes, 10 números, AlexRacer

Talvez (apenas talvez) a solução pretendida, mas se assim for, muitos bytes poderiam ter sido jogados fora:

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 bytes, 10 números, James Holderness

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

Experimente online!

Provavelmente não é a solução pretendida.

O que eu fiz foi me livrar do irritante 25 ( 5:*) multiplicando-o por 0. Se colocarmos um 9no início, as saídas serão 9 - Nonde é necessário gerar a Npartir de um único comando. O único problema é -1obter 10, mas tentar ler um número inteiro se não houver entrada pressiona convenientemente a -1.

05AB1E, 5 bytes, 10 números, por Adnan .

Código original:

…[==1

1-10:

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

Explicação:

…[==   3 char string
    1  Push number

05AB1E, 6 bytes, 10 números, Adnan

Código original:

¼ [==q

Continue adicionando ¼'s para gerar até 10:

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

Experimente online

Como funciona:

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