Este é um desafio de policiais e ladrões , o segmento de ladrões pode ser encontrado aqui .

Sua tarefa é escrever um código que produza uma sequência OEIS e contém o nome da sequência no código ( A______) e gera uma segunda sequência separada quando o nome da sequência no código é alterado para o nome da segunda sequência.

Aqui está um exemplo em Haskell que funciona para A000217 e A000290 .

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

Experimente online!

Você deve revelar uma das duas seqüências e o código mantendo a segunda sequência em segredo. Os ladrões tentarão descobrir qual é a sequência oculta. Se um ladrão conseguir determinar qual é a sua sequência (ou outra sequência que se encaixa nos critérios), você responde está quebrado. Se nenhum fizer isso na semana em que sua resposta for publicada, você poderá marcar sua resposta como Segura e revelar a solução pretendida para verificação. Respostas seguras não podem ser quebradas.

Saída de entrada

^{Retirado daqui}

O seu código pode ser uma função ou um programa completo que tem n através de um método padrão de entrada e emite o n ésimo termo da sequência como indexada pelo índice fornecido na página OEIS.

Você deve suportar todos os valores fornecidos nos arquivos OEIS b para essa sequência, qualquer número que não esteja nos arquivos b não precisa ser suportado.

Pontuação

Sua pontuação será o número de bytes no seu código, com menos bytes sendo melhores.

Python 3, 59 bytes, A162626 , quebrado pelo Wheat Wizard

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

Este é era suposto ser impossível, não era?

Python 3 , 62 bytes, A017016 ( rachado )

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

Experimente online!

Japt , 13 bytes ( Rachado )

Existe (pelo menos) uma outra solução, se alguém quiser dar uma facada nela.

p#A000012uCnG

Experimente online
A000012

Explicação

#seguido por um caractere em Japt nos fornece o código de caractere desse caractere, portanto #A=65, ao qual o restante do número é anexado, fornecendo-nos 65000012ou 65000290.

ué o método modulo (difere de %sempre retornar um número positivo).

O nmétodo subtrai o número ao qual é aplicado do número passado para ele. Ce Gsão as constantes Japt para 11 e 15, respectivamente. Então, CnGnos dá 4.

Agora temos 65000012%4=0e 65000290%4=2. O pmétodo aumenta o número ao qual é aplicado (neste caso, implicitamente, o número inteiro de entrada U) à potência do número passado a ele, fornecendo as 2 fórmulas finais de U**0e U**2.

MATL , 30 29 bytes ( rachado )

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

A077430

Experimente online!

-1 byte graças a @Sanchises

C #, 28 bytes ( rachado )

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

Funciona com A000290 .

Fácil de começar.

Experimente online!

Python 2, 43 bytes, A000079 ( rachado )

Experimente online

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

C #, 75 bytes, ( Rachado )

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

A000244

Experimente online!

Python 2 , 53 bytes, A000012 [rachado]

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

Experimente online!

A próxima sequência é A055642 (comprimento de dígitos em um número decimal). Para o qual o número é avaliado por si próprio, uma vez que a soma dos dígitos no OEIS é igual a 22; o len (...) calcula, assim, o comprimento real do número de entrada para 'A055642'. Para as seqüências A000012 (ou qualquer outra que não seja A055642. O len sempre será igual a um, pois o número avaliado será '1'.

Python 3, 65 bytes, A000027, quebrado

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

Yay aritmética louca!

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

Pega um número inteiro como entrada, a sequência é baseada em 1.

A segunda sequência pretendida é A133020 . No registro para A018253, há um link para uma lista de entradas para sequências relacionadas aos divisores de números . Nessa lista, A133020 está sob divisores de quadrados: 100² . Se você quiser ver a sequência inteira, insira Transcript show: o printString; cr.antes da ^instrução de retorno no código.

Haskell, 226 bytes, seguro!

Não tenho certeza se inteligente ou feio, talvez 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)

Então agora isso calcula A001906 , mas deve ser capaz de gerar muitas sequências.

Experimente online!

Solução: A131078

Querendo saber se isso foi muito difícil ou ninguém tentou?

o 1to o 6são os dígitos do número da série, mé uma lista de operações. lé uma lista infinita definida recursivamente com os dois primeiros valores derivados do número de série e os demais computados dos dois anteriores usando uma operação fixa de m. No caso de A001906, a definição pode ser simplificada para

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

(flip(+))é (geralmente) o mesmo que (+), e obtemos uma definição bem conhecida (mas não a mais curta) dos números de Fibonacci. Esse esquema de recursão poderia computar diretamente o A001906, mas precisa de uma operação mais complicada do que a do Windows m. Um outro exemplo: utilizando os valores iniciais 1e 2e a operação (*)dá a série A000301 . É calculado pelo nosso código quando o número da série é substituído por?103206 .

Por fim, a função findexa na lista l, mas somente após alguma transformação da entrada. Para A001906, a parte do meio se reduz a (*)2, de modo que apenas os números de Fibonacci são obtidos em posições pares. A parte certa se torna flip const 1, que é a função de identidade e não interfere ainda mais.

Para a solução A131078, os valores iniciais de lsão 1e 0, e a operação é flip const, o que permite lser 1,0,1,0,.... A parte do meio de ftorna-se (flip div 4), resultando em 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,.... Parecia uma boa resposta, mas vi que o A131078 começa em n=1, então adicionei a parte correta f, que aqui é flip(-)1subtrair uma.

Minha idéia era torná-lo um pouco ofuscado, usando-o me indexando-o com dígitos dos números de série; depois, ficava mais ofuscado (termos complicados) fazê-lo funcionar (talvez eu não estivesse procurando o suficiente por alternativas); e então ficou ainda mais ofuscado (parte certa f) para fazê-lo realmente funcionar. Ainda acho que algumas tentativas e adivinhações poderiam ter quebrado.

dc , 52 bytes, quebrado

Este funciona com A000217 :

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

Experimente online!

Python 3.6, 114 bytes, cracked

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) returns the n-th value of the sequence for n >= 0.

random.choices(s,k) is new in Python 3.6, it returns k items selected from s with replacement.

Chip, 67 bytes, cracked by Yimin Rong

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

A000012. A bit cheeky, yes.

Try it online!

Uses bytes for i/o, so I was nice and built a bashy/pythony wrapper.

A sequência alternativa é A060843 . Experimente online para entradas 1..4.

Yimin Rong curvou-se à direita, um programa tão curto de Chip só pode calcular coisas muito simples. A sequência original é toda sua, e a sequência alternativa são os números de castores ocupados, dos quais apenas 4 são conhecidos.

Esses números, 1, 6, 21, 107são simplesmente codificados para as entradas 1..4.

Uma coisa interessante sobre o uso do Chip para esse desafio é que os dígitos 0- 9não são números, mas elementos lógicos. Especificamente, 0- 7são os oito bits que endereçam a cabeça da pilha e 8e 9são as opções de leitura e gravação. Isso tornou isso um pouco mais interessante e muito mais ofuscado.

Uma oferta potencial é apenas isso A-D appear, meaning that we only have 4 bits for indexing the sequence. This meant that there could be at most 16 different values. In fact, only A-C are actually used for the alternate sequence, giving at most 8 different values.

For any who might be interested, here is the same code, stripped of the no-ops and unused elements:

.

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