Il s'agit d'un défi entre flics et voleurs , le fil des voleurs peut être trouvé ici .

Votre tâche consiste à écrire du code qui génère une séquence OEIS et contient le nom de la séquence dans le code ( A______) et génère une deuxième séquence distincte lorsque le nom de la séquence dans le code est remplacé par le nom de la deuxième séquence.

Voici un exemple dans Haskell qui fonctionne pour A000217 et A000290 .

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

Essayez-le en ligne!

Vous devez ensuite révéler l'une des deux séquences et le code gardant secret la deuxième séquence. Les voleurs tenteront de comprendre quelle est la séquence cachée. Si un voleur parvient à déterminer quelle est votre séquence (ou une autre séquence qui correspond aux critères), vous répondez est craqué. Si personne ne le fait dans la semaine suivant la publication de votre réponse, vous pouvez marquer votre réponse comme sûre et révéler la solution envisagée pour vérification. Les réponses sûres ne peuvent pas être fissurées.

Entrée sortie

^{Pris d' ici}

Votre code peut être une fonction ou un programme complet qui prend n via une méthode d'entrée standard et génère le n ème terme de la séquence indexé par l'index fourni sur la page OEIS.

Vous devez prendre en charge toutes les valeurs fournies dans les fichiers b OEIS pour cette séquence, tout nombre ne figurant pas dans les fichiers b n'a pas besoin d'être pris en charge.

Notation

Votre score sera le nombre d'octets dans votre code, avec moins d'octets étant mieux.

Python 3, 59 octets, A162626 , craqué par Wheat Wizard

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

C'est était censé être impossible, non?

Python 3 , 62 octets, A017016 ( fissuré )

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

Essayez-le en ligne!

Japt , 13 octets ( fissuré )

Il y a (au moins) une autre solution, si quelqu'un d'autre veut s'y attaquer.

p#A000012uCnG

Essayez-le en ligne
A000012

Explication

#suivi d'un caractère dans Japt nous donne le code de ce caractère #A=65, auquel le reste du nombre est ensuite ajouté, en nous donnant 65000012ou 65000290.

uest la méthode modulo (elle diffère de %par le fait qu'elle renvoie toujours un nombre positif).

La nméthode soustrait le nombre auquel elle est appliquée du nombre qui lui est transmis. Cet Gsont les constantes Japt pour 11 et 15, respectivement. Alors, CnGnous donne 4.

Nous avons maintenant 65000012%4=0et 65000290%4=2. La pméthode élève le nombre auquel elle est appliquée (dans ce cas, c'est implicitement l'entier en entrée U) à la puissance du nombre qui lui est passé, nous donnant les 2 formules finales de U**0et U**2.

MATL , 30 29 octets ( fissuré )

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

A077430

Essayez-le en ligne!

-1 octet grâce à @Sanchises

C #, 28 octets ( fissuré )

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

Fonctionne avec A000290 .

Un moyen facile de commencer.

Essayez-le en ligne!

Python 2, 43 octets, A000079 ( fissuré )

Essayez-le en ligne

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

C #, 75 octets, ( fissuré )

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

A000244

Essayez-le en ligne!

Python 2 , 53 octets, A000012 [fissuré]

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

Essayez-le en ligne!

La séquence suivante est A055642 (longueur des chiffres dans un nombre décimal). Pour lequel le nombre s'évalue lui-même, puisque la somme des chiffres dans OEIS est égale à 22; le len (...) calcule ainsi la longueur réelle du numéro d'entrée pour 'A055642'. Pour les séquences A000012 (ou toute autre que A055642. Le len sera toujours égal à un, car le nombre évalué sera '1'.

Python 3, 65 octets, A000027, fissuré

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

Ouais l'arithmétique folle!

Smalltalk, 148 octets, sûr!

|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

Prend un entier comme entrée, la séquence est basée sur 1.

La deuxième séquence prévue est A133020 . Dans la rédaction de A018253 se trouve un lien vers une liste d'entrées pour les séquences liées aux diviseurs de nombres . Dans cette liste, A133020 est divisé en diviseurs de carrés: 100² . Si vous souhaitez voir la séquence entière, insérez-la Transcript show: o printString; cr.avant l' ^instruction return dans le code.

Haskell, 226 octets, sûr!

Je ne sais pas si c'est intelligent ou laid, peut-être les deux ...

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)

Alors maintenant, cela calcule A001906 , mais il devrait être capable de générer beaucoup de séquences.

Essayez-le en ligne!

Solution: A131078

Vous vous demandez si cela a été trop difficile ou si personne n'a essayé?

o 1to o 6sont les chiffres du numéro de série, mest une liste d'opérations. lest une liste infinie définie récursivement avec les deux premières valeurs dérivées du numéro de série et les autres calculées à partir des deux précédentes en utilisant une opération fixe à partir de m. Dans le cas de A001906, la définition peut être simplifiée pour

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

(flip(+))est (généralement) identique à (+), et nous obtenons une définition bien connue (mais pas la plus courte) des nombres de Fibonacci. Ce schéma de récursivité pourrait calculer directement A001906, mais cela nécessite une opération plus compliquée que celles de m. Autre exemple: l'utilisation des valeurs de départ 1et 2et l'opération (*)donne la série A000301 . Il est calculé par notre code lorsque le numéro de série est remplacé par?103206 .

Enfin, la fonction findexe dans la liste l, mais seulement après une certaine transformation de l'entrée. Pour A001906, la partie centrale se réduit à (*)2, de sorte que nous obtenons uniquement les numéros de Fibonacci à des positions paires. La bonne partie devientflip const 1 , qui est la fonction d'identité et n'interfère plus.

Pour la solution A131078, les valeurs de départ de lsont 1et 0, et l'opération est flip const, ce qui permet d' lêtre 1,0,1,0,.... La partie médiane de fdevient (flip div 4), résultant en 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,.... Cela ressemblait à une bonne réponse, mais j'ai vu que A131078 commence à n=1, alors j'ai ajouté la bonne partie de f, qui est iciflip(-)1 de soustraire une.

Mon idée était de le rendre un peu obscurci en l'utilisant met en l'indexant avec des chiffres des numéros de série, puis il est devenu plus obscurci (termes compliqués) pour le faire fonctionner (peut-être que je ne cherchais pas assez longtemps pour des alternatives); puis il est devenu encore plus obscurci (partie droite de f) pour que cela fonctionne vraiment. Je pense que certains deviner et essayer auraient pu le faire craquer.

dc , 52 octets, fissuré

Celui-ci fonctionne avec A000217 :

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

Essayez-le en ligne!

Python 3.6, 114 octets, craqué

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) renvoie la n-ième valeur de la séquence pour n> = 0.

random.choices(s,k)est nouveau dans Python 3.6, il renvoie les kéléments sélectionnés savec remplacement.

Chip , 67 octets, craqué par Yimin Rong

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

A000012 . Un peu effronté, oui.

Essayez-le en ligne!

Utilise des octets pour les E / S, donc j'étais sympa et j'ai construit un wrapper bashy / pythony.

La séquence alternative est A060843 . Essayez-le en ligne pour les entrées 1..4.

Yimin Rong courbé à droite, un programme de puce aussi court ne peut calculer que des choses très simples. La séquence d'origine est tout à fait unique et la séquence alternative est le nombre de castors occupés, dont 4 seulement sont connus.

Ces nombres, 1, 6, 21, 107sont simplement codés en dur pour les entrées 1..4.

Une chose intéressante à propos de l'utilisation de Chip pour ce défi est que les chiffres 0- 9ne sont pas des nombres, mais des éléments logiques. Plus précisément, 0- 7sont les huit bits adressés à la tête de la pile, 8et 9sont les commutateurs de lecture et d'écriture. Cela a rendu cela un peu plus intéressant et beaucoup plus obscur.

Un cadeau potentiel est que seulement A- Dapparaît, ce qui signifie que nous n'avons que 4 bits pour indexer la séquence. Cela signifiait qu'il pouvait y avoir au plus 16 valeurs différentes. En fait, seuls A- Csont réellement utilisés pour la séquence alternative, donnant au maximum 8 valeurs différentes.

Pour tous ceux qui pourraient être intéressés, voici le même code, débarrassé des no-ops et des éléments inutilisés:

.

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