[Question]
  [
> 
> This is a [cops-and-robbers](/questions/tagged/cops-and-robbers "show questions tagged 'cops-and-robbers'") challenge, the robbers thread can be found [here](https://codegolf.stackexchange.com/questions/137382/solving-secret-swapping-sequences).
> 
> 
> 
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](https://www.oeis.org/A000217) and [A000290](https://www.oeis.org/A000290).
```
f x|last"A000217"=='0'=x^2|1>0=sum[1..x]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P02hoiYnsbhEydHAwMDI0FzJ1lbdQN22Is6oxtDOwLa4NDfaUE@vIvZ/bmJmnm1BUWZeiUqagqHBfwA "Haskell – 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](https://codegolf.stackexchange.com/questions/137213/swap-the-sequence)
Your code can be a function or complete program that takes **n** via a standard input method and outputs the **n**th 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.
  
[Answer]
# Python 3, 59 bytes, [A162626](https://oeis.org/A162626), [cracked](https://codegolf.stackexchange.com/a/137434/59523)
```
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?
[Answer]
# [Python 3](https://docs.python.org/3/), 62 bytes, [A017016](https://www.oeis.org/A010716) ([Cracked](https://codegolf.stackexchange.com/a/137391/59487))
```
n=int(input())
print(sum(1for i in"A017016"if i>"0")*-~n//-~n)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P882M69EIzOvoLREQ1OTq6AIxC0uzdUwTMsvUshUyMxTcjQwNDcwNFPKTFPItFMyUNLU0q3L09cHEpr//5sAAA "Python 3 – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt/), 13 bytes ([Cracked](https://codegolf.stackexchange.com/a/137413/58974))
There is (at least) one other solution, if anyone else wants to take a stab at it.
```
p#A000012uCnG
```
[Try it online](https://tio.run/##y0osKPn/v0DZ0QAIDI1KnfPc//@3AAA)  
[A000012](https://oeis.org/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`.
> 
> 
> 
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~30~~ 29 bytes ([Cracked](https://codegolf.stackexchange.com/a/137544/72733))
```
A077430I\2-|Gw^1Mwx*10&Ylk1+&
```
[A077430](https://oeis.org/A077430)
[Try it online!](https://tio.run/##y00syfn/39HA3NzE2MAzxki3xr08ztC3vELL0EAtMifbUFvt/38LEwA "MATL – Try It Online")
-1 byte thanks to @Sanchises
[Answer]
# C#, 28 bytes ([Cracked](https://codegolf.stackexchange.com/a/137384/38550))
```
n=>n*n*("A000290"[6]<49?1:n)
```
Works with [A000290](https://oeis.org/A000290).
An easy one to get this started.
[Try it online!](https://tio.run/##Sy7WTc4vSv2fl5ibWlyQmJyqEFxZXJKay1XNpQAEyTmJxcUKAWA2RAQEiksSSzKTFcryM1MUfBMz8zQ04VIIRSDgVpqXbJOZV6KjACTsFNIUbBX@59na5WnlaWkoORoYGBhZGihFm8XamFjaG1rlaf635kLR75yfV5yfk6oXXpRZkuqTmZeqkaZhpKlpTVCRMTGKTIhRZApShFVVUGpiClgRkim1XBCy9j8A "C# (.NET Core) – Try It Online")
[Answer]
# Python 2, 43 bytes, [A000079](https://oeis.org/A000079) ([Cracked](https://codegolf.stackexchange.com/a/137405/66855))
[Try it online](https://tio.run/##K6gsycjPM/rvYxvzPycxNyklUSHPSkOjuDRXIzexQCO/KEVH3dEACMwt1TU1tYw0VS00tbTy/qflFylkKmTmKRQl5qWnahjoGBoYaFpxcRYUZeaVKGTqKPhoZGr@BwA)
```
lambda n:((sum(map(ord,'A000079'))*2)%8)**n
```
[Answer]
# C#, 75 bytes, ([Cracked](https://codegolf.stackexchange.com/a/137414/38550))
```
n=>{int r=1,e=3-0xA000244%2;for(;n>0;e*=e){r*=(n%2>0?e:1);n>>=1;}return r;}
```
[A000244](https://oeis.org/A000244)
[Try it online!](https://tio.run/##VU7LagMxDLzvV@gSsPPCu82pjh1KoacWSnvo2ThaMGTlYjulZfG3b70JfXgO0kiakWTjZvDkJzIDxndjEV6/YsKhGRsosCcTIzxf@LUzIyaTnIUP747wZBwx/jv6E814OJPdO0prKEFDD2oipcdSQFDtGtXNRnzeCSG63W7Ryd4HJkkLiUuFfAxLxWjRaXHA25aXgVatzAHTORAEmSfZVNeKHdi824ECIUvaK2gLWa0cr5T1lzPuPUV/wu1bcAkfHSHrmeNcVsJc3/vxvKA5Xiz/5Lm5xjx9Aw "C# (Mono) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 53 bytes, [A000012](https://oeis.org/A000012) [[cracked]](https://codegolf.stackexchange.com/a/137424/59523)
```
lambda x:len(`x**(sum(map(int,'A000012'[1:]))==22)`) 
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUaHCKic1TyOhQktLo7g0VyM3sUAjM69ER93RAAgMjdSjDa1iNTVtbY2MNBM0Ff4XFAFlFdKAagpKSzQ0Nf8bGRsZAQA "Python 2 – 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'. 
> 
> 
> 
[Answer]
## 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](https://oeis.org/A001906), but it should be able to generate a lot of sequences.
[Try it online!](https://tio.run/##LcxNasMwEAXgvU4xCl5oYlnIaWuIiQxd9gRdGBdEbDci@sNWuii9u6uQwDwGhm/eRa/XydptC@DVMulRxNsyCUapx2L3LmV9lM2OuLb98Gn6XrQFrbpeV919BuJUfw5@TZyVyFmVs0c@mh/OvnAoSzZbE09F55BYFaBuA7xU9/1r4qdJF@YoZQGa8nE/ILKkjQWLlsyKWUpRsCd6zegtp6kO@1zx4MV6c339509VXwvRDDyMY7Yeh@dj9ljkdiSb08aDgrgYn6AApyPM0Eshajls/w "Haskell – Try It Online")
---
Solution: [A131078](https://oeis.org/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](https://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.
[Answer]
# Python 3, 65 bytes, A000027, cracked
```
a=lambda a,n=((int("A000027",11)-0x103519a)%100%30+1)/2:a//(14-n)
```
Yay crazy arithmetic!
[Answer]
# 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](https://oeis.org/A018253)
Takes an integer as input, sequence is 1-based.
> 
>  The intended second sequence is [A133020](https://oeis.org/A133020). In the writeup for [A018253](https://oeis.org/A018253) is a link to a [list of entries for sequences related to the divisors of numbers](https://oeis.org/index/Di#divisors). In that list, [A133020](https://oeis.org/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.
> 
> 
> 
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 52 bytes, [cracked](https://codegolf.stackexchange.com/a/137555/48198)
This one works with [A000217](https://oeis.org/A000217):
```
?SaA000217d8d1+Sb%1r-dScla*r10 7^-Lb%+la*1+Lc+La*2/p
```
[Try it online!](https://tio.run/##S0n@/98@ONHRwMDAyNA8xSLFUDs4SdWwSDclODknUavI0EDBPE7XJ0lVG8gz1PZJ1vZJ1DLSL/j/39AAAA "dc – Try It Online")
[Answer]
# Python 3.6, 114 bytes, [cracked](https://codegolf.stackexchange.com/a/138295/56819)
```
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](https://oeis.org/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.
[Answer]
# [Chip](https://github.com/Phlarx/chip), 67 bytes, [cracked](https://codegolf.stackexchange.com/a/138357/56819) by Yimin Rong
```
2D5B#{*Cm49!}E-7
(A000012d#,zkmsh
b-\6/e2)[1Zv^~^S
33a#kcf3g88taz1@
```
[A000012](http://oeis.org/A000012). A bit cheeky, yes.
[Try it online!](https://tio.run/##PZBNT4NAEIbv/IqxHLqrsBRQi2lr/KpXD97UtFnYBTYVdmWnCrX615Ea4xwmed68eTKZlNuyzzjCJVj5xrLSwHwOy4f7Pro7u3E/j2@r04ujr6U/dcj1ZJgwEq6321S2dFL/5TyQEX0On95X36tHJ465u8nyuEgS5Lvwqh88jnOwM1WbLTJUGvZgOix1HYOfwUhVRjcItrMzaGEBqkYyALMoVM0ayQWhdAZ/kR4c6TbPZcM@GoWStAz1Ou1QWlLxlgycKly/yrrAktCTKQ2CxAupB4eOboRsFuNUFWNKR8MhgTYYZKUyv4uZ7v8He9ACfNFPfgA "Chip – Try It Online")
Uses bytes for i/o, so I was nice and built a bashy/pythony wrapper.
---
> 
> Alternate sequence is [A060843](http://oeis.org/A060843). [Try it online](https://tio.run/##PZBNT4NAGITv/IrXcuiuwlJKbTFtjV/16sGbmja7sMCmwq7sW4Va/etIjfEyyUwmTyYjuC26hCNcgpVvLCkMLBawerjvxnfnN@7n6W05uTj5Wvkzh1yPpqN4EqWut9@WtnCE/zIN5Jg@h0/v6@/1oxNF3N0mWZTHMfJ9eNX1HMc50pmqzA4ZKg0HMC0WuorAT2CgSqNrBNvaOTSwBFUh6Q2zmKqK1ZKnhNI5/EW6Z4hdlsmafdQKJWkY6o1oUVpS8ob0XijcvMoqx4LQsxkNgtgLqQfHjq5TWS@HQuVDSgf9kEAbDJJCmV9hpv3/4AA6BT/tJj8 "Chip – 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
> 
> ```
> 
> 
]