这个挑战有两个线程。这是警察的话题。强盗的线程位于此处。

您的挑战是选择一个OEIS序列，并用两种不同的语言编写两个完整的程序，当通过STDIN或其他形式的标准输入（其中n为任何正数）给定n时，该序列将生成序列中的第n个项目。但是，您的两个程序必须是字谜，这意味着每个程序都可以从对方的字母重新排列。

程序必须将数字的小数点后跟可选的空白输出到STDOUT。程序可以输出到STDERR，但是应该忽略它，如果隐藏的情况如此，则必须明确指出是这种情况。

如果愿意，也可以按字符代码输出。但是，如果您在隐藏的解决方案中这样做，则必须在提交的正文中注明。

然后，您将显示OEIS编号，其源代码以及它所使用的一种语言的名称。

如果抢劫犯找到了以您已经提出的语言以外的其他语言运行的原始提交的字谜，则盗贼会破解您的提交。要破解答案，他们必须只找到能产生顺序且是原文的字谜的任何语言和程序，而不一定是您正在考虑的答案。

因此，您会受到激励，使他们尽可能难于使用其符号列表来查找完成任务的任何语言。

计分

这是代码高尔夫球，所以最短的，完整的程序是赢家。

语言能力

如果两种建议的解决方案都不能用两种语言完成任务，则将认为语言是不同的。只要警察的解决方案或强盗的解决方案都不能使用另一种语言输出正确的语言，这将包括同一语言的不同版本。

即，如果有两个解决方案1和2分别使用语言A和B，则解决方案2不能使用语言A产生正确的输出，解决方案1不能使用语言B产生正确的输出。

安全

一旦您的提交被破解了一个星期，您可以发布解决方案并声明您的发布安全。如果一周后您选择不发布解决方案，您的答案可能仍会被破解。

Python 2，118 字节，A042545破解

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|

我不想实现一个琐碎的序列，所以我决定使用我的PPCG用户ID。我先用另一种语言写了这本书，它应该给您提供关于该语言是什么的线索，尽管我打赌100美元，这会在打高尔夫球的一种语言中被破解，然后再被翻译成其他语言。

注意：由于浮点精度错误，仅在输入14时才是准确的。预期的解决方案是相同的。

预期的解决方案，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

尽管由于JS不支持负索引这一事实，所以该序列的存储方式与Python解决方案几乎相同，但是该序列以最大优先而不是最小优先的顺序存储。

Brain-Flak，24字节，A000290，安全

另一个方形解决方案。这次只不过是括号

({(({}[()])()){}[()]}{})

预期的解决方案是Brain-Flueue，它是使用队列而不是堆栈的Brain-flak版本。该程序是：

({(({})[()]){}}{})[()()]

这些语言被认为是不同的，因为当以另一种语言运行时，这两个程序都不会暂停。

Python 2，38 字节，A000290 Emigna破解

def e(X):return X*X
print e(input())##

这可能很容易破解。我主要是以此为起点。

CJam中的原始解决方案：

ri:XX*e#def ()return X
e#pnt (input())

CJam，7个字节，A005843 破解！

ri2*e#^

这是一个基本2*n序列。

说明：

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

在线尝试！

原创解决方案，胡萝卜

#^i*2er

胡萝卜是我创造的一种雪茄。我很久以前就停止开发它。我之所以选择它，是因为我希望其他语言很难注释掉代码中不必要的部分。

说明：

#^            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

在线尝试！

2sable，15个字节，A000290，破解！

跳上同一n ²列火车：p。

*?"!#$&<=@\^{|}

在线尝试！

Brain-Flak，44字节，A000290 破解

<({({})({}[()])}{}))()()()turpentine/"*"*4splint>

在线尝试！

原始解决方案，Python 2

print(input()**(len(set("{}{}{}[]()<>"))/4))

Excel，12字节，A000012 破解

=IF(1=1,1,1)

也许不是最艰难的，但可以破解。

Python 2，25个字节，A000583，已破解

Y=input("");print`Y**4`,X

打印输出后，该程序退出并出现错误。

我的隐藏代码（与破解解决方案大不相同！）：

其实 25个位元组

4,n`*`Y")ii(*nppruttY;="X

在线尝试！

说明：

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

Python，118字节，A042545，安全

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])

这次它可以同时在2和3中使用。并且没有任何评论！你会怎么做？

注意：与旧解决方案一样，由于浮点算术错误，这在前15个项后会失去精度。

预期的解决方案，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])   

尽管我保留了多个旧版本，但是我还是设法丢失了该副本，但是幸运的是，将其与其他版本拼凑在一起并不是一件难事。现在，我发现我prt在这两个程序中都有可能是多余的。那好吧。

Python 2，124个字节，A144945，[安全]

破解此漏洞将为您赢得500 rep赏金！太晚了！

在n X n棋盘上放置2个皇后以使其互相攻击的方法数量。

我希望这不太容易。我安排了代码，以使空白清晰可见。这些仅是空格和换行符。

_{注意：通过字符代码的预期解决方案输出}

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

在线尝试

旨在解决方案，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

这等效于以下BF程序：

>>,[->>>+>>>+>>>+++++<<<<<<<<<]>>>->>>>>>-<<<[[>+<-]>[>>[<<<+>>+>-]<[>+<-]<-]<<<<]>>+++>[-<-[<+<<]<[+[->+<]<+<<]>>>>>]<<<.,.

Fuzzy Octo鳄梨调味酱，26字节，A070627 [安全]

49++*5^pm#]%:"?:.=:#,|"1:@

测试用例：

1 -> 1
3 -> 23
5 -> 1

解：

^::::|*?1=#@]","%.#49++5pm

在Magistack中工作。

Pyth，75个字节，A004526 破解，牛奶

比起其他任何事情，它更像是一个有趣的测试，但是：

/Q/////////////////****22222 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2;;;;;

在线尝试！

牛奶的解决方案（凸）：

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;

在线尝试

预期解决方案（///）：

/*///;2/;// ///22/Q//2;///;//;***2222222222222222222222                    

在线尝试

在最后一个分号之前以2的形式输入，并输出正确数量的Q。

该序列是0索引的（即0为0，1为0，2为1，...）

在///中发现轻微的语法错误，因此编辑了所有解决方案。

MATL，7字节，A000217，已破解

:sp{1}x

序列是n(n+1)/2（三角形数），在输入开始n=1由挑战指定：1，3，6，10，...（用于输入输出0并不保证在这两个程序相同）。

使用其他语言的程序退出时出错（在STDOUT中生成正确的输出之后）。

在线尝试！

:            % 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

Python 2，37 字节，A000290破解

print(input()**(1+1))
"'10°3¢','m'"

Python 3，27字节，A000012，破解

这次没有输入！

if 1:
    if 1:
        print( '1' )

缩进是制表符，而不是保存字节-空格是必需的。

我认为它不需要TIO链接或说明！

（大概不会花很长时间就能破解）

预期答案（空格）：

-Start-


    if1:if1:print('1')
-End-

（开始和结束不是程序的一部分）

抱歉，我忘了补充说它可以打印到STDERR：

在线尝试！

Fuzzy Octo鳄梨调味酱，11字节，A001844 [Safe！]

hha02^d+**+

dh*h++^2*0a在Pyth中，可以进行工作的裂缝是。这不是正确的输出格式。

我的代码仍然在那里！（并且不在Pyth中）

测试用例：

0 -> 1
1 -> 5

解：

^++d0ah*2*h

在Jolf中。

WinDbg，39个字节，A000007 由jimmy23013破解

~e.block{j(0>=@$t0)?@$t0+(1<7);??0}t":"

的困难顺序0**n。

通过在伪寄存器中传递一个值来完成输入$t0。

我最初的解决方案是C＃：

@t=>(object)(0<@t?0:1)??"$$700~lk.{}+";

JavaScript ES6，38个字节，A000290，已破解

J=>eval(Array(J).fill(J).join`+`)|2-2;

这列方形火车很漂亮，但是走得很快。（得到它吗？方形火车吗？就像车轮吗？不？好吧，很好。批评家。）

预期答案：网状（在线尝试！），

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

MATL，13字节，A002275 破解！

i:"@ax'1']
v!

在线尝试！

说明：

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

2sable，13个字节，A002378，破解！

希望我没有错过任何事情。计算a（n）= n×（n + 1）：

>*?"!&)<=@\\}

我的版本：

?"\>@&*})<\=!

或展开的版本：

  ? " \
 > @ & *
} ) < \ =
 ! . . .
  . . .

请注意，>左上角的未被使用（2sable程序除外）。我这样做是为了使强盗迷惑（但这显然行不通哈哈）。

在线尝试！

2sable，15字节，A087156

D1QiA0*<}.;2->>

在线尝试

非负数的顺序，但1除外。

Befunge 93，14字节，A121377， 被牛奶弄碎了！

&52* %68*+ .@Q

有趣的事实：对此的预期解决方案是我第一次使用该语言。

我在Pyth中的解决方案。＆@打印错误，但转到STDERR，根据OP，该错误将被忽略。

+%Q*5 2*6 8.&@

Python 2，35个字节，A048735，安全

print(lambda u:u&u<<1)(input())>>1

最初的解决方案是使用我自己的编程语言Wise。

:<<>&>print(lambda uuu1)(input())1

大多数角色是无关的禁忌。重要角色是前六个。:在堆栈上创建第一项的两个副本。 <<>左移两次，右移一次，这等效于左移一次。 &取第一项和第二项（按原件和按移位的副本）的按位和。最后，>一次向右移位。

05AB1E，5字节，A000012，安全

$;$1?

1的序列。在线尝试

预期解决方案：Arcyou

1;$$?

在线尝试。我找不到该语言的文档，因此没有解释它的确切工作方式。

Python 2，70 字节，A000217破解！

我觉得不会用其他版本的语言破解，我们将看到:)

o=input()
v=0
i=1
while o:
 v+=i
 i+=1
print v


#|  d00->1@@@++-^,,[

之后，我意识到我对代码进行了错误的混淆（它不会更改发布的答案的有效性）。这是我在Haystack中开始的代码：

v
0
v
0
i
1
-
>      d0[v
^-1@+@d+1@?,,o|

05AB1E，9个字节，A000042 破解！

1×,1*-^$)

这是自然数的一元表示形式（OEIS）。因此3，例如，如果输入为，则输出为111。

说明：

                    # implicit input
1                   # pushes 1 to the stack   
 ×                  # pushes "1" × (the input)
  ,                 # outputs the stack
   1*-^$)           # irrelevant

在线尝试！

原创解决方案，胡萝卜

1^*$-1×^)

说明

1^             Push "1" to the stack
  *            Multiply the string by
   $-1         ...the input (as an integer) minus 1 times
      ×,)      Ignored by the interpreter

将*字符串乘以(n+1)时间，从而a^*3得到aaaa而不是aaa。这就是为什么我1从输入中减去。

直到现在，我才意识到)两种语言都无关紧要：D

在线尝试！

J，2字节，A000290，破解

*~

好吧，不妨开始寻找那些两个字节的文件。产量n × n或n ²。

预期的解决方案，Jolf，2个字节

*~

好。是的 这是我自己的语言，我认为它可以工作是因为~寻找扩展字符，但找不到扩展字符，因此它会忽略它。¯\ _（ツ）_ /¯糟糕。

ABCR，24字节，A023443 破解！

70: Quit xi. Classy queue!

有很多人。计算n - 1。

05AB1E，8字节，A000042，破解

F1}J,(1&

测试用例：

1 -> 1
2 -> 11
3 -> 111

衔尾蛇，6字节，A000012 破解

)49.o(

始终输出1。