Este es el hilo de los ladrones. El hilo de la policía va aquí .

Escriba un código que tenga el mismo número de bytes que la publicación policial y donde los caracteres revelados sean idénticos. El código debe producir 1en su estado inicial y producir los números 2, 3 ..cuando se realizan alteraciones individuales.

El ganador será el ladrón que logró más publicaciones.

Publicación de ejemplo:

MyLang, 9 bytes, 8 números (incluido el enlace para responder), nombre de usuario de Cop.

Código original:

abc1efghi

Código que produce 1 - 8:

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

Se alientan las explicaciones. El formato exacto de la publicación de ladrón es opcional.

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

Código original:

1

Esto reemplaza la entrada vacía por el número 1.

Código que produce 1 - 10 (mostrando nuevas líneas como \nconveniencia):

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 y más, contamos el número de cadenas vacías en la etapa anterior. Para 2, hay una cadena vacía antes y después del 1. Para 3 hay una cadena vacía antes de las unidades, entre las unidades y después de las unidades. Esto funciona hasta 10.

Pruébalo en línea

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

Código original:

____;say__-9

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

Explicación:

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)

Otros numeros

 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)

Explicación

Array(2)crea una matriz con dos celdas vacías. El .joinmétodo une todos los elementos de una matriz utilizando un delimitador, que lo convierte en una cadena. En el Código Original, el delimitador era 3. Esto significaba que las dos celdas vacías en la matriz se unían y se usaban 3como su delimitador. Esto evalúa "3", sin nada a cada lado de 3la matriz porque la matriz está vacía. Y dado que lengthof "3"es 1, este valor se envía a la consola.

Para los otros números, agrego 1 dígito más al delimitador que une los elementos de la matriz. Por lo tanto, esto aumenta su longitud, lo que alertaumenta los valores. Tenga en cuenta que el valor numérico del delimitador no es importante, solo lo es su longitud.

Snack Snippet!

Nota: Utilicé en console.loglugar de alertmi Snack Snippet por razones obvias. Además, la salida de la consola se muestra en el fragmento.

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)

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

Tengo la sensación de que esto no es lo que estabas buscando.

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

Programa original:

alert(0_6_4_>_0_2_0_7)

Agrietado:

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 difícil es tratar con el >, que tiene una precedencia muy baja. Intenté cambiarlo a an >>, pero es más fácil simplemente absorberlo haciendo que calcule inútilmente un falso booleano (la 42>101210sección) que es numéricamente 0, y solo genere los números del 1 al 10 con operadores con una precedencia aún menor que >. Utilicé ^, bit xor, porque puede generar los números del 1 al 10 con bastante facilidad (convenientemente, el 6 y el 7 en la entrada original me permiten simplificar la expresión, 6^7que es 1).

JavaScript, 9 bytes, Hedi

Código original:

alert(+1)

Modificaciones:

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

Octava, 55 bytes, 10 números, flawr

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

La final 1se puede ciclar hasta 9 y luego cambiar +1a +2.

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

Esto fue 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)

Explota el hecho (que no sabía hasta ahora) de que un literal hexadecimal termina tan pronto como se encuentra un personaje que no 0-9a-fA-Fse encuentra, por lo tanto0xfor es una forma muy astuta de escribir 15 or. Después de eso, se trataba de encontrar el valor correcto congruente con 10 módulo 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

Supongo que esta no es la solución prevista, pero espero que no esté muy lejos ...

Octava, 32 bytes, 10 números, por 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

Hay muchas formas de hacer modificaciones aquí (por ejemplo s=2y +0al principio).

Editar: Una alternativa más 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 bytes, 10 números, por Oliver

Código original:

 1: 3628801zï0>

Otros numeros

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

Explicación

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 resumirlo, presione 3628801, tome su recíproco y redondee eso al entero más cercano (evalúa como 0). Luego incremente la pila. TADA!

Pruébalo en línea! Para salida = 1 A continuación, agregue tantos >s como desee según el número que desea generar.

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

Hay tanto que puedes hacer con este código ...

Gelatina, 7 bytes, 10 números, Jonathan Allan

Código original:

“1‘ỌȮḊ‘

Luego:

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

¡Puedes consultar el último en TryItOnline!

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

Octava, 21 bytes, 10 números, por Stewie Griffin

El fprfue un buen error =) ¡Pero me encanta la (1') -> 2(1') -> 2+(1')secuencia!

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

Hexagonía, 7 bytes, 10 números, por Martin Ender

Original:

1<@|!__

Código que produce 1 - 10:

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

1: ¡ Pruébelo en línea!
9: ¡ Pruébelo en línea!
10: ¡ Pruébelo en línea!

Aquí está el hexadecimal para los primeros 9 programas (donde # es el número que desea imprimir):

 # <
@ | !
 ) .

El borde de la memoria se establece en el valor que desea imprimir, se desvía al SE y se imprime.

Y el hex para 10:

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

Aquí, agregué un personaje al final que aumentó el tamaño del hex. Primero, el borde de la memoria se establece en 9, el puntero se desvía hacia el SE, la memoria se incrementa, se envuelve, el puntero se desvía hacia el SW, el valor se imprime y el programa finaliza.

Aquí hay una segunda solución:

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

1: ¡ Pruébelo en línea!
9: ¡ Pruébelo en línea!
10: ¡ Pruébelo en línea!

El hexadecimal para 1 - 9 (esta vez *es el número para imprimir):

 * <
@ | !
 $ )

Esto funciona igual que 1 - 9 arriba.

El hex para 10:

 9 #
@ | !
 $ )

Estos golpes 9luego #cambiaron el puntero de instrucciones a la esquina inferior derecha, la memoria se incrementa a 10, $salta sobre el !, el puntero se invierte hacia el este, donde salta )y termina.

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

Original:

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

Primero:

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

Luego:

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

Código original:

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

Agrietado:

x=/$/=~%q
)

p x

Esto fue complicado. ¡Muchos personajes que se revelaron resultaron ser pistas falsas! /no es división sino parte de un literal regex. %no es mod sino parte de una sintaxis literal de cadena poco común. Este programa simplemente imprime la longitud de una cadena delimitada por nuevas líneas. Los programas posteriores se pueden obtener insertando caracteres adicionales en la segunda línea.

Octava, 25 bytes, 10 números, por 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 bytes, 10 números, por JHM

Código original:

봃法희
반자뭉

Modificado:

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

Octava, 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))%

Octava, 24 bytes 9 10 números

Nota: Esta grieta es para la primera versión del puesto de policía (publicado el fragmento mal), con el código de manifiesto con este aspecto: ___a__repmat(__one__),__). La versión correcta está arriba.

Código original:

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

Versiones modificadas que imprimen 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

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

Realmente disfruté este ... 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 bytes, 9 números, por DLosc

Código original:

Write 49+_

Para producir los números del 1 al 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 es el código ascii de 1. _contiene 0 por defecto (so 49+_ = 1). E Writeimprime el carácter correspondiente al código ascii de su argumento. Muy claro.

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

Tal vez (solo tal vez) la solución prevista, pero si es así, se podrían haber eliminado muchos bytes:

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:**-~-.@

Pruébalo en línea!

Probablemente no sea la solución prevista.

Lo que hice fue deshacerme del molesto 25 ( 5:*) multiplicándolo por 0. Si luego ponemos un 9al principio, entonces las salidas estarán 9 - Ndonde sea necesario generarN partir de un solo comando. El único problema es -1obtener 10, pero intentar leer un número entero si no hay entrada empuja 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

Explicación:

…[==   3 char string
    1  Push number

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

Código original:

¼ [==q

Sigue agregando ¼'s para generar hasta 10:

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

Pruébalo en línea

Cómo funciona:

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