Procurando sequências de trocas secretas

19

Este é um desafio de , 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.

Assistente de Trigo
fonte
11
Sua pontuação será o número de bytes no seu código, com menos bytes sendo melhores. - Por que isso não está marcado código-golfe , então?
Mr. Xcoder
@ Mr.Xcoder eu esqueci. Não leia essas coisas demais;) #
Wheat Wizard
Portanto, o código deve produzir uma sequência de algum comprimento (definido ou não?) Ou o n-ésimo elemento da sequência?
Morto Possum
@DeadPossum n º termo .
Sr. Xcoder
@ WheatWizard acho que eu estava procurando em outro lugar, mas monitor. Meu mal
Dead Possum

Respostas:

5

Python 3 , 62 bytes, A017016 ( rachado )

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

Experimente online!

Mr. Xcoder
fonte
Tentei fazê-lo tão ofuscado possível ...
Mr. Xcoder
11
@officialaimm Eu fiz isso de propósito. Eu quero fazer isso ofuscado. Eu realmente não se preocupam com golfe, porque Python não vai ganhar um concurso de ofuscação de código-golf: p
Mr. Xcoder
11
Rachado?
totallyhuman
A propósito, essa foi a solução pretendida?
totallyhuman
@totallyhuman Sim, foi a solução ideal.
Mr. Xcoder
4

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.

Shaggy
fonte
rachado?
officialaimm
11
@officialaimm: Correto, bem feito.
Shaggy
Como não conheço Japt, assumi que o poder a ser aumentado era (sum_of_numbers_in_oeis(excluding 'A') + 1)%4. : D
officialaimm
11
@officialaimm: Adoro ver ladrões quebrar desafios em idiomas que eles não conhecem :) Na verdade, eu postei isso com a esperança de que alguém que não conheça Japt tenha conhecimento.
Shaggy
A020338 também pode funcionar se a entrada de sequência for permitida (indexada 1).
Bubbler
4

MATL , 30 29 bytes ( rachado )

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

A077430

Experimente online!

-1 byte graças a @Sanchises

Cinaski
fonte
11
Deve ser corrigido agora
Cinaski
11
Apenas uma dica: você pode substituir `3` por I1 byte.
Sanchises
@Sanchises Thanks! Não sabia que Ifoi inicializado para 3
Cinaski 4/17/17
2
Você deve verificar a Tabela 3. Juntamente com l(um) e O(zero), você quase nunca precisará usar um espaço em seus programas MATL. Em uma nota relacionada, consulte a Tabela 7, bem como, o qual contém muitas constantes predefinidas úteis (embora tenha cuidado que por exemplo 4X2Z%tem uma forma abreviada 1Z%)
Sanchises
3

C #, 28 bytes ( rachado )

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

Funciona com A000290 .

Fácil de começar.

Experimente online!

TheLethalCoder
fonte
Ainda não pode ser
decifrado
@ Mr.Xcoder Can now :)
TheLethalCoder 3/17/17
11
Craked (embora não seja realmente rachado!)
Shaggy
@Shaggy Eu só queria fazer a bola rolar: P
TheLethalCoder
3

Python 2, 43 bytes, A000079 ( rachado )

Experimente online

lambda n:((sum(map(ord,'A000079'))*2)%8)**n
Gambá morto
fonte
Rachado?
TheLethalCoder
@TheLethalCoder Bem .. Cabe, mas não é o que eu escolhi. Também fiz editar antes de seu comentário, e ele se encaixa não mais
Morto Possum
5
Você mudou depois de postar? Um pouco injusto.
TheLethalCoder
@TheLethalCoder eu fiz isso para proteger deste falso-positivo seqüência: C
Morto Possum
11
Não sei sobre a edição de uma entrada, mas pelas regras do OP: " Se um ladrão conseguir determinar qual é a sua sequência (ou outra sequência que se encaixa nos critérios), a resposta será quebrada ", apenas para sua informação.
Alleks
3

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!

TheLethalCoder
fonte
Cracked
Lynn
@ Lynn O que deu de presente? A primeira sequência?
TheLethalCoder 3/17/17
3
Você está usando o número OEIS % 2- para que o programa possa literalmente fazer apenas duas coisas , dependendo do resultado: uma para 0e outra para 1. Então, coloquei um número ímpar em seu lugar, e o desafio meio que se rompeu.
Lynn
@ Lynn Ah, suponha, não achou ofuscante essa parte.
TheLethalCoder 3/17/17
2

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

officialaimm
fonte
11
Rachado?
totallyhuman
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!

pppery
fonte
Hum, A004526, dá o n=12que parece certo, mas o resultado será reduzido em um índice - eu rachei com insetos ou caí em um arenque vermelho muito inteligente?
Jonathan Allan
Nem; você interpretou mal o A004526, que afirma claramente a(n) = floor(n/2); a sequência listada começa com 0. Essa é a solução pretendida, no entanto.
precisa saber é
Oh sim, o deslocamento - certo (ufa), obrigado! Bem rachado então.
Jonathan Allan
1

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.


fonte
1

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.

Peneiradores cristãos
fonte
Tentei algumas sequências e elas geralmente davam divisão por zero erros, erros negativos de expoentes ou pareciam funcionar para sempre. Para ser sincero, Haskell me assusta , parece que não consigo entender, gastando muito tempo em procedimentos, eu acho.
Se você está apenas tentando, existe o problema extra de que mesmo a solução gera um erro de "índice negativo" quando fornecida 0. Tudo bem, porque só começa às 1! A partir de 1também deve remover alguns dos erros "divisão por zero". Estou surpreso com exemplos que correm para sempre. Talvez a transformação índice cria valores muito grandes nestes casos ...
Christian Sievers
0

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.

RootTwo
fonte
Feel very much like encryption/hashing.
pppery
@ppperry - if that's against the rules, I'll remove it.
RootTwo
Cracked?
Phlarx
0

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
Phlarx
fonte
Just to exclude the obvious, you're not trying to sneak in an empty sequence, e.g. A290000? Technically, because your code returns nothing for input of zero, this sequence would match!
Ha, there is at least one value in the other sequence :) Also, I should say, I designed this to be 1-indexed, since that's how OEIS is indexed.
Phlarx
(Nevermind, I found counterexamples. My code is still 1-indexed.)
Phlarx
So I did some more looking into it, and the doing-nothing is python's fault. It wasn't giving any output for zero, so my code never ran. I've fixed that in the TIO link now. (Gave the bit-length a floor of 1 byte).
Phlarx
1
Cracked.