[Question]
  [
This challenge has two threads. This is the cops' thread. The robbers' thread is located [here](https://codegolf.stackexchange.com/questions/99156/polyglot-anagrams-robbers-thread).
Your challenge is to choose an [OEIS](https://oeis.org) sequence and write two *full programs* in two different languages that produces that nth item in the sequence when given an n via STDIN, or an other forms of standard input, where n is any positive number. However your two programs must be anagrams, meaning each can be rearranged from the other's letters.
Programs must output the decimal of the number followed by optional whitespace to STDOUT. Programs may output to STDERR however it should be ignored and if the hidden case does so it must be clearly stated that this is the case.
If you wish you may also output by character code. However if you do so in your hidden solution you must state such in the body of your submission.
You will then present the OEIS number, the source code for and the name of *one* language it is in.
Robbers will crack your submission if they find an anagram of the original submission that runs in a language other than the one you already presented. To crack an answer they must only find ***any*** language and program which produces the sequence and is an anagram of the original, not necessarily the answer the you were thinking about.
Thus you are incentivized to make it as hard as possible to find any language that does the task using their list of symbols.
## Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so the shortest un-cracked program is the winner.
## Languages
Languages will be considered different if the two proposed solutions do not complete the task in both languages. This will include different versions of *the same language* as long as neither the cop's solution or the robber's solution produce the correct output in the other's language.
i.e. If the there are two solutions 1 and 2 that are in language A and B respectively solution 2 must not produce the correct output in language A and solution 1 must not produce the correct output in language B.
# Safety
Once your submission has been uncracked for a week you may post your solution and declare your post safe. If after a week you choose not to post a solution your answer may still be cracked.
  
[Answer]
# ~~Python 2, 118 bytes, [A042545](https://oeis.org/A042545)~~ [Cracked](https://codegolf.stackexchange.com/a/99395/12012)
```
i=input();s=1/(801**.5-28);a=[0,1]
for p in range(i):a+=[a[-2]+a[-1]*int(s)];s=1/(s-int(s))
print a[i]#,,,.//000fhlmo|
```
I didn't feel like implementing a trivial sequence, so I decided to go with my PPCG user ID. I wrote this in the other language first, which should give you a clue about what that language is, though I'd bet 100 dollars that this will be cracked in a golfing language before it's cracked in the intended other language.
**Note:** Due to floating-point precision errors, this is only accurate up to an input of 14. The intended solution is the same way.
## Intended solution, JavaScript (ES7)
```
for(i=prompt(),s=1/(801**.5-28),a=[1,0];i--;s=1/(s-n))
  n=s|0,a.unshift(a[1]+a[0]*n);
alert(a[0])  //#+2:[]giiiiinnpt
```
Works in pretty much the same way as the Python solution, though the sequence is stored largest-first rather than smallest-first due to the fact that JS does not support negative indexing.
[Answer]
# Brain-Flak, 24 bytes, [A000290](http://oeis.org/A000290), Safe
Yet another square solution. This time there is nothing but parentheses
```
({(({}[()])()){}[()]}{})
```
---
The intended solution was in [Brain-Flueue](https://github.com/Wheatwizard/Brain-Flueue), a version of brain-flak that uses queues instead of stacks. The program was:
```
({(({})[()]){}}{})[()()]
```
The languages are considered distinct because neither of the two programs halt when run in the other language.
[Answer]
# ~~Python 2, 38 bytes, [A000290](http://oeis.org/A000290)~~ [Cracked by Emigna](https://codegolf.stackexchange.com/questions/99156/polyglot-anagrams-robbers-thread/99163#99163)
```
def e(X):return X*X
print e(input())##
```
This will probably be very easy to crack. I'm mostly posting this as a starting point.
Orignial solution in CJam:
```
ri:XX*e#def ()return X
e#pnt (input())
```
[Answer]
# ~~[CJam](https://sourceforge.net/projects/cjam/), 7 bytes, [A005843](http://oeis.org/A005843)~~ [Cracked!](https://codegolf.stackexchange.com/questions/99156/polyglot-anagrams-robbers-thread/99198#99198)
```
ri2*e#^
```
This is a basic `2*n` sequence.
Explanation:
```
r          e# read input
 i         e# convert to integer
  2*       e# multiply it by 2
    e#^    e# this is a comment that is ignored by the interpreter
```
[Try it online!](http://cjam.tryitonline.net/#code=cmkyKmUjXg&input=MjE)
---
# Original Solution, [Carrot](https://github.com/kritixilithos/Carrot)
```
#^i*2er
```
Carrot is an esolang created by me. I have stopped developing it a long time ago. The reason I chose this is because I hoped that it would be hard for other languages to comment out the unnecessary parts of the code.
Explanation:
```
#^            This pushes the input to the stack (anything before the ^ is the stack)
  i           Convert stack to integer
   *2         Multiply it by 2
     er       These are ignored because they are not Carrot commands
              Implicit output
```
[Try it online!](http://kritixilithos.github.io/Carrot/)
[Answer]
# ~~Brain-Flak, 44 bytes, [A000290](http://oeis.org/A000290)~~ [Cracked](https://codegolf.stackexchange.com/a/99166/56656)
```
<({({})({}[()])}{}))()()()turpentine/"*"*4splint>
```
[Try it online!](http://brain-flak.tryitonline.net/#code=PCh7KHt9KSh7fVsoKV0pfXt9KSgpKCkoKXR1cnBlbnRpbmUvIioiKjRzcGxpbnQ-Cg&input=NA&debug=on)
---
## Original solution, Python 2
```
print(input()**(len(set("{}{}{}[]()<>"))/4))
```
[Answer]
# ~~[2sable](http://github.com/Adriandmen/2sable), 15 bytes, [A000290](http://oeis.org/A000290)~~, [Cracked!](https://codegolf.stackexchange.com/a/99237/31957)
Hopping on the same **n2** train :p.
```
*?"!#$&<=@\^{|}
```
[Try it online!](http://2sable.tryitonline.net/#code=Kj8iISMkJjw9QFxee3x9&input=NA)
[Answer]
# ~~Excel, 12 bytes, [A000012](http://oeis.org/A000012)~~ [Cracked](https://codegolf.stackexchange.com/a/99207/47066)
```
=IF(1=1,1,1)
```
Maybe not the toughest, but a fun one to crack.
[Answer]
# Python 2, 25 bytes, [A000583](https://oeis.org/A000583), [cracked](https://codegolf.stackexchange.com/a/99278/45941)
```
Y=input("");print`Y**4`,X
```
This program exits with an error after printing the output.
---
My hidden code (substantially different from the cracked solution!):
## [Actually](http://github.com/Mego/Seriously), 25 bytes
```
4,n`*`Y")ii(*nppruttY;="X
```
[Try it online!](http://actually.tryitonline.net/#code=NCxuYCpgWSIpaWkoKm5wcHJ1dHRZOz0iWA&input=NTA)
Explanation:
```
4,n`*`Y")ii(*nppruttY;="X
4,n                        input, repeat 4 times
   `*`Y                    do * until the stack stops changing (fixed-point combinator)
       ")ii(*nppruttY;="X  push this string and immediately pop and discard it
```
[Answer]
# Python, 118 bytes, [A042545](https://oeis.org/A042545), Safe
```
i=int(input());s=pow(801.0,0.5);a=[0|0,1]
for Moshprtflmah in range(i):s=1./(s%1);a+=[a[-2]+a[-1]*int(s)];
print(a[i])
```
This time it works in both 2 and 3. And there's no comments! What will you do?
Note: As with the old solution, this loses precision after the first 15 terms due to floating-point arithmetic errors.
## Intended solution, JavaScript (ES6)
```
giiiiinnnnprt:
i=prompt([n=+2]);s=Math.pow(801,.5);for(a=[1,0];i--;a.unshift(a[1]+a[0]*(s|0)))s=1/(s%1)
alert(a[0])   
```
Though I kept several old versions, I somehow managed to lose *this* copy, but fortunately piecing it together from the others wasn't too hard. I see now that I had an extraneous `prt` in both programs that could have been golfed out. Oh well.
[Answer]
# Python 2, 124 bytes, [A144945](http://oeis.org/A144945), [Safe]
Cracking this would have earned you a 500 rep bounty! Too late!
> 
> Number of ways to place 2 queens on an n X n chessboard so that they attack each other.
> 
> 
> 
I hope it's not too easy. I arranged my code so the whitespace is clearly visible. Those are spaces and newlines only.
*Note: intended solution outputs via character code*
```
n=input();print((3+2)*n*n+~0*6*n+1)*n/3;            +6;
+7+7+7+7+7+7+7+7+7;+++++++++++++++9+9*9*9
```
[**Try it online**](https://repl.it/EU0M/1)
### Intended Solution, [Headsecks](http://esolangs.org/wiki/Headsecks):
```
r2=ni***p**
(
 
 
p((0 ;3+++3;+;/
 
 
)
 
 
 
 
 
i+++nn
 +)7
n
 
n+++ 
 
 
17+~
 +)7;97++++7
 
 
69+9n+ ++7+n 69
 +7+ ++7
 
 
**7+++tut
```
This is equivalent to the following BF program:
```
>>,[->>>+>>>+>>>+++++<<<<<<<<<]>>>->>>>>>-<<<[[>+<-]>[>>[<<<+>>+>-]<[>+<-]<-]<<<<]>>+++>[-<-[<+<<]<[+[->+<]<+<<]>>>>>]<<<.,.
```
[Answer]
# Fuzzy Octo Guacamole, 26 bytes, [A070627](https://oeis.org/A070627) [Safe]
```
49++*5^pm#]%:"?:.=:#,|"1:@
```
Test cases:
```
1 -> 1
3 -> 23
5 -> 1
```
Solution:
```
^::::|*?1=#@]","%.#49++5pm
```
Works in Magistack.
[Answer]
# ~~Pyth, 75 bytes, [A004526](https://oeis.org/A00526)~~ [Cracked, milk](https://codegolf.stackexchange.com/questions/99156/polyglot-anagrams-robbers-thread/99263#99263)
More of a playful test than anything, but:
```
/Q/////////////////****22222 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2;;;;;
```
[Try it online!](https://pyth.herokuapp.com/?code=%2FQ%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2a%2a%2a%2a22222+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2%3B%3B%3B%3B%3B&input=129&debug=0)
Milk's solution (Convex):
```
2/Q2 2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2*2*2*; 2*;                 2; 2; 2;
```
[Try it online](http://convex.tryitonline.net/#code=Mi9RMiAyLzIvMi8yLzIvMi8yLzIvMi8yLzIvMi8yLzIvMi8yLzIvMioyKjIqOyAyKjsgICAgICAgICAgICAgICAgIDI7IDI7IDI7&input=Nw)
Intended solution (///):
```
/*///;2/;// ///22/Q//2;///;//;***2222222222222222222222                    
```
[Try it online](http://slashes.tryitonline.net/#code=LyovLy87Mi87Ly8gLy8vMjIvUS8vMjsvLy87Ly8yMjIyMjIyOyoqKjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIgICAgICAgICAgICAgICAgICAgIA&input=)
Takes input in the form of 2's before the last semicolon and outputs the correct number of Q's.
The sequence is 0-indexed (i.e. 0 is 0, 1 is 0, 2 is 1, ...)
Found slight syntactical mistakes in the ///, so edited all solutions.
[Answer]
# MATL, 7 bytes, [A000217](https://oeis.org/A000217), [cracked](https://codegolf.stackexchange.com/a/99253/36398)
```
:sp{1}x
```
The sequence is `n(n+1)/2` (triangular numbers), starting at input `n=1` as specified by the challenge: `1`, `3`, `6`, `10`, ... (Output for input `0` is not guaranteed to be the same in the two programs).
The program in the other language exits with an error (after producing the correct output in STDOUT).
[Try it online!](http://matl.tryitonline.net/#code=OnNwezF9eA&input=MTA)
```
:            % Push [1 2 ... n], where n is implicit input
 s           % Sum of that array. Gives the desired result
   p         % Product of that. Gives the same number
    {1}      % Push a cell array containing number 1
       x     % Delete it
```
[Answer]
# ~~Python 2, 37 bytes, [A000290](http://oeis.org/A000290)~~ [Cracked](https://codegolf.stackexchange.com/a/99172/47066)
```
print(input()**(1+1))
"'10°3¢','m'"
```
[Answer]
# ~~Python 3, 27 bytes, [A000012](https://oeis.org/A000012)~~, [Cracked](https://codegolf.stackexchange.com/questions/99156/polyglot-anagrams-robbers-thread/99360#99360)
No input this time!
```
if 1:
    if 1:
        print( '1' )
```
The indents are tabs, but not to save bytes - they are required for whitespace.
I don't think it needs a TIO link or explanation!
(Probably won't take long to crack in some way)
Intended answer (Whitespace):
```
-Start-
    
    
    if1:if1:print('1')
-End-
```
(Start and end not part of the program)
Sorry, I forgot to add that it prints to STDERR:
[Try it online!](http://whitespace.tryitonline.net/#code=ICAgCQoJCiAJaWYxOmlmMTpwcmludCgnMScp&input=)
[Answer]
# [Fuzzy Octo Guacamole](https://github.com/RikerW/Fuzzy-Octo-Guacamole), 11 bytes, [A001844](http://oeis.org/A001844) [Safe!]
```
hha02^d+**+
```
[A crack that sort-of works is `dh*h++^2*0a`, in Pyth.](https://codegolf.stackexchange.com/questions/99156/polyglot-anagrams-robbers-thread/99252#99252) It's not the right output format though.
My code is still out there! (and it's not in Pyth)
Test Cases:
```
0 -> 1
1 -> 5
```
Solution:
```
^++d0ah*2*h
```
In Jolf.
[Answer]
# ~~WinDbg, 39 bytes, [A000007](https://oeis.org/A000007)~~ [Cracked by jimmy23013](https://codegolf.stackexchange.com/questions/99156/polyglot-anagrams-robbers-thread/99213#99213)
```
~e.block{j(0>=@$t0)?@$t0+(1<7);??0}t":"
```
The difficult sequence of `0**n`.
Input is done by passing a value in the pseudo-register `$t0`.
My original solution was C#:
```
@t=>(object)(0<@t?0:1)??"$$700~lk.{}+";
```
[Answer]
# JavaScript ES6, 38 bytes, [A000290](http://oeis.org/A000290), [Cracked](https://codegolf.stackexchange.com/a/99244/31957)
```
J=>eval(Array(J).fill(J).join`+`)|2-2;
```
This square train is pretty nifty, but isn't going anywhere fast. (Get it? *square* train? as in, wheels? no? okay, fine. *critics*.)
---
Intended answer: Reticular ([Try it online!](http://reticular.tryitonline.net/#code=aW4ySm87PT5ldmFsKEFycmF5KEopLmZpbGwoSikuamArYCl8LTI&input=Ng)),
```
in2Jo;=>eval(Array(J).fill(J).j`+`)|-2
in      take input, convert to number
  2J    raise to the second power
    o;  output and terminate; ignores following chars
```
[Answer]
# ~~[MATL](http://github.com/lmendo/MATL), 13 bytes, [A002275](http://oeis.org/A002275)~~  [Cracked!](https://codegolf.stackexchange.com/a/99226/31716)
```
i:"@ax'1']
v!
```
[Try it online!](http://matl.tryitonline.net/#code=aToiQGF4JzEnXQp2IQ&input=)
Explanation:
```
i           % Grab input
 :          % Push (range(1,input))
  "         % For each element in this range:
   @        %   Push it
    a       %   Is is truthy?
     x      %   Delete it
      '1'   %   Push '1'
         ]  %   End loop
v           % Join all of these '1's together
 !          % Transpose and display
```
[Answer]
# ~~[2sable](http://github.com/Adriandmen/2sable), 13 bytes, [A002378](https://oeis.org/A002378)~~, [Cracked!](https://codegolf.stackexchange.com/a/99286/8478)
Hoping I didn't miss something. Computes **a(n) = n × (n + 1)**:
```
>*?"!&)<=@\\}
```
---
My version:
```
?"\>@&*})<\=!
```
Or the unfolded version:
```
  ? " \
 > @ & *
} ) < \ =
 ! . . .
  . . .
```
Note that the `>` in the top-left corner is unused (except for the 2sable program). I did this to confuse the robbers (but that obviously didn't work haha). 
[Try it online!](http://2sable.tryitonline.net/#code=Pio_IiEmKTw9QFxcfQ&input=Ng)
[Answer]
# 2sable, 15 bytes, [A087156](https://oeis.org/A087156)
```
D1QiA0*<}.;2->>
```
[Try it online](http://2sable.tryitonline.net/#code=RDFRaUEwKjx9LjsyLT4-&input=Nw)
The sequence of non-negative numbers, except for 1.
[Answer]
#  [Befunge 93](http://www.quirkster.com/iano/js/befunge.html), 14 bytes, [A121377](https://oeis.org/A121377),  [Cracked by milk](https://codegolf.stackexchange.com/a/99398/42854)!
```
&52* %68*+ .@Q
```
Fun fact: The intended solution to this is the first time I've ever used that language.
My solution in Pyth. &@ print an error, but that goes to STDERR which according to the OP is ignored.
```
+%Q*5 2*6 8.&@
```
[Answer]
# Python 2, 35 bytes, [A048735](http://oeis.org/A048735), Safe
```
print(lambda u:u&u<<1)(input())>>1
```
---
The original solution was in my own programming language [Wise](https://github.com/Wheatwizard/Wise).
```
:<<>&>print(lambda uuu1)(input())1
```
Most of the characters are irrelevant no-ops. The important characters are the first six. `:` creates two copies of the first item on the stack. `<<>` bit shifts twice to the left and once to the right which is equivalent to bit shifting once to the left. `&` takes the bitwise and of the top and second item (the original and the bit shifted copy). Lastly `>` bit shifts once to the right.
[Answer]
# 05AB1E, 5 bytes, [A000012](https://oeis.org/A000012), Safe
```
$;$1?
```
Sequence of 1's. [Try it online](http://05ab1e.tryitonline.net/#code=JDskMT8&input=ODY)
### Intended Solution: Arcyou
```
1;$$?
```
[Try it online](http://arcyou.tryitonline.net/#code=MTskJD8&input=NTQ). I couldn't find documentation for this language, so don't have an explanation of how it works exactly.
[Answer]
# ~~Python 2, 70 Bytes, [A000217](https://oeis.org/A000217)~~ [Cracked!](https://codegolf.stackexchange.com/a/99210/25180)
I have a feeling this won't be cracked in the language I used for the other version, we will see :)
```
o=input()
v=0
i=1
while o:
 v+=i
 i+=1
print v
#|  d00->1@@@++-^,,[
```
---
I realized afterwards I had incorrectly obfuscated the code (it doesn't change the posted answer's validity). Here's the code I started with in Haystack:
```
v
0
v
0
i
1
-
>      d0[v
^-1@+@d+1@?,,o|
```
[Answer]
# ~~[05AB1E](https://github.com/Adriandmen/05AB1E), 9 bytes, [A000042](http://oeis.org/A000042)~~ [Cracked!](https://codegolf.stackexchange.com/questions/99156/polyglot-anagrams-robbers-thread/99329#99329)
```
1×,1*-^$)
```
This is the *Unary representation of natural numbers* (OEIS). So if the input was `3`, for example, then output would be `111`.
Explanation:
```
                    # implicit input
1                   # pushes 1 to the stack   
 ×                  # pushes "1" × (the input)
  ,                 # outputs the stack
   1*-^$)           # irrelevant
```
[Try it online!](http://05ab1e.tryitonline.net/#code=McOXLDEqLV4kKQ&input=Nw)
---
# Original Solution, [Carrot](https://github.com/kritixilithos/Carrot)
```
1^*$-1×^)
```
Explanation
```
1^             Push "1" to the stack
  *            Multiply the string by
   $-1         ...the input (as an integer) minus 1 times
      ×,)      Ignored by the interpreter
```
The `*` multiplies the string by `(n+1)` times, so that `a^*3` results in `aaaa` and not `aaa`. So that is why I subtracted `1` from the input.
Only now I realise that the `)` has been irrelevant in both the languages :D
[Try it online!](http://kritixilithos.github.io/Carrot/)
[Answer]
# J, 2 bytes, [A000290](http://oeis.org/A000290), [Cracked](https://codegolf.stackexchange.com/a/99379/31957)
```
*~
```
Well, might as well start going for those two-byters. Yields **n** × **n**, or **n**2.
## ~~intended solution, Jolf, 2 bytes~~
```
*~
```
Well. Yeah. This is my own language and I think it works because `~` looks for an extended character, but doesn't find one, so it just ignores it. ¯\\_(ツ)\_/¯ Oops.
[Answer]
# ~~[ABCR](https://github.com/Steven-Hewitt/ABCR), 24 bytes, [A023443](https://oeis.org/A023443)~~ [Cracked!](https://codegolf.stackexchange.com/a/99394/55696)
```
70: Quit xi. Classy queue!
```
There's a bunch of no-ops. Calculates `n - 1`.
[Answer]
# 05AB1E, 8 bytes, [A000042](https://oeis.org/A000042), [Cracked](https://codegolf.stackexchange.com/a/99348/41805)
```
F1}J,(1&
```
Test cases:
```
1 -> 1
2 -> 11
3 -> 111
```
[Answer]
## ~~[Ouroboros](https://github.com/dloscutoff/Esolangs/tree/master/Ouroboros), 6 bytes, [A000012](https://oeis.org/A000012)~~ [Cracked](https://codegolf.stackexchange.com/a/99468/42545)
```
)49.o(
```
Always outputs `1`.
]