19
\$\begingroup\$

This is a challenge, the robbers thread can be found here.

Your task is to write some code that outputs an OEIS sequence, and contains the name of the sequence in the code (A______) and outputs a second separate sequence when the name of the sequence in the code is changed to the name of the second sequence.

Here's an example in Haskell that works for A000217 and A000290.

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

Try it online!

You are then to reveal one of the two sequences, and the code keeping the second sequence a secret. Robbers will attempt to figure out what the hidden sequence is. If a robber manages to determine what your sequence is (or another sequence that fits the criteria) you answer is cracked. If none do so in a week of your answer being posted you may mark your answer as Safe and reveal the intended solution for verification. Safe answers cannot be cracked.

Input Output

Taken from here

Your code can be a function or complete program that takes n via a standard input method and outputs the nth term of the sequence as indexed by the provided index on the OEIS page.

You must support all values provided in the OEIS b files for that sequence, any number not in the b files need not be supported.

Scoring

Your score will be the number of bytes in your code, with less bytes being better.

Improve this question
\$\endgroup\$
12
  • 1
    \$\begingroup\$ Your score will be the number of bytes in your code, with less bytes being better. - Why isn't this tagged code-golf, then? \$\endgroup\$ Commented Aug 3, 2017 at 14:44
  • \$\begingroup\$ @Mr.Xcoder I forgot to. Don't read into these things too much ;) \$\endgroup\$ Commented Aug 3, 2017 at 14:46
  • \$\begingroup\$ So code should output sequence of some length (defined or not?) or n-th element of sequence? \$\endgroup\$ Commented Aug 3, 2017 at 14:55
  • \$\begingroup\$ @DeadPossum nth term. \$\endgroup\$ Commented Aug 3, 2017 at 14:56
  • \$\begingroup\$ @WheatWizard guess I was looking somewhere else, but monitor. My bad \$\endgroup\$ Commented Aug 3, 2017 at 14:57

14 Answers 14

Reset to default
9
\$\begingroup\$

Python 3, 59 bytes, A162626, cracked

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

This is was supposed to be impossible, wasn't it?

Improve this answer
\$\endgroup\$
1
  • 2
    \$\begingroup\$ Cracked \$\endgroup\$ Commented Aug 3, 2017 at 18:17
5
\$\begingroup\$

Python 3, 62 bytes, A017016 (Cracked)

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

Try it online!

Improve this answer
\$\endgroup\$
5
  • \$\begingroup\$ I tried to make it as obfuscated as possible... \$\endgroup\$ Commented Aug 3, 2017 at 15:09
  • 1
    \$\begingroup\$ @officialaimm I did that on purpose. I want to make this obfuscated. I don't really care about golfing, because Python won't win a code-golf obfuscation contest :p \$\endgroup\$ Commented Aug 3, 2017 at 15:10
  • 1
    \$\begingroup\$ Cracked? \$\endgroup\$ Commented Aug 3, 2017 at 15:14
  • \$\begingroup\$ By the way, was that the intended solution? \$\endgroup\$ Commented Aug 3, 2017 at 17:01
  • \$\begingroup\$ @totallyhuman Yeah, it was the indtended solution. \$\endgroup\$ Commented Aug 3, 2017 at 17:16
4
\$\begingroup\$

Japt, 13 bytes (Cracked)

There is (at least) one other solution, if anyone else wants to take a stab at it.

p#A000012uCnG

Try it online
A000012

Explanation

# followed by a character in Japt gives us the charcode of that character, so #A=65, which the rest of the number then gets appended to, giving us 65000012 or 65000290.

u is the modulo method (it differs from % in that it will always return a positive number).

The n method subtracts the number it is applied to from the number passed to it. C and G are the Japt constants for 11 & 15, respectively. So, CnG gives us 4.

We now have 65000012%4=0 and 65000290%4=2. The p method raises the number it's applied to (in this case that is, implicitly, the input integer U) to the power of the number passed to it, giving us the 2 final formulas of U**0 and U**2.

Improve this answer
\$\endgroup\$
5
  • \$\begingroup\$ cracked? \$\endgroup\$ Commented Aug 3, 2017 at 16:06
  • 1
    \$\begingroup\$ @officialaimm: Correct, nicely done. \$\endgroup\$ Commented Aug 3, 2017 at 16:11
  • \$\begingroup\$ Since I don't know Japt, I had assumed the power to be raised was (sum_of_numbers_in_oeis(excluding 'A') + 1)%4. :D \$\endgroup\$ Commented Aug 3, 2017 at 16:44
  • 1
    \$\begingroup\$ @officialaimm: I love seeing robbers crack challenges in languages they don't know :) I actually posted this with the hope that it would be someone unfamiliar with Japt who would crack it. \$\endgroup\$ Commented Aug 3, 2017 at 23:05
  • \$\begingroup\$ A020338 may also work if string input is allowed (1-indexed). \$\endgroup\$ Commented Aug 30, 2018 at 8:30
4
\$\begingroup\$

MATL, 30 29 bytes (Cracked)

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

A077430

Try it online!

-1 byte thanks to @Sanchises

Improve this answer
\$\endgroup\$
5
  • 1
    \$\begingroup\$ Should be fixed now \$\endgroup\$ Commented Aug 4, 2017 at 6:57
  • 1
    \$\begingroup\$ Just a hint: you can replace ` 3` by I for 1 byte. \$\endgroup\$ Commented Aug 4, 2017 at 8:11
  • \$\begingroup\$ @Sanchises Thanks! Didn't knew I is initialized to 3 \$\endgroup\$ Commented Aug 4, 2017 at 8:29
  • 2
    \$\begingroup\$ You should check out Table 3. Along with l (one) and O (zero), you should almost never have to use a space in your MATL programs. On a related note, check out Table 7 as well, which contains many useful predefined constants (although beware that e.g. 4X2Z% has a shorthand 1Z%) \$\endgroup\$ Commented Aug 4, 2017 at 8:52
  • \$\begingroup\$ Cracked. \$\endgroup\$ Commented Aug 4, 2017 at 12:10
3
\$\begingroup\$

C#, 28 bytes (Cracked)

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

Works with A000290.

An easy one to get this started.

Try it online!

Improve this answer
\$\endgroup\$
4
  • \$\begingroup\$ It cannot be cracked yet >_< \$\endgroup\$ Commented Aug 3, 2017 at 14:47
  • \$\begingroup\$ @Mr.Xcoder Can now :) \$\endgroup\$ Commented Aug 3, 2017 at 14:47
  • 1
    \$\begingroup\$ Craked (although not really cracked!) \$\endgroup\$ Commented Aug 3, 2017 at 14:49
  • \$\begingroup\$ @Shaggy I just wanted to get the ball rolling :P \$\endgroup\$ Commented Aug 3, 2017 at 14:50
3
\$\begingroup\$

Python 2, 43 bytes, A000079 (Cracked)

Try it online

lambda n:((sum(map(ord,'A000079'))*2)%8)**n
Improve this answer
\$\endgroup\$
9
  • \$\begingroup\$ Cracked? \$\endgroup\$ Commented Aug 3, 2017 at 15:22
  • \$\begingroup\$ @TheLethalCoder Well.. It fits, but it is not the one, that I've chosen. Also I made edit before your comment, and it no longer fits \$\endgroup\$ Commented Aug 3, 2017 at 15:24
  • 5
    \$\begingroup\$ You changed it after posting? A bit unfair. \$\endgroup\$ Commented Aug 3, 2017 at 15:26
  • \$\begingroup\$ @TheLethalCoder I did it to protect from this false-positive sequence :C \$\endgroup\$ Commented Aug 3, 2017 at 15:27
  • 1
    \$\begingroup\$ I don't know about editing an entry, but from the rules in the OP, "If a robber manages to determine what your sequence is (or another sequence that fits the criteria) you answer is cracked", just FYI. \$\endgroup\$ Commented Aug 3, 2017 at 23:49
3
\$\begingroup\$

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!

Improve this answer
\$\endgroup\$
4
  • \$\begingroup\$ Cracked \$\endgroup\$ Commented Aug 3, 2017 at 16:11
  • \$\begingroup\$ @Lynn What gave it away? The first sequence? \$\endgroup\$ Commented Aug 3, 2017 at 16:12
  • 3
    \$\begingroup\$ You are taking the OEIS number % 2 — so the program can literally only do two things, depending on the outcome of that: one for 0 and one for 1. So I put an odd number in its place, and the challenge kinda cracked itself. \$\endgroup\$ Commented Aug 3, 2017 at 16:15
  • \$\begingroup\$ @Lynn Ah suppose, didn't think obfuscating that part. \$\endgroup\$ Commented Aug 3, 2017 at 16:16
2
\$\begingroup\$

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

Improve this answer
\$\endgroup\$
1
  • 1
    \$\begingroup\$ Cracked? \$\endgroup\$ Commented Aug 3, 2017 at 17:25
2
\$\begingroup\$

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.

Improve this answer
\$\endgroup\$
2
  • \$\begingroup\$ I tried a few sequences and they usually gave division by zero errors, negative exponent errors or just seemed to run forever. To be honest, Haskell freaks me out, just can't seem to wrap my head around it, spent too long in procedural I guess. \$\endgroup\$ Commented Aug 18, 2017 at 1:06
  • \$\begingroup\$ If you're just trying, there is the extra problem that even the solution gives a "negative index" error when given 0. That is fine because it only starts at 1! Starting at 1 should also remove some of the "division by zero" errors. I'm surprised by examples running forever. Maybe the index transformation creates very big values in these cases... \$\endgroup\$ Commented Aug 18, 2017 at 9:36
1
\$\begingroup\$

Python 3, 65 bytes, A000027, cracked

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

Yay crazy arithmetic!

Improve this answer
\$\endgroup\$
3
  • \$\begingroup\$ Um, A004526, gives n=12 which looks right, but the result will be off by one index - did I crack with bug or fall for a very clever red herring? \$\endgroup\$ Commented Aug 3, 2017 at 22:31
  • \$\begingroup\$ Neither; you've misinterpreted A004526, which clearly states a(n) = floor(n/2); the sequence listed starts with 0. That is the intended solution, however. \$\endgroup\$ Commented Aug 3, 2017 at 22:44
  • \$\begingroup\$ Oh yes the offset - right (whew), thanks! Well cracked then. \$\endgroup\$ Commented Aug 3, 2017 at 23:54
1
\$\begingroup\$

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.

Improve this answer
\$\endgroup\$
0
\$\begingroup\$

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!

Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ Cracked. \$\endgroup\$ Commented Aug 4, 2017 at 13:28
0
\$\begingroup\$

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.

Improve this answer
\$\endgroup\$
3
  • \$\begingroup\$ Feel very much like encryption/hashing. \$\endgroup\$ Commented Aug 9, 2017 at 2:09
  • \$\begingroup\$ @ppperry - if that's against the rules, I'll remove it. \$\endgroup\$ Commented Aug 9, 2017 at 7:20
  • \$\begingroup\$ Cracked? \$\endgroup\$ Commented Aug 9, 2017 at 18:56
0
\$\begingroup\$

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
Improve this answer
\$\endgroup\$
5
  • \$\begingroup\$ 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! \$\endgroup\$ Commented Aug 7, 2017 at 11:21
  • \$\begingroup\$ 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. \$\endgroup\$ Commented Aug 8, 2017 at 14:14
  • \$\begingroup\$ (Nevermind, I found counterexamples. My code is still 1-indexed.) \$\endgroup\$ Commented Aug 8, 2017 at 14:23
  • \$\begingroup\$ 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). \$\endgroup\$ Commented Aug 8, 2017 at 15:14
  • 1
    \$\begingroup\$ Cracked. \$\endgroup\$ Commented Aug 10, 2017 at 2:18

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.