Este é um caso de policiais e ladrões, se você não estiver familiarizado com o formato, clique na tag para acessar o wiki. Não haverá um tópico de ladrões para esta pergunta.

Policiais

Sua tarefa como Policiais é selecionar duas seqüências da Enciclopédia Online de Sequências Inteiras e escrever um programa que considere o enésimo elemento de uma sequência como entrada e emita o enésimo elemento da segunda sequência. Você faz uma resposta incluindo o código e omitindo as seqüências selecionadas. Os ladrões tentarão encontrar as seqüências que você selecionou e se alguém conseguir encontrar as sequências que você tinha em mente ou algumas outras sequências para as quais seu programa deve marcar sua resposta como Cracked . Se um ladrão informar com um crack que você acredita que não é válido, você poderá apresentar uma prova de que não é um crack. Caso contrário, você deve marcar isso.

De acordo com as respostas usuais que foram decifradas por 7 dias, são elegíveis para serem marcadas como seguras. Um policial pode marcar sua resposta como segura, revelando as seqüências que eles tinham em mente. Uma vez segura, uma resposta não pode mais ser quebrada.

O objetivo é minimizar a contagem de bytes do seu programa enquanto permanece inalterado.

Exemplo

O código Python a seguir converte o enésimo elemento de A000290 (os números quadrados) em A000217 (os números triangulares):

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

Estipulações e Requisitos

• Se você escolher uma sequência que não tem provado ser finita, deverá gerar todos os termos que possam existir, não apenas os listados na página OEIS

• Como exceção às linguagens de regras anteriores, sem números inteiros de precisão infinita, não é necessário gerar ou inserir números fora de seu intervalo.

• O tamanho da sua sequência de entrada não deve ter sido provado ser menor que a sequência de saída.

• Sua sequência de entrada não deve ter nenhum elemento de repetição (caso contrário, a tarefa é praticamente impossível)

• O OEIS inclui um índice em sua página (o primeiro número após o cabeçalho "OFFSET"), por padrão, esse é o seu deslocamento para n (n é igual ao índice do primeiro elemento da sequência). Se você escolher outro índice, deverá indicar isso em sua resposta.

• Se você escolher um deslocamento diferente daquele listado no OEIS, ainda deverá mapear todos os elementos em sua sequência de entrada para o elemento correspondente em sua sequência de saída.

• Se o seu programa receber uma entrada que não esteja na sequência de entrada, poderá fazer o que quiser (comportamento indefinido). No entanto, provavelmente é do seu interesse continuar produzindo um número inteiro.

• Não é antidesportivo intencionalmente dificultar a execução do código, seja demorado para executar ou através da seleção de idiomas não livres . Enquanto eu aplicarei o último, não posso aplicá-lo objetivamente. No entanto, eu imploro, por uma questão de diversão, que não tente o primeiro, pois isso dificulta especificamente o desafio para aqueles com computadores mais fracos.

Ladrões

Sua tarefa como ladrões é selecionar respostas não rachadas e inseguras e encontrar as seqüências entre as quais eles mapeiam. Se você encontrar uma solução que funcione (não necessariamente a solução pretendida pelos policiais), comente as seqüências na resposta apropriada.

Os ladrões não devem se preocupar muito em verificar se duas seqüências específicas são uma solução; uma deve postar uma solução se corresponder a todas as entradas no OEIS. Se essa não é a sequência que um policial teve em mente, ele pode oferecer uma prova de que está incorreto ou marcá-lo como quebrado se não conseguir encontrar um.

Geléia , 14 bytes (Rachado por @Wolfram)

+66%444µ111<µ¡

Experimente online!

Deve ser bastante óbvio o que isso faz. De fato, para o benefício dos usuários que não são do Jelly, darei uma explicação:

Explicação

+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 

A questão é: por que isso acontece?

Rachadura

As sequências em questão foram A201647 e A201647 . Eles são finitos e diferem apenas nos dois últimos elementos:

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

Assim, se a entrada é baixa, deixo a mesma e simplesmente encaixo uma função na transformação das duas últimas.

Jelly , 7 bytes (Rachado por @JonathanAllan)

ÆFḅÆdÆẸ

Experimente online!

O que faz

Æ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 ( Rachado! )

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)

Experimente online!

Desculpe se este código parece horrível, acho que este é o meu primeiro golfe em Python. A conversão em Python facilita o código.

Processando , 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;}

Uma função que recebe um int e retorna um int. Enquanto o número de entrada estiver emint intervalo, o programa deve funcionar bem.

Isso não é lento, apenas ilegível. Boa sorte!

Estou surpreso que esta submissão tenha durado tanto tempo. Oh bem, pelo menos é a primeira submissão segura :)

A000578 a A000290

Em outras palavras: os cubos para os quadrados.

Explicação

Ao responder Sem seqüências de caracteres (ou números) anexadas , descobri uma lista de constantes de processamento que representam ints. Por exemplo, CORNERtem um valor de 0. A lista completa pode ser encontrada aqui . Para encontrar o valor de uma constante, você pode justamente printisso.

Usando isso, decidi trocar certos números com combinações dessas constantes para ofuscá-lo. Então, aqui está o que você obtém quando substitui as constantes pelos 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;}

Mesmo agora, o código claro completo não é revelado. As cores estão restantes. No processamento, as variáveis ​​de cores têm valores int, por exemplo, branco ( #ffffff) é -1, #fffffeé -2, #fffffdé -3e assim por diante. Isso pode ser encontrado pela printcor. Então, vamos simplificar as cores.

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 na metade do caminho :) Para entender os valores, precisamos simplificar as expressões 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;}

Muito mais claro! Agora vamos simplificar o 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;}

Quase acabando! Agora temos que descobrir esse (int)sqrt(red(color(-65536))/16))bocado. color(-65536)é vermelho, então rgb(255, 0, 0). Agora a red()função retorna o valor do componente vermelho no argumento (que é uma cor). Então, quanto de vermelho existe em vermelho? A resposta é 255. Com isso temos

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

Substituindo isso no programa resulta em:

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

Yay, está feito!

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, isso retorna o quadrado (feito multiplicando duas vezes no loop for) da raiz do cubo do número de entrada.

Mathematica (ou o que for) -  Rachado!

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 ]

Eu sei que o Mathematica é um software não-livre, mas essa função é trivial para ser portada para qualquer idioma favorito em que você deseja executá-lo. Ele literalmente calcula o valor do polinômio grau-9 determinado avaliado no número inteiro de entrada e, em seguida, pega o quociente inteiro desse valor e do número de 42 dígitos na última linha. Por exemplo, f[100]avalia como -3024847237.