Este es un desafío de policías y ladrones . El hilo de los ladrones está aquí .

Una pregunta interesante para pensar es la siguiente:

Si tengo una secuencia de números, ¿cuántos de ellos debo proporcionar antes de que quede claro de qué secuencia estoy hablando?

Por ejemplo, si quiero hablar sobre los enteros positivos en orden a partir de $1$ , podría decir $1,2,3, \dots$ , pero ¿es eso realmente suficiente?

Tengo una manera de responder a esta pregunta, y ser un jugador de código implica el código de golf. Ha proporcionado suficientes términos de una secuencia si el código más corto que produce esos términos produce todos los términos de la secuencia. Si pensamos en esto en términos de código de golf, esto significaría que ha proporcionado suficientes casos de prueba para que el código más corto que pasa los casos de prueba haga la tarea deseada.

Reto

Este desafío es un desafío de policías y ladrones . En el cual los policías presentarán casos de prueba y los ladrones tendrán que encontrar una forma más corta de falsificar los casos de prueba que no sea la secuencia prevista. Los policías presentarán lo siguiente:

• Una pieza de código que toma un entero no negativo como entrada y produce un entero como salida. Este código definirá su secuencia. Su código no necesita soportar 0 como entrada, optando por tomar 1 como la entrada más pequeña. Debe quedar claro si este es el caso en su respuesta.

• Cualquier plataforma relevante o requisitos de idioma que puedan afectar la salida, por ejemplo, el tamaño de la letra larga.

• Un número $n$ , junto con los primeros $n$ términos de la secuencia calculados por el código. Estos actuarán como "casos de prueba".

Se le recomienda que explique qué hace su secuencia y enlace OEIS si existe, sin embargo, es su código el que define la secuencia, no la descripción.

Los ladrones encontrarán un programa en el mismo lenguaje que es más corto que el presentado y pasa todos los casos de prueba (produce la misma salida para las primeras entradas que el código del policía). El código del ladrón también debe diferir en la salida del programa del policía para un número mayor que $n$$n$ .

Los policías deben poder descifrar sus propias respuestas antes de enviarlas.

Después de una semana, un policía puede revelar su crack y marcar su respuesta como segura. Las respuestas marcadas como tales ya no se pueden descifrar.

Tanteo

Las respuestas de los policías se puntuarán por el número de bytes, con menos bytes mejor. Las respuestas agrietadas obtienen una puntuación infinita.

cQuents , 4 bytes ( agrietado )

"::$

Pruébalo en línea!

Aquí hay ocho ( n=8) casos:

1 1
2 12
3 123
4 1234
5 12345
6 123456
7 1234567
8 12345678

Explicación del código:

"      Stringify sequence (join on "", remove it and see what happens)
 ::    Given input n, output all items in the sequence up to and including n
   $   Each item in the sequence equals the index

Entonces, la secuencia es 1,2,3,4,5 ..., se une ""para que se convierta 12345 ..., y ::significa que se imprime en la entrada.

Python 3 , 66 57 bytes ( Agrietado )

agrietado por xnor
también agrietado por Cat Wizard antes de una edición

def f(n):x=n/10-2;return int(x*60-x**3*10+x**5/2-x**7/84)

Pruébalo en línea!

¡Hola! Aquí hay una secuencia para descifrar para . Da a estos primeros 40 elementos con indexación 0, no es una secuencia OEIS$n=40$

[-54, -56, -58, -59, -59, -59, -59, -57, -55, -53, -50, -46, -43, -38, -33, -28, -23, -17, -11, -5, 0, 5, 11, 17, 23, 28, 33, 38, 43, 46, 50, 53, 55, 57, 59, 59, 59, 59, 58, 56]

Python 2 , 44 bytes ( agrietado )

f=lambda n,i=1,p=1:n and-~f(n-p%i,i+1,p*i*i)

Pruébalo en línea!

Los números primos. ¿Qué secuencia podría ser más pura? ¿O más exagerado ? Su objetivo es producir los primeros 50 números primos para n=1a n=50.

El código es un generador del Teorema de Wilson copiado exactamente de este consejo .

Los diferentes valores para la secuencia alternativa no se deben a limitaciones de la máquina, como desbordamientos y precisión. No hay bibliotecas de terceros.

Agrietado por Arnauld, @PoonLevi y el Sr. Xcoder.

Wolfram Language (Mathematica) , 39 34 bytes (Seguro)

Check[{1,9,7}[[#]],18+Boole[#>9]]&

Pruébalo en línea!

Parece simple, la solución debería ser difícil.

1 indexado . Esta secuencia no está disponible en el OEIS.$n = 99$

{1, 9, 7, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19}

Esta lista anterior es igual a:

Join[{1, 9, 7}, Table[18, 6], Table[19, 90]]

Aquí hay una plantilla para verificar su solución: ¡ Pruébelo en línea!

Grieta prevista

El problema aquí es que la producción aumenta en 1 cuando el número de dígitos aumenta en 1, con la excepción de los primeros tres términos; La solución prevista tiene algo que ver con la conversión de cadenas.

Por lo tanto, al leer la documentación sobre Conversión entre expresiones y cadenas , se puede encontrar la función SpokenString.

La solución es simplemente la longitud de la versión de cadena hablada de la expresión x^npara varias entradas:StringLength@SpokenString[x^#]&

Haskell , 29 bytes (Agrietado: 1 , 2 )

a n=n*ceiling(realToFrac n/2)

Pruébalo en línea!

Esto es A093005 : .$a(n)=n\lceil \frac{n}{2} \rceil$

Casos de prueba para , es decir :$0 \leq n \leq 20$map a [0..20]

[0,1,2,6,8,15,18,28,32,45,50,66,72,91,98,120,128,153,162,190,200]

Solución prevista (20 bytes)

b n=sum$n<$show(3^n)

Pruébalo en línea! Difiere en , con una ( 23 ) = 276 y b ( 23 ) = 253 .$n=23$$a(23) = 276$$b(23) = 253$

Esta función es equivalente a . Gracias al techo, ambas funciones se superponen para argumentos enteros en el rango de 0 a 22 :$b(n) = n\ len(3^n) = n \lceil log_{10}(1+3^n)\rceil$$0$$22$

_fuente

JavaScript (ES6), 12 bytes ( agrietado )

Este es bastante fácil.

n=>n*(8*n+1)

Pruébalo en línea!

Esta es A139275 :

$0\le n<9$

Y según las reglas del desafío, debe divergir más allá.

Malbolge, 10 bytes

ub&;$9]J6

Tenga en cuenta que el código termina con un byte 0x14 (control de dispositivo 4).

Pruébalo en línea!

La secuencia indexada a 0 para crackear es [9, 19, 29].

> <> , 276 bytes ( Agrietado )

1$1-:?!v$:      1[0$          >:?!va2[$:{:@%:{$-{,]v
       >$n; v              <  ^   >~{]02.1+1+ffr+1r<
 :}[r]{  [01>:{*@@+$a*l2=?!^~]+ff+9+1g"3"=?v"3"ff+9+1pf0.
 :}[l01-$>    $:0(?v$@$:@@:@)?v@@1-$}v     >"2"ff+9+1p00.
>.       ^-1l v!?} <  .4a}$@@$<   .4a<
^26{]r0[}:{]~{<

Pruébalo en línea! Llama a este con-v n para obtener el elemento n-ésimo (1 indexado)

1$1-:?!;$::n84*o1[0$          >:?!va2[$:{:@%:{$-{,]v
            v              <  ^   >~{]02.1+1+ffr+1r<
 :}[r]{  [01>:{*@@+$a*l2=?!^~]+ff+9+1g"3"=?v"3"ff+9+1pf0.
 :}[l01-$>    $:0(?v$@$:@@:@)?v@@1-$}v     >"2"ff+9+1p00.
>.       ^-1l v!?} <  .4a}$@@$<   .4a<
^26{]r0[}:{]~{<

Pruébalo en línea!Llame con -v npara obtener una lista de elementos n-1 que comienzan en 1

Intérprete de pescado en línea

Una larga y compleja, esta es OEIS A004000 .

Deje que a (n) = k, forme m invirtiendo los dígitos de k, agregue m a k Luego ordene los dígitos de la suma en orden creciente para obtener a (n + 1).

Ejemplo: 668 -> 668 + 866 = 1534 -> 1345.

Debido a que el código en> <> es bastante largo, el desafío es descifrarlo por $n = 34$. Estos 34 elementos hacen un total de 290 bytes, demasiado para codificar el resultado;)
Aquí están los 34 primeros elementos indexados en 1

1 2 4 8 16 77 145 668 1345 6677 13444 55778 133345 666677 1333444 5567777 12333445 66666677 133333444 556667777 1233334444 5566667777 12333334444 55666667777 123333334444 556666667777 1233333334444 5566666667777 12333333334444 55666666667777 123333333334444 556666666667777 1233333333334444 5566666666667777

Jalea , 6 bytes , ¡Seguro!

<4+ạ2ȯ

Esto define una secuencia de índice cero donde:

Como tal, los primeros dieciséis valores $a(0)\cdots a(15)$ son 1,1,1,2,2,3,4,5,6,7,8,9,10,11,12,13

Pruébalo en línea! ( aquí hay una versión de valor único)

Esto no está actualmente en el OEIS (aunque A34138 funcionará como un crack si es lo suficientemente corto)

Grieta prevista

La secuencia anterior coincide con el recuento de dígitos decimales del primer $16$términos de A062569 , la suma de los divisores del factorial de$n$(también indexado a cero).
los$17^{\text{th}}$término de A062569 , sin embargo, es$107004539285280$ que tiene $15$ dígitos, no $14=a(16)$.

El código necesario es de cinco bytes de jalea, !ÆsDL.

JavaScript, 26 bytes ( agrietado )

let f=x=>x>1?f(x-1)*f(x-2)+1:1

for (x of [0,1,2,3,4,5,6,7]) {
  console.log(x + ' -> ' + f(x))
}

OEIS A007660

La salida son los primeros 6 elementos con indexación 0 (1,1,2,3,7,22)

(algo cambiado de lo que OEIS tiene en la lista)

Simplemente creando una respuesta fácil de resolver para comenzar

Pruébalo en línea!

JavaScript, 16 bytes ( agrietado )

g=
x=>Math.exp(x)|0

tmp=[0,1,2,3,4]
console.log(tmp.map(g).join(','))

Los primeros 5 elementos de OEIS149 ($\lfloor e^n\rfloor$)

Las entradas requeridas para coincidir son 0,1,2,3,4.

Pruébalo en línea!

APL (Dyalog Unicode) , 17 15 bytes

⌈∊∘1 5+.633*5-⊢

Pruébalo en línea!

Los primeros 13 términos (basados ​​en 1) son:

2 1 1 1 2 2 3 4 7 10 16 25 39

Sugerencia: la solución prevista utiliza una de las funciones integradas menos utilizadas.

Casco , 5 bytes ( descifrado por Jonathan Allan )

Este es A000030 desplazado por$16$:

←d+16

Pruébalo en línea!

La secuencia está indexada a 0, salida para$0 \leq n < 23$:

Explicación

←d+16  -- example input:  23
  +16  -- add 16:         39
 d     -- digits:         [3,9]
←      -- extract first:  3

Solución

LdΣ

JavaScript, 25 bytes ( Cracked 21 bytes)

f=
x=>[7,11,12,13,13][x]||14

for(i=0;i<15;i++)
  console.log(i+"->"+f(i))

Secuencia de 7,11,12,13,13 seguida de 14s infinitos.

Solución prevista 22 bytes:

x = Math.atan (x + 1) * 10 | 0

Pruébalo en línea!

JavaScript, 22 bytes ( agrietado )

f=
x=>(3-(5/63)**.5)**x|1

for(y=0;y<16;y++)
  console.log(y +"->"+f(y))

Esto es 0 indexado y se requiere precisión hasta una entrada de 15. No se puede encontrar en OEIS

Mi solucion 20 bytes

x => 163 ** (32 * x / 163) | 1

Pruébalo en línea!

> <> , 42 bytes, agrietado

i3%0v
642 .
840
789
159
a 1
v<<
n
l
?
\/
;

Pruébalo en línea!

Secuencia para crackear (indexada a 0): 101786, 5844, 19902(no en OEIS).

Solución prevista , para referencia.

Perl 6 , 53 bytes

{(1,2,2,{$!=++$;prepend(@,2-$!%2 xx$_).pop}...*)[$_]}

Pruébalo en línea!

Bloque de código anónimo que devuelve la secuencia de Kolakoski indexada en 0 ( OEIS A000002 ). Se requieren soluciones para que coincidan con los primeros 130 elementos, por lo que para algunos n > 129difiere de la secuencia de Kolakoski.

Pascal (FPC) , 86 bytes ( agrietado )

var n:word;begin read(n);write(n div 2+n div 4+n div 8+n div 16+n div 32+n div 64)end.

Pruébalo en línea!

La secuencia debe ser igual hasta $n=120$. La secuencia de la entrada 0 a la entrada 120 es

0   0   1   1   3   3   4   4   7   7   8   8  10  10  11  11  15  15  16  16  18  18  19  19  22  22  23  23  25  25  26  26  31  31  32  32  34  34  35  35  38  38  39  39  41  41  42  42  46  46  47  47  49  49  50  50  53  53  54  54  56  56  57  57  63  63  64  64  66  66  67  67  70  70  71  71  73  73  74  74  78  78  79  79  81  81  82  82  85  85  86  86  88  88  89  89  94  94  95  95  97  97  98  98 101 101 102 102 104 104 105 105 109 109 110 110 112 112 113 113 116

var n,i,s:word;begin read(n);i:=2;repeat s:=s+n div i;i:=i*2until i>n;write(s)end.

¡pero r_64 lo hizo aún mejor !