Se trata de policías y ladrones si no está familiarizado con el formato, haga clic en la etiqueta para ir a la wiki. No habrá un hilo de ladrones para esta pregunta.

Policías

Su tarea como policías es seleccionar dos secuencias de la Enciclopedia en línea de secuencias enteras y escribir un programa que tome el enésimo elemento de una secuencia como entrada y salga el enésimo elemento de la segunda secuencia. Luego realiza una respuesta que incluye el código y omite las secuencias seleccionadas. Los ladrones intentarán encontrar las secuencias que seleccionó y si se las arregla para encontrar las secuencias que tenía en mente u otras secuencias para las cuales su programa debe marcar su respuesta como Agrietada . Si un ladrón le informa con un crack que cree que no es válido, puede presentar una prueba de que no es un crack. De lo contrario, debe marcarlo así.

Según las respuestas habituales que se han descifrado durante 7 días, se pueden marcar como seguras. Un policía puede marcar su respuesta como segura al revelar las secuencias que tenían en mente. Una vez segura, una respuesta ya no se puede descifrar.

El objetivo es minimizar el recuento de bytes de su programa mientras permanece sin descifrar.

Ejemplo

El siguiente código de Python traduce el enésimo elemento de A000290 (los números cuadrados) en A000217 (los números triangulares):

lambda x:sum(range(0,int(x**.5+1)))

Estipulaciones y requisitos

• Si elige una secuencia que no se ha demostrado que sea finita, debe generar todos los términos que puedan existir, no solo los que figuran en la página OEIS

• Como excepción a los lenguajes de regla anteriores sin enteros de precisión infinita, no es necesario que emitan o ingresen números fuera de su rango.

• El tamaño de su secuencia de entrada no debe haber demostrado ser más pequeño que la secuencia de salida.

• Su secuencia de entrada no debe tener elementos de repetición (de lo contrario, la tarea es prácticamente imposible)

• El OEIS incluye un índice en su página (el primer número después del encabezado "OFFSET") de manera predeterminada, este es su desplazamiento para n (n es igual al índice para el primer elemento de la secuencia) si elige otro índice, debe indicarlo en tu respuesta.

• Si elige un desplazamiento diferente del que aparece en el OEIS, aún debe asignar todos los elementos en su secuencia de entrada al elemento correspondiente en su secuencia de salida.

• Si su programa recibe una entrada que no está en la secuencia de entrada, puede hacer lo que desee (comportamiento indefinido). Sin embargo, probablemente sea de su mayor interés que aún genere un número entero.

• Es antideportivo hacer que su código sea difícil de ejecutar intencionalmente, ya sea haciendo que su ejecución sea lenta o una selección de idioma no libre . Si bien haré cumplir lo último, no puedo hacer cumplir objetivamente lo primero. Sin embargo, te ruego, por diversión, que no intentes lo primero, ya que hace que el desafío sea específicamente más difícil para aquellos con computadoras más débiles.

Ladrones

Su tarea como ladrones es seleccionar respuestas no resueltas, inseguras y encontrar las secuencias entre las que se asignan. Si encuentra una solución que funcione (no necesariamente la solución prevista por los policías) comente las secuencias en la respuesta adecuada.

Los ladrones no deberían preocuparse demasiado por verificar que dos secuencias particulares son una solución, uno debe publicar una solución si coincide con todas las entradas en OEIS. Si esa no es la secuencia que un policía tenía en mente, el policía puede ofrecer una prueba de que es incorrecta o marcarla como agrietada si no puede encontrarla.

Jalea , 14 bytes (Craqueado por @Wolfram)

+66%444µ111<µ¡

Pruébalo en línea!

Debería ser bastante obvio lo que esto hace. De hecho, para beneficio de los usuarios que no son Jelly, incluso daré una explicación:

Explicación

+66%444µ111<µ¡
       µ    µ¡  Run the transformation
+66%444           "add 66, then modulo 444"
        111<    once if 111 is less than the input, zero times otherwise 

La pregunta es, ¿por qué hace esto?

Grieta

Las secuencias en cuestión fueron A201647 y A201647 . Son finitos y difieren solo en los últimos 2 elementos:

• 3, 5, 7, 9, 11, 15, 21, 165, 693
• 3, 5, 7, 9, 11, 15, 21, 231, 315

Por lo tanto, si la entrada es baja, la dejo igual, y simplemente ajusto una función a la transformación de las dos últimas.

Jelly , 7 bytes (Craqueado por @JonathanAllan)

ÆFḅÆdÆẸ

Pruébalo en línea!

Que hace

ÆFḅÆdÆẸ  Main link. Argument: n

ÆF       Factor n into prime-exponent pairs.
   Æd    Compute σ, the number of divisors of n.
  ḅ      Convert each pair from base σ to integer.
     ÆẸ  Yield the integer whose prime signature (infinite sequence of all prime
         exponents, including zeroes, in order) is equal to the result.

Python 3, 256 bytes ( ¡Agrietado! )

from math import*
def p(i,m):
 r=0;d=floor(log(i))
 for y in range(d):r+=(pow(16,d-y-1)%(8*y+m))/(8*y+m)
 o=-1;y=d
 while r!=o:o=r;r+=pow(16,d-y-1)/(8*y+m);y+=1
 return r
def q(n):r=4*p(n,1)-2*p(n,4)-p(n,5)-p(n,6);return floor((1-(-r%1)if r<0 else r%1)*16)

Pruébalo en línea!

Lo siento si este código se ve horrible, creo que este es mi primer Python golf. El casting en Python hace que sea más fácil codificar.

Procesando , 184 bytes, ¡SEGURO!

int x(int y){int b=TRIANGLES-MITER;for(int i=OVERLAY/BURN;i>#fffffe;b*=(int)pow(y,(MOVE-HAND+0.)/(int)sqrt(red(color(-1<<16))/(int)log(color(0)*color(-1)))),i-=QUAD/DARKEST);return b;}

Una función que toma un int y devuelve un int. Mientras el número de entrada esté enint del rango, el programa debería funcionar bien.

Esto no es lento, simplemente ilegible. ¡Buena suerte!

Me sorprende que esta presentación haya durado tanto tiempo. Oh, bueno, al menos es la primera presentación segura :)

A000578 a A000290

En otras palabras: los cubos a los cuadrados.

Explicación

Al responder Sin cadenas (o números) adjuntos , descubrí una lista de constantes de procesamiento que representan ints. Por ejemplo, CORNERtiene un valor de 0. La lista completa se puede encontrar aquí . Para encontrar el valor de una constante, simplemente puede printhacerlo.

Usando esto, decidí intercambiar ciertos números con combinaciones de estas constantes para ofuscarlo. Entonces, esto es lo que obtienes cuando sustituyes las constantes con sus respectivos valores int.

int x(int y){int b=9-8;for(int i=512/8192;i>#fffffe;b*=(int)pow(y,(13-12+0.)/(int)sqrt(red(color(-1<<16))/(int)log(color(0)*color(-1)))),i-=16/16);return b;}

Incluso ahora, el código claro completo no se revela. Quedan los colores. En Processing, las variables de color tienen valores int, por ejemplo white ( #ffffff) is -1, #fffffeis -2, #fffffdis -3, etc. Esto se puede encontrar printing ing color. Entonces simplifiquemos los colores.

int x(int y){int b=9-8;for(int i=512/8192;i>-2;b*=(int)pow(y,(13-12+0.)/(int)sqrt(red(color(-1<<16))/(int)log(-16777216*-1))),i-=16/16);return b;}

Estamos a la mitad del camino :) Para comprender los valores, necesitamos simplificar las expresiones numéricas.

int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/(int)sqrt(red(color(-65536))/(int)log(16777216))),i-=1);return b;}

Mucho más claro! Ahora simplifiquemos el logaritmo.

int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/(int)sqrt(red(color(-65536))/(int)16.6...)),i-=1);return b;}


int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/(int)sqrt(red(color(-65536))/16)),i-=1);return b;}

¡Casi terminado! Ahora tenemos que resolver este (int)sqrt(red(color(-65536))/16))bocado. color(-65536)es rojo, entonces rgb(255, 0, 0). Ahora la red()función devuelve el valor del componente rojo en el argumento (que es un color). Entonces, ¿cuánto rojo hay en rojo? La respuesta es 255. Con eso obtenemos

(int)sqrt(255/16))
(int)sqrt(15)
(int)3.8...
3

Sustituir esto en el programa da como resultado:

int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/3),i-=1);return b;}

¡Ya está hecho!

int x(int y){                        // y is the cube
  int b=1;                           // variable that holds the final result
  for(int i=0;                       // for-loop that
          i>-2;                      // loops twice
          b*=(int)pow(y,(1.)/3),     // multiply b by the cube root of y
          i-=1);                     // decrement the looping variable
  return b;                          // finally return b
}

Para resumir, esto devuelve el cuadrado (hecho multiplicando dos veces en el ciclo for) de la raíz cúbica del número de entrada.

Mathematica (o lo que sea) -  ¡Agrietado!

f[x_] := Quotient[ 366403414911466530559405368378193383110620062 - 
    755296348522256690003418238667147075159564695 x + 
    525778437135781349270885523650096958873079916 x^2 - 
    156594194215500250033652167655133583167162556 x^3 + 
    20861131421245483787723229627506507062999392 x^4 - 
    1181515772235154077024719095229309394979146 x^5 + 
    29382627265060088525632055454760915985604 x^6 - 
    308672970015057482559939241399297150364 x^7 + 
    1087516675449597417990589334580403666 x^8 - 
    312989984559486345089577524231879 x^9, 
  265451130886621254401938908479744271974400 ]

Sé que Mathematica es un software no libre, pero esta función es trivial para transferir a cualquier idioma favorito en el que desee ejecutarlo. Literalmente calcula el valor del polinomio de grado 9 evaluado en el entero de entrada, luego toma el cociente entero de ese valor y el número de 42 dígitos en la última línea. Por ejemplo, f[100]evalúa a -3024847237.