Bu bir polis ve soyguncu mücadelesi, soyguncular iş parçacığını burada bulabilirsiniz .

Göreviniz, OEIS dizisi çıkaran ve koddaki dizinin adını içeren bir kod yazmaktır ( A______) ve koddaki dizinin adı ikinci dizinin adı olarak değiştirildiğinde ikinci bir ayrı dizinin çıktısını almaktır.

İşte Haskell'de A000217 ve A000290 için çalışan bir örnek .

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

Çevrimiçi deneyin!

Daha sonra iki sekanstan birini ve ikinci sekansı gizli tutan kodu ortaya çıkarırsınız. Soyguncular gizli dizinin ne olduğunu bulmaya çalışacaklar. Bir soyguncu, dizinizin ne olduğunu (veya ölçütlere uyan başka bir diziyi) belirlemeyi başarırsa, cevapladığınız yanıt kırılır. Cevabınızın gönderilmesinden sonraki bir hafta içinde bunu yapmazsanız cevabınızı Güvenli olarak işaretleyebilir ve doğrulama için amaçlanan çözümü açığa çıkarabilirsiniz. Güvenli cevaplar kırılamaz.

Giriş çıkış

^{Buradan alındı}

İşletme kodu alan bir fonksiyon ya da tam bir program olabilir , n , standart bir giriş yöntemi ile ve çıkışlar n OEIS sayfasında sağlanan indeksi dizinlenen şekilde dizisinin inci terimi.

Bu sekans için OEIS b dosyalarında sağlanan tüm değerleri desteklemelisiniz, b dosyalarında olmayan herhangi bir sayının desteklenmesi gerekmez.

puanlama

Puanınız kodunuzdaki bayt sayısı olacaktır ve daha az bayt daha iyi olacaktır.

Python 3, 59 bayt, A162626 , Buğday Sihirbazı tarafından çatlamış

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

Bu edilir o imkansız değildi gerekiyordu?

Python 3 , 62 bayt, A017016 ( Çatlak )

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

Çevrimiçi deneyin!

Japt , 13 bayt ( Kırık )

Başka bir çözüm varsa, en azından bir çözüm daha var.

p#A000012uCnG

Çevrimiçi deneyin
A000012

açıklama

#ardından Japt'taki bir karakter bize o karakterin karakterini verir, böylece #A=65, numaranın geri kalanı bize eklenir, 65000012ya da verir 65000290.

umodulo yöntemidir ( %her zaman pozitif bir sayı döndüreceğinden farklıdır ). Yöntem geçirilen numaradan uygulanır numarasını bundan çıkarmaktadır. ve sırasıyla 11 ve 15 için Japt sabitleridir. Yani, bize verir . Şimdi ve var . Yöntemi (örtük, bu durumda, giriş tamsayı uygulanacağına sayısını yükseltir bize 2 nihai formüller vererek kendisine geçirilen sayının kuvvetine) ve .

nCGCnG4

65000012%4=065000290%4=2pUU**0U**2

MATL , 30 29 bayt ( Çatlak )

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

A077430

Çevrimiçi deneyin!

@Sanchises sayesinde -1 bayt

C #, 28 bayt ( Çatlak )

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

İle çalışır A000290 çalışır .

Bunu başlatmak için kolay bir tane.

Çevrimiçi deneyin!

Python 2,43 bayt, A000079 ( Çatlak )

Çevrimiçi deneyin

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

C#, 75 bytes, (Cracked)

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

A000244

Try it online!

Python 2, 53 bytes, A000012 [cracked]

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

Try it online!

The next sequence is A055642(length of digits in a decimal number). For which the number evaluates to itself, since sum of the digits in OEIS equals 22; the len(...) thus calculates to actual length of the input number for 'A055642'. For sequences A000012(or any other than A055642. The len will always equal to one, since the number evaluted will be '1'.

Python 3, 65 bytes, A000027, cracked

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

Yay crazy arithmetic!

Smalltalk, 148 bytes, safe!

|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

Takes an integer as input, sequence is 1-based.

The intended second sequence is A133020. In the writeup for A018253 is a link to a list of entries for sequences related to the divisors of numbers. In that list, A133020 is under divisors of squares: 100². If you want to see the entire sequence, insert Transcript show: o printString; cr. before the return ^ statement in the code.

Haskell, 226 bytes, safe!

Not sure if clever or ugly, maybe both...

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)

So now this computes A001906, but it should be able to generate a lot of sequences.

Try it online!

Solution: A131078

Wondering if this was too difficult or no one tried?

o 1 to o 6 are the digits of the series number, m is a list of operations. l is a recursively defined infinite list with the first two values derived from the series number and the remaining ones computed from the previous two using a fixed operation from m. In the case of A001906, the definition can be simplified to

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

(flip(+)) is (usually) the same as (+), and we get a well known (but not the shortest) definition of the Fibonacci numbers. This recursion scheme could directly compute A001906, but that needs an operation more complicated than those in m. Another example: using starting values 1 and 2 and the operation (*) gives the series A000301. It is computed by our code when the series number is replaced with ?103206.

Finally, the function f indexes into the list l, but only after some transformation of the input. For A001906, the middle part reduces to (*)2, so that we only get the Fibonacci numbers at even positions. The right part becomes flip const 1, which is the identity function and does not further interfere.

For the solution A131078, the starting values of l are 1 and 0, and the operation is flip const, which lets l be 1,0,1,0,.... The middle part of f becomes (flip div 4), resulting in 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,.... This looked like a nice answer, but then I saw that A131078 starts at n=1, so I added the right part of f, which here is flip(-)1 to subtract one.

My idea was to make it a bit obfuscated by using m and indexing into it with digits from the series numbers, then it became more obfuscated (complicated terms) to make it work (maybe I wasn't searching long enough for alternatives); and then it became even more obfuscated (right part of f) to make it really work. Still I think some guessing and trying could have cracked it.

dc, 52 bytes, cracked

This one works with A000217:

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

Try it 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.

Alternate sequence is A060843. Try it online for inputs 1..4.

Yimin Rong hunched right, such a short Chip program can only calculate very simple things. The original sequence is all one's, and the alternate sequence is the busy beaver numbers, of which only 4 are known.

These numbers, 1, 6, 21, 107, are simply hard-coded for the inputs 1..4.

One interesting thing about using Chip for this challenge is that the digits 0-9 are not numbers, but logical elements. Specifically, 0-7 are the eight bits addressing the head of the stack, and 8 and 9 are the read and write toggles. That made this a bit more interesting and much more obfuscated.

A potential giveaway is that only 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