28

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.

code-golf sequence cops-and-robbers

— Asistente de trigo
fuente

Está claro que hay formas de resolver un problema de manera no matemática, como imprimir todos los casos de prueba, pero ese problema está condicionado a los casos provistos por la policía. ¿Debería haber una regla al respecto? ¿Existe alguna restricción contra la computabilidad de las secuencias o algo de la teoría de Ramsey? (es decir, ¿necesita poder descifrar su máquina?)

— theREALyumdub

2

@theReallyumdub la pregunta estipula que debes poder descifrar tu propia presentación.

— Wheat Wizard

@ CatWizard Gracias, seguí adelante y eso ya está en una meta publicación obvia, aparentemente impide que algunos de estos tipos. Por lo tanto, no está en el espíritu de la etiqueta hacer que una grieta tarde más de una hora en computarse o algo así

— theREALyumdub

44

spikedmath.com/062.html

— Giuseppe

¿Existe una condición de "aunque en teoría su solución debe funcionar para todos los números en la práctica, solo necesita funcionar para ..."?

— user202729

6

cQuents , 4 bytes ( agrietado )

"::$

Pruébalo en línea!

Aquí hay ocho ( n=8) casos:

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.

— Stephen
fuente

Agrietado.

— Bubbler

5

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]

— crashoz
fuente

Olvidé eliminar el espacio en blanco, todavía no soy un golfista experto: p ¿Te importa si edito para arreglar eso?

— crashoz

Claro, adelante. Me quitaré la grieta.

— Wheat Wizard

Agrietado

— xnor

5

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.

— xnor
fuente

Estoy bastante seguro de que no pretendiste quebrarte por esto ; tal vez especifique "Python (sin bibliotecas de terceros)" o "Python (sin importaciones)" o algo así?

— Jonathan Allan

@ JonathanAllan Gracias, edité que no hay bibliotecas de terceros.

— xnor

Todavía no he podido descifrar esto (mi mejor intento en este momento es de 47 bytes más o menos), pero creo que hay algo interesante que destacar sobre esos números primos en particular. Para cada

, con

, esto tiene:

. Al mismo tiempo, esto no es cierto para cualquier número que no sea primo (en el rango indicado anteriormente), pero sí

p_{i}

$p_i$

i \in [1, 50] \cap N

$i\in[1, 50]\cap \mathbb{N}$

2^{p_{i}} \equiv 2 (mod p_{i})

$2^{p_i}\equiv 2 (\text{mod } p_i)$ entonces para valores más altos. Dejo esta idea aquí para que otros puedan probar suerte usando la técnica mencionada, y tal vez obtener una mejor puntuación :)

— Sr. Xcoder

@ Mr.Xcoder Aquí está mi mejor intento basado en su método propuesto. Diverge con éxito en N = 69, devolviendo 341 (la primera pseudoprima de Fermat a la base 2, o el primer número de Poulet) pero también falla para N = 1. Dudo que pueda solucionarlo por mi cuenta, así que pensé que sería mejor compartir lo que tengo. (Mi mejor solución es 46 bytes ...)

— Arnauld

1

@Arnauld Encontré una solución de 44 bytes usando este método. Parece que no puedo ir más allá. Tal vez alguien más pueda resolver esto.

— Poon Levi el

4

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^#]&

— JungHwan Min
fuente

3

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 y . $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 a : $b(n) = n\ len(3^n) = n \lceil log_{10}(1+3^n)\rceil$ $0$ $22$

_fuente

— Laikoni
fuente

agrietado

— ბიმო

@Laikoni, si el crack previsto es más corto, entonces alguien más podría reclamar al ladrón de BMO.

— fəˈnɛtɪk 01 de

@ fəˈnɛtɪk Gracias, no estaba al tanto de esta regla.

— Laikoni 01 de

@BMO re-craqueado

— Ørjan Johansen

2

@BMO Allá vas :)

— Laikoni

2

JavaScript (ES6), 12 bytes ( agrietado )

Este es bastante fácil.

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

Pruébalo en línea!

Esta es A139275 :

una (norte) = norte (8 norte + 1)

$a(n) = n(8n+1)$

$0\le n<9$

0 0, 9 9, 34, 75, 132, 205, 294, 399, 520

$0, 9, 34, 75, 132, 205, 294, 399, 520$

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

— Arnauld
fuente

n=>8*n*n+ndifiere para n=94906273, ¿es esta una grieta válida?

— ngn

@ngn Me parece válido de acuerdo con las reglas de desafío, pero tal vez debería preguntarle al OP si la pérdida de precisión cuenta como una divergencia válida. Sin n=9embargo, la grieta prevista es diferente .

— Arnauld

@ CatWizard ^

— ngn

Yo diría que es un crack válido.

— Wheat Wizard

2

agrietado (en |lugar de +)

— ngn

2

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

— Pomo de la puerta
fuente

2

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

— crashoz
fuente

¿Cómo se ejecuta el programa para producir un solo resultado para un determinado n(como lo requiere la pregunta)?

— Jonathan Allan

Como en realidad no hay "funciones" en fish, agregué una versión a la que puede llamar para obtener el n-ésimo (que es esencialmente el mismo, porque tiene que calcular los elementos anteriores n-1)

— crashoz

Más importante aún, ¿tiene una grieta que se ajuste a la misma indexación de entrada que produce la salida única?

— Jonathan Allan

1

Creo que sí, puedo hacer una función que hace la misma secuencia para

1 <= n <= 34

$1<=n<=34$ pero es diferente para

n > 34

$n>34$ siendo ~ 30 bytes más corto

— crashoz

Agrietado

— Jo King

2

Jalea , 6 bytes , ¡Seguro!

<4+ạ2ȯ

Esto define una secuencia de índice cero donde:

una (norte) = {\begin{cases} 1 & norte < 3 \\ 2 & norte = 3 \\ norte - 2 & norte > 3 \end{cases}

$a(n) = \begin{cases} 1 & n<3 \\ 2 & n=3 \\ n-2 & n>3 \end{cases}$

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.

— Jonathan Allan
fuente

1

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

Expandir fragmento

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!

— fəˈnɛtɪk
fuente

Agrietada .

— Sr. Xcoder

¿La salida de su fragmento de ejemplo comienza en 1, no en 0?

— Paŭlo Ebermann

@ PaŭloEbermann Solucionó eso

— fəˈnɛtɪk

1

JavaScript, 16 bytes ( agrietado )

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

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

Expandir fragmento

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!

— fəˈnɛtɪk
fuente

Agrietado

— Sr. Xcoder

1

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.

— Bubbler
fuente

agrietado

— ngn

Actualizado @ngn la presentación policía :)

— pelele

1

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

1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3

$1,1,1,1,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3$

Explicación

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

Solución

LdΣ

— ბიმო
fuente

agrietado

— Jonathan Allan

1

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

Expandir fragmento

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!

— fəˈnɛtɪk
fuente

Agrietado

— Arnauld

0

JavaScript, 22 bytes ( agrietado )

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

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

Expandir fragmento

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!

— fəˈnɛtɪk
fuente

Agrietada .

— Sr. Xcoder

0

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

— Aidan F. Pierce
fuente

Agrietado

— Jo King

Por lo general, los ladrones deberían estar codificando la salida

— Jo King

@JoKing Su crack no parece producir ningún valor diferente al mío (o tal vez no lo he probado lo suficiente como para encontrar qué valores difieren), pero eso probablemente sea fácilmente rectificable. Si bien no parece haber nada en las reglas que prohíban la codificación rígida, estoy de acuerdo en que puede no ajustarse al espíritu del desafío; en cualquier caso, usted ha demostrado que la codificación rígida (para un policía) conlleva sus propios riesgos.

— Aidan F. Pierce

1

He actualizado mi respuesta para producir un valor diferente para4

— Jo King

0

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.

— Jo King
fuente

0

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

Mi solución original fue

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 !

— AlexRacer
fuente

agrietado

— Wheat Wizard

Codificar a los policías y ladrones (policías)

Reto

Tanteo

cQuents , 4 bytes ( agrietado )

Python 3 , 66 57 bytes ( Agrietado )

Python 2 , 44 bytes ( agrietado )

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

Grieta prevista

Haskell , 29 bytes (Agrietado: 1 , 2 )

Solución prevista (20 bytes)

JavaScript (ES6), 12 bytes ( agrietado )

Malbolge, 10 bytes

> <> , 276 bytes ( Agrietado )

Jalea , 6 bytes , ¡Seguro!

Grieta prevista

JavaScript, 26 bytes ( agrietado )

JavaScript, 16 bytes ( agrietado )

APL (Dyalog Unicode) , 17 15 bytes

Casco , 5 bytes ( descifrado por Jonathan Allan )

Explicación

Solución

JavaScript, 25 bytes ( Cracked 21 bytes)

JavaScript, 22 bytes ( agrietado )

> <> , 42 bytes, agrietado

Perl 6 , 53 bytes

Pascal (FPC) , 86 bytes ( agrietado )