Este es un desafío de policías y ladrones , el hilo de ladrones se puede encontrar aquí .

Su tarea es escribir algún código que genere una secuencia OEIS y contenga el nombre de la secuencia en el código ( A______) y genere una segunda secuencia separada cuando el nombre de la secuencia en el código se cambie por el nombre de la segunda secuencia.

Aquí hay un ejemplo en Haskell que funciona para A000217 y A000290 .

f x|last"A000217"=='0'=x^2|1>0=sum[1..x]

Pruébalo en línea!

Luego debes revelar una de las dos secuencias, y el código mantiene la segunda secuencia en secreto. Los ladrones intentarán descubrir cuál es la secuencia oculta. Si un ladrón logra determinar cuál es su secuencia (u otra secuencia que se ajuste a los criterios), su respuesta está descifrada. Si ninguno lo hace en una semana de publicación de su respuesta, puede marcar su respuesta como Segura y revelar la solución prevista para la verificación. Las respuestas seguras no se pueden descifrar.

De entrada y salida

^{Tomado de aquí}

El código puede ser una función o programa completo que lleva n a través de un método de entrada estándar y da salida a la n º término de la secuencia como indexado por el índice proporcionada en la página OEIS.

Debe admitir todos los valores proporcionados en los archivos b de OEIS para esa secuencia; no es necesario admitir cualquier número que no esté en los archivos b.

Puntuación

Su puntaje será el número de bytes en su código, con menos bytes mejor.

Python 3, 59 bytes, A162626 , descifrado por Wheat Wizard

lambda n:n*(n+1)*(n+2)/3if 0<=n<=3else n*(n**2+5)/3#A162626

Esto se suponía que era imposible, ¿verdad?

Python 3 , 62 bytes, A017016 ( Agrietado )

n=int(input())
print(sum(1for i in"A017016"if i>"0")*-~n//-~n)

Pruébalo en línea!

Japt , 13 bytes ( agrietado )

Hay (al menos) otra solución, si alguien más quiere apuñalarlo.

p#A000012uCnG

Pruébelo en línea
A000012

Explicación

#seguido de un carácter en Japt nos da el código de carácter de ese personaje, entonces #A=65, al cual el resto del número se agrega, dándonos 65000012o 65000290.

ues el método de módulo (difiere de %que siempre devolverá un número positivo).

El nmétodo resta el número al que se aplica del número que se le pasa. Cy Gson las constantes de Japt para 11 y 15, respectivamente. Entonces, CnGnos da 4.

Ahora tenemos 65000012%4=0y 65000290%4=2. El pmétodo eleva el número al que se aplica (en este caso, que es, implícitamente, el entero de entrada U) a la potencia del número que se le pasa, dándonos las 2 fórmulas finales de U**0y U**2.

MATL , 30 29 bytes ( Agrietado )

A077430I\2-|Gw^1Mwx*10&Ylk1+&

A077430

Pruébalo en línea!

-1 byte gracias a @Sanchises

C #, 28 bytes ( agrietado )

n=>n*n*("A000290"[6]<49?1:n)

Funciona con A000290 .

Una fácil para comenzar esto.

Pruébalo en línea!

Python 2, 43 bytes, A000079 ( Agrietado )

Pruébalo en línea

lambda n:((sum(map(ord,'A000079'))*2)%8)**n

C #, 75 bytes, ( Agrietado )

n=>{int r=1,e=3-0xA000244%2;for(;n>0;e*=e){r*=(n%2>0?e:1);n>>=1;}return r;}

A000244

Pruébalo en línea!

Python 2 , 53 bytes, A000012 [agrietado]

lambda x:len(`x**(sum(map(int,'A000012'[1:]))==22)`) 

Pruébalo en línea!

La siguiente secuencia es A055642 (longitud de dígitos en un número decimal). Para lo cual el número se evalúa a sí mismo, ya que la suma de los dígitos en OEIS es igual a 22; la len (...) calcula así la longitud real del número de entrada para 'A055642'. Para las secuencias A000012 (o cualquier otra que no sea A055642. La len siempre será igual a uno, ya que el número evaluado será '1'.

Python 3, 65 bytes, A000027, agrietado

a=lambda a,n=((int("A000027",11)-0x103519a)%100%30+1)/2:a//(14-n)

Yay aritmética loca!

Smalltalk, 148 bytes, ¡seguro!

|x o|x:=(16rA018253*0.00861-1445345)floor. o:=OrderedCollection new. 1 to:x/2 do:[:i|x\\i=0 ifTrue:[o add:i]].o add:x.^o at:stdin nextLine asInteger

A018253

Toma un entero como entrada, la secuencia se basa en 1.

La segunda secuencia prevista es A133020 . En el informe para A018253 hay un enlace a una lista de entradas para secuencias relacionadas con los divisores de números . En esa lista, A133020 está bajo divisores de cuadrados: 100² . Si desea ver la secuencia completa, inserte Transcript show: o printString; cr.antes de la ^declaración de devolución en el código.

Haskell, 226 bytes, ¡seguro!

No estoy seguro de si es inteligente o feo, tal vez ambos ...

o n=read.pure.(!!n)$"A001906"
m::Integral a=>[a->a->a]
m=[const,(+),(-),(*),div,(^)]++(flip<$>m)
l=o 1:o 3-o 1:zipWith(m!!(o 6+o 3-o 2))(tail l)l
f=(l!!).((m!!(o 4+o 5+o 6-2*o 1-o 2))$sum[1|n<-[1..6],odd(o n)]).((m!!o 6)$o 3)

Así que ahora esto calcula A001906 , pero debería ser capaz de generar muchas secuencias.

Pruébalo en línea!

Solución: A131078

¿Se pregunta si esto fue demasiado difícil o si nadie lo intentó?

o 1que o 6son los dígitos del número de serie, mse muestra una lista de las operaciones. les una lista infinita definida recursivamente con los dos primeros valores derivados del número de serie y los restantes calculados a partir de los dos anteriores utilizando una operación fija de m. En el caso de A001906, la definición se puede simplificar a

l=0:1:zipWith(flip(+))(tail l)l

(flip(+))es (generalmente) lo mismo (+)y obtenemos una definición bien conocida (pero no la más corta) de los números de Fibonacci. Este esquema de recursión podría calcular directamente A001906, pero eso necesita una operación más complicada que las de m. Otro ejemplo: el uso de valores de partida 1y 2y la operación (*)da la serie A000301 . Nuestro código lo calcula cuando el número de serie se reemplaza por ?103206.

Finalmente, la función se findexa en la lista l, pero solo después de alguna transformación de la entrada. Para A001906, la parte media se reduce a (*)2, de modo que solo obtenemos los números de Fibonacci en posiciones pares. La parte correcta se convierte flip const 1, que es la función de identidad y no interfiere más.

Para la solución A131078, los valores iniciales de lson 1y 0, y la operación es flip const, lo que permite lser 1,0,1,0,.... La parte media de se fconvierte (flip div 4), lo que resulta en 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,.... Esto parecía una buena respuesta, pero luego vi que A131078 comienza en n=1, así que agregué la parte correcta f, que aquí es flip(-)1restar una.

Mi idea era hacerlo un poco ofuscado al usarlo me indexarlo con dígitos de los números de serie, luego se volvió más ofuscado (términos complicados) para que funcionara (tal vez no estaba buscando las alternativas lo suficiente); y luego se volvió aún más ofuscado (parte correcta f) para que realmente funcione. Aún así, creo que algunas suposiciones e intentos podrían haberlo resuelto.

cc , 52 bytes, agrietado

Este funciona con A000217 :

?SaA000217d8d1+Sb%1r-dScla*r10 7^-Lb%+la*1+Lc+La*2/p

Pruébalo en línea!

Python 3.6, 114 bytes, agrietado

from random import*
g=lambda n:eval(''.join(Random("A005843").choices('n8-9+17n#8*+26%n1 32-3+4-545*-#6*7',k=34)))

A005843

g(n) devuelve el enésimo valor de la secuencia para n> = 0.

random.choices(s,k)es nuevo en Python 3.6, devuelve kelementos seleccionados scon reemplazo.

Chip , 67 bytes, agrietado por Yimin Rong

2D5B#{*Cm49!}E-7
(A000012d#,zkmsh
b-\6/e2)[1Zv^~^S
33a#kcf3g88taz1@

A000012 . Un poco descarado, sí.

Pruébalo en línea!

Utiliza bytes para E / S, así que fui agradable y construí un contenedor bashy / pythony.

La secuencia alternativa es A060843 . Pruébelo en línea para obtener entradas 1..4.

Yimin Rong se inclinó a la derecha, un programa Chip tan corto solo puede calcular cosas muy simples. La secuencia original es de uno y la secuencia alternativa son los números de castores ocupados, de los cuales solo se conocen 4.

Estos números, 1, 6, 21, 107simplemente están codificados para las entradas 1..4.

Una cosa interesante acerca del uso de la viruta para este reto es que los dígitos 0- 9no son números, sino elementos lógicos. Específicamente, 0- 7son los ocho bits que se dirigen al encabezado de la pila, 8y 9son los conmutadores de lectura y escritura. Eso lo hizo un poco más interesante y mucho más ofuscado.

Un regalo potencial es que sólo A- Daparecemos, lo que significa que sólo tenemos 4 bits para indexar la secuencia. Esto significaba que podría haber como máximo 16 valores diferentes. De hecho, sólo A- Cse utiliza efectivamente para la secuencia alterna, dando un máximo de 8 valores diferentes.

Para cualquiera que pueda estar interesado, aquí está el mismo código, despojado de los elementos no operativos y no utilizados:

.

   B  *C 49!
 A000012d ,z  s
b-\6/e   1Zv-~^S
`3a`-cf3g`8taz1