这是强盗的线程这个挑战

警察将选择一个OEIS序列，并用两种不同的语言编写两个完整的程序，当通过STDIN给出n时，该序列将生成序列中的第n个项目。这两个程序必须互为字母，这意味着每个程序都可以从对方的字母重新排列。

他们将提供OEIS编号，源代码以及所使用的一种语言的名称。

您必须找到原始警察提交的字谜的字谜，该字谜以与警察使用的语言不同的语言运行。要破解答案，您必须只找到能产生该序列并且是原文的字谜的任何语言和程序，而不一定是警察在考虑的答案。

您可以按字符代码输出，也可以在解决方案中包含STDERR，但前提是警察已表明他们的隐藏解决方案可以这样做。十进制输出到STDOUT始终是有效的破解。

因此，激励警察使其尽可能地难以使用其符号列表来找到完成任务的任何语言。

计分

裂缝最多的人将是本节的获胜者。每个解决方案的仅第一个裂缝将计入一个人的分数。

排行榜

非常感谢参与此挑战的每一个人。

这是目前的排行榜

Place  User             Score
-----------------------------
1      Adnan            3
1      Kritixi Lithos   3
1      Emigna           3
1      milk             3
5      Steven H.        2
5      Wheat Wizard     2
5      jimmy23013       2
8      ETH Productions  1
8      Dennis           1
8      alleks           1
8      Martin Ender     1
8      Oliver           1
8      Conor O'Brien    1

05AB1E，38个字节，Loovjo，A000290

nXtdief e():return X*X
pr e(input())##

在线尝试！

很可能不是预期的解决方案，但它可以工作。

说明

n      # square input
 X     # push 1
  t    # push sqrt(1)
   d   # push is_number(1.0)
    i  # if true do the rest of the code (1.0 is not a number so it will never execute)

Jolf，15个字节，Adnan，A000290

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

在这里尝试！绝对不是预期的解决方案，但是，它可行。

说明

*&"?!#$|<=@\^{}
*                multiply
 &               the two inputs to this func, x, y: x && y
                 returns y if x and y, or the falsey argument.
  "?!#$|<=@\^{}  this string is always truthy, so the second arg is used.
                 two implicit inputs are taken, both equal to the first arg
                 so, this corresponds to *xx, which is x^2.

05AB1E，49字节，Wheat Wizard，A000290

实际上与Emigna的破解方法相同：p。

n4i<({({)({[()]){))()()()turpetne/"*"*splint>}}}}

说明：

n          # Square the input
 4i        # If 4 == 1, do the following...
   <({...

在线尝试！

05AB1E，35字节，Oliver，A000290

警察应该停止n^2在python中发布挑战...

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

在线尝试！

说明

n    # square input
 0i  # if 0 == 1 do the rest of the code

2sable，7个字节，Kritixi Lithos，A005843

码：

r^#ei2*

说明：

r         # Reverse the stack, which is a no-op
 ^        # XOR the input with itself, always leading to 0
  #       # If 1, break (which stops the program)
   e      # Compute input nPr input, which always leads to 1
    i     # If equal to one, do the following..
     2*   #   Multiply the input by 2.

在线尝试！

六角形，13字节，阿德南，A002378

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

在线尝试！

展开：

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

不是100％是否是原始的，因为左上角\未被使用。

这些<\>只是镜像，因此该程序实际上是完全线性的：

?"&)}=*!@

?          Read input.
 "         Move back and left.
  &        Copy input.
   )       Increment copy.
    }=     Move forward and right and turn around (to face the n and n+1 edges).
      *    Multiply.
       !   Print.
        @  Terminate.

V，13字节，DJMcMayhem，A002275

v!:x]''"
@ai1

在线尝试！

这可能是作者打算使用的第一种解决方案。

说明

v!:x]''"   Does nothing
@ai1       inserts 1 a times

2sable，Conor O'Brien，A000290

~*

在线尝试！

我不知道它是如何工作的，实际上只有一个程序可以满足要求，我只是勉强地找到了它所使用的语言。

浏览完文档后，我可以提出一个解释：

~         Push Input OR Input (always pushes the input)
 *        Multiply that by Input 

Pyth，26个字节，Steven H.，A023443

码：

tQ.qly 7:esau0euii s uxC !

在线尝试。

相当简单：

 Q                            Reads input
t                             Substracts 1 from it
  .q                          Quits program (implicit print)
    ly 7:esau0euii s uxC !    None of this ever plays a part...
                                I just thought it'd be fun to scramble it.

Python 3，118个字节， 3，118 ETHproductions，A042545

s,a=801**.5-28,[0,0==0]
for i in range(int(input())):a+=[a[i]+a[-1]*int(1/s)];s=1/s-1//s
(print(a[-2]),) #.0fhlmop|

在Ideone上进行测试。

警察提交

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|

有什么不同

警察提交在Python 3中不起作用有两个原因。

• Python 2的输入功能会自动评估一行输入，而Python 3的对应功能只是将输入返回为字符串。我们可以简单地调用int来解决此问题。

• print 是Python 2中的一个语句，但它是Python 3中的一个函数。特别是，这意味着我们必须用括号将其参数括起来。

这意味着我们需要int()和()，但是这些字符并不是注释的全部。这意味着我们必须进行一些更改。

而不是分数s，我们跟踪1 / s。

s – s=1/(801**.5-28)– 的初始化变为s=801**.5-28，保存字符1/()。

a – – 的更新中a [-1]的因数变为，花费了字符。int(s)int(1/s)1/

s – s=1/(s-int(s))– 的更新成为s=1/s-1//s，花费了字符1//，但保存了字符(int())。

中保存的字符()(int())涵盖了将代码移植到Python 3所需的字符，但是获得它们会使我们付出很多代价1//。我们可以拿//从评论中获取，但是我们必须将其保存1在其他位置。

保存所需1内容的一种方法（唯一的一种？）是替换a1的初始化中的用0==0。这花费了这四个字符，但是我们可以00从注释中获取。

到目前为止，我们有以下代码。

i=int(input());s=801**.5-28;a=[0,0==0]
for p in range(i):a+=[a[-2]+a[-1]*int(1/s)];s=1/s-1//s
print(a[i]) #,,,.()0fhlmo|

要恢复=我们现在“欠”的其中一个，我们可以用一个赋值重写s和a的初始化：s,a=801**.5-28,[0,0==0]此外，这还保存了一个;并花费a ,，可以将其添加到注释中或从注释中删除。

=可以通过不将输入存储在变量中来保存第二个range(int(input()))字符，即，代之以将字符保存在中i=。我们用我在循环后为好，但我^个元素一个是刚刚从右边第二个，所以我们可以替换i使用-2。出于同样的原因，a[-2]可以将循环体替换为i。

现在，我们可以对工作的Python 3代码进行排列：

s,a=801**.5-28,[0,0==0]
for i in range(int(input())):a+=[a[i]+a[-1]*int(1/s)];s=1/s-1//s
print(a[-2]) #,.()0fhlmop|

但是，此代码也可以在Python 2中使用！解决此问题的一种方法是替换print(a[-2])为(print(a[-2]),); 我们在注释中有我们需要的字符。如前所述，print是Python 3中的一个函数，因此它构造了元组（None，）。但是，Python 2的print 语句是一个元组文字内部的SyntaxError。

CJam，39个字节，牛奶，A000007

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

在这里尝试。

Pyth，7个字节，Luis Mendo，A000217

x:{ps}1

根据要求，程序在退出后错误退出 p刷新正确答案。

在这里在线尝试！

05AB1E，12个字节，tuskiomi，A000012

1,(FI1=1=1,)

在线尝试！

说明

1,            # print 1
  (           # negate input
   F          # that many times do (i.e. no times)
    I1=1=1,)  # the rest of the code

05AB1E，38字节，Conor O'Brien，A000290

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

在线尝试！

说明

这是基于Emigna在这里的破解。

n   #Squares the number
 2i #Runs the rest of the code if 2==1

05AB1E，27字节，boboquack，A000012

1 1pif:
    if :
        rint( '1' )

在线尝试

怎么运行的：

1                     # push 1
  1                   # push 1
   p                  # pop (1), push is_prime(1)
    i                 # pop (is_prime(1), false), if is false so don't execute rest

CJam，70个字节，Shebang，A000217

ri),:+








e#|  d00->1@@@++-^,[o=input(v=0i=1whil o v=i i+=1pnt v

在这里尝试。

凸，75字节，boboquack，A004526

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  e# push 2
 / e# pop first 2, divide, push result
   e# push a bunch of garbage but discard it all with semi-colons (;)
  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;

Dip，9字节，Kritixi Lithos

绝对不是预期的答案。

1^,-$)×1*

说明：

1$^,-)×   # Basically does nothing
       1* # Repeat "1" n times

点，6字节，DLosc，A000012

.()49o

我以为我会先尝试OP的esolang ;-)

在线尝试。

05AB1E，25个字节，Mego，A000583

码：

nnYi=put("");prit`Y**4`,X

说明：

n       # Square the input
 n      # Square the squared input
  Y     # Constant that pushes 2
   i    # If equal to 1, do the following:
    =put...

在线尝试！

浸，8字节，奥利弗，A000042

(1J&F},1

说明

              #Implicit Input
(             #Start range loop
 1            #Push 1 to the stack
  J           #Join all the elements in the stack
   &          #End program
    F},1      #These are ignored

有趣的是，这是预期的语言！Dip是由Oliver创建的esolang。

从命令行测试案例和运行中

$python3 dip.py
Dip v1.0.0 by Oliver Ni.
>>> (1J&F},1
> 4
1111
>>> (1J&F},1
> 7
1111111

2sable，14字节，Dopapp，A121377

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

在线尝试。

工作原理（或多或少）：

Q@
  5              # Push 5
    2            # Push 2
     *           # Pop (2), pop (5), push 5*2=10
      %          # Pop (10), pop (input), push input%10
       6         # Push 6
         8       # Push 8
          *      # Pop (8), pop (6), push 8*6=48
           +     # Pop (48), pop (input), push input+48
            .&

05AB1E，4字节，Oliver，A000012

p¥_1

在线尝试！

这是1s 的序列。

              # Implicit input
p¥_           # Does nothing
   1          # Pushes 1 to the stack
              # Implicit output

这种输出1无论输入是什么。

浸，5字节，奥利弗，A000012

`¸WW/

1无论输入是什么，该序列都将打印。Oliver的答案打印一个1.0。该程序还会打印一个1.0。这显然是预期的解决方案。

说明

`¸                  # push character `¸`
  W                 # pushes 1000000
   W                # pushes 1000000 also
    /               # divides the last two items in stack resulting in 1.0
                    # implicit output (1.0)

替代解决方案（@milk提供）

凸，5个字节

WW¸`/

在线尝试！

说明

                  // implicit input
W                 // pushes -1
 W                // pushes -1 also
  ¸               // calculates the LCM of the two numbers (which evaluates to 1)
   `              // finds its string representation
    /             // slices the string (so that it would evaluate to "1")
                  // implicit output