这是警察和强盗的挑战。这是强盗的线索。在警察的线程是在这里。

警察将从OEIS中选择任何序列，并编写一个程序p，该程序打印出该序列中的第一个整数。他们还将找到一些字符串s。如果将s插入p，则此程序必须打印序列中的第二个整数。如果将s + s插入p的相同位置，此程序必须打印序列中的第三个整数。s + s + s在相同位置将打印第四个，依此类推。这是一个例子：

Python 3，序列A000027

print(1)

隐藏的字符串是两个字节。

字符串为+1，因为程序print(1+1)将打印A000027中的第二个整数，程序print(1+1+1)将打印第三个整数，依此类推。

警察必须揭示序列，原始程序p和隐藏字符串s的长度。强盗通过找到任何字符串裂纹提交到该长度并插入它来创建序列的位置。该字符串不需要匹配预期的解决方案即可成为有效裂纹，插入字符串的位置也不需要。

如果您破解了其中一个警察的答案，请发布解决方案（显示隐藏的字符串和位置）以及答案的链接。然后评论警察的答案，并在此处提供您的破解链接。

规则

• 您的解决方案必须能按顺序使用任意数量的数字，或者至少要解决由于内存限制，整数/堆栈溢出等原因导致失败的合理限制。

• 胜出的强盗是破解最多提交内容的用户，而决胜局是首先达到该破解数量的用户。

• 获胜的警察是最短的s未被破解的警察。决胜局是最短的p。如果没有完整的意见书，那么拥有解决方案的警察将获得最长的胜利。

• 为了声明安全，您的解决方案必须保持完整状态1周，然后显示隐藏的字符串（及其插入位置）。

• s可能不是嵌套的，它必须首尾相连。例如，如果s为10，则每次迭代都会进行，10, 1010, 101010, 10101010...而不是10, 1100, 111000, 11110000...

• 禁止使用所有加密解决方案（例如，检查子字符串的哈希）。

• 如果s包含任何非ASCII字符，则还必须指定使用的编码。

Python 2，xnor的序列A138147

原版的：

print 10

破解：

print "1%s0"%10
      ^^^^^^^

在线尝试！

Nitrodon的Brain-Flak，A000984

({({}<>({}))<>}<>){({}<>)<>}<>

这只有30个字节，不确定Nitrodon的想法。

在线尝试！

说明

我尝试了很多事情，但这是行得通的。A000984的术语是Pascal三角形的中心元素。

现在我发现可以通过将它们对角线加起来得到它们：

例如：

$1+3+6+10 = 20$

而且由于Nitrodon程序的最终操作是总结所有这些内容，因此它们似乎是一个不错的候选人（更像是我尝试了一堆东西，但最终却奏效了）。

因此，我们需要一个程序，该程序取一个部分和并产生下一个部分。幸运的是，有一种非常巧妙的方法可以将其中之一转移到下一个。每行是下一行的增量。这是$n$连续第项是的区别$n$日和$n-1$下一行的个方面。

一个问题是我们没有足够的最后一行来计算所需的行。由于如果有一行，则每一行都比最后一行长，因此无法使用此方法获得下一行的最后一个成员。但是，这里还有另一个技巧，每行的最后一个成员等于该行的所有先前成员！

$1+3+6=10$

而且，如果您熟悉Brain-Flak，它应该会很容易做到，并向您展示。

现在查看代码：

首先，我们进行下一行计算，其中每个新成员是两个相邻旧成员的总和。可以通过以下方式完成：

{({}<>({}))<>}<>

它基本上将元素移到上方并添加（不删除）它上面已经存在的内容。但这会颠倒一切，因此对于下一次我们需要返回的行，请放回原处。

{({}<>({}))<>}<>{({}<>)<>}<>

现在我们需要计算该行的最后一个成员。正如我之前所说，这非常容易。由于我们在该行的所有元素上都有一个循环，因此我们可以取该总和并将其推入。我们将其推入第二个循环之前，使其最终到达底部。

({({}<>({}))<>}<>){({}<>)<>}<>

就是这样。

精神鞭A，A000290，作者：Sriotchilism O'Zaic

原版的：

((()))({}<>)

破解：

((()))({}([])[]<>)
         ^^^^^^

在线尝试！

或者：

((())([])[])({}<>)
     ^^^^^^

在线尝试！

MATL，Luis Mendo的序列A005206

原版的：

voOdoO

在线尝试！

破解：

voOdoOdNq17L/k
      ^^^^^^^^

我不是MATL专家，但是据我了解，原始文件voOdoO会创建两个空数组和一个[0]堆栈上的数组。这[0]是在不带括号的情况下打印的序列的第一个元素。破解/解决方案然后执行以下操作：

• d从堆栈中取出一个元素，并（假设它是一个数字或大小为1的数组）将其变成一个空数组。这些空数组不会被打印，但是会增加堆栈大小
• Nq计算堆栈的大小并减去1。这是n+1评估函数时的用语（因为它从2开始，并且由于d向堆栈中添加了不可见的内容，因此每次迭代都增加1 ）
• 17L 这是常数 Phi = (1+sqrt(5))/2
• /k它执行的floor((n+1)/Phi)是计算序列元素的公式之一。该公式在OEIS上列出，因为a(n) = floor(sigma*(n+1)) where sigma = (sqrt(5)-1)/2我们使用的是身份(sqrt(5)-1)/2 = 1/Phi

Python 3- A__

print(100+-1)

在线尝试！

100瓶啤酒，添加-1以获取下一个数字99，依此类推。

小桶，序列A000045，通过A__

原版的：

0.

破解：

01":&+.
 ^^^^^

请注意，挑战在于找到长度<= 6的子字符串，但找到的字符串长度为5。

对于那些谁懒得抬头小桶规范的命令的定义： 0和1推动相应数量的堆栈; "将纸叠顶部移动到纸叠底部（滚动）； &如果栈顶是空的，则将栈顶弹出到寄存器中，否则将寄存器清空到栈中； +相加前两个堆栈值。

首字母1"只是在堆栈底部插入1。这个不断增长的1列表仅在第一次迭代中起作用，它使我们能够假设堆栈开始时1 0不是0。的确，重复10:&+.该:&+部分的程序具有与上述解决方案完全相同的行为，只是它的底部没有越来越多的1。

由于&在重复部分仅使用一次并且具有交替的行为，因此的行为1":&+取决于迭代的奇偶性。

现在，该程序并没有真正打印从一开始就从0，1开始的斐波那契序列。它实际上从第二个位置（即从0开始）打印1，0斐波那契数列。

• 在第一次，第三次，...迭代中，状态从开始，在[a, b]结束a+b (&=b)。
• 在第二，第四，...迭代中，状态从开始，在[b] (&=a)结束[b, b+a]。

实际上，这可以根据需要计算顺序。

Java 8+，本杰明·厄克特（Benjamin Urquhart）的序列A010686

()->System.out.println(1^4);
                        ^^

精神鞭 -，A000578 ，作者Sriotchilism O'Zaic

原版的：

((())<>)

在线尝试！

破解：

((())(({})([][][]){})<>)
    ^^^^^^^^^^^^^^^^

在线尝试！

吡咯，序列A083420，由MLavrentyev撰写

fold({(b,e):(2 * b) + 1},1,[list: 0,0,])
                                  ^^^^

您可以在这里运行它，但是我还没有弄清楚如何链接到代码。您将不得不复制粘贴。

提供的函数将忽略其第二个参数。它将其第一个加倍，并添加一个，这将生成2^n - 1此处所需的必要序列-我需要做的就是告诉它执行该操作多少次，方法是更改​​折叠列表的长度。幸运的是，Pyret并没有抱怨结尾的逗号。

Python 3，序列A268575，由 A268575

原版的：

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW")
print(len(W))

破解（100字节）：

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW");A=-1,1,0;*X,=F(lambda a:(S(a,x)for x in product(A,A)),W);W={p for p in X if 2<X.count(p)<4+({p}<W)}
print(len(W))

在线尝试！

据我所知，原始代码正在设置定义，以使隐藏的字符串尽可能简略，然后定义初始的“人生游戏”模式。然后，隐藏的字符串等效于以102字节编写Conway的《生命游戏》的迭代。

出于此破解的目的，该S函数将其参数内的元素（即可迭代对象）求和，F并将一个返回可迭代对象的函数应用于列表中的每个元素，并将所有结果粉碎在一起。

• ;A=-1,1,0;结束前面的语句，并用A缩写元组（-1,1,0），A用于product(A,A)给出相对于给定单元格以及单元格本身的所有邻居。
• *X,=F(lambda a:(S(a,x)for x in product(A,A)),W);通过X将邻居的相对位置添加到每个单元格并将它们粉碎到一个列表中，创建一个新列表，其中包含所有单元格的所有邻居以及单元W格W本身。
• W={p for p in X if 2<X.count(p)<4+({p}<W)}遍历此列表X，确定X下一个迭代中的每个单元格是否属于该单元格集中。这几乎是从《生活游戏》高尔夫中逐字记录的。

Haskell，A014675，Khuldraeseth na'Barya

原始码

main=print$uncurry(!!)([2],0)

带子串

main=print$uncurry(!!)                                   ([2],0)
                      $(\(a,n)->(a>>= \e->2:[1|e>1],n+1))

在线尝试！

桌面计算器，A006125，作者：A__

原版的：

1n

破解：

1 2lx1+dsx^*n
 ^^^^^^^^^^^

在线尝试！

简单实施。

cQuents，序列A003617由斯蒂芬·

=10#2:pZ
  ^

在线尝试！

从最低的n + 1位数字开始，依次为1和n个零。的#2指定只序列，其序列定义施加一次到种子的第二项，将被打印; 该序列定义仅查找并返回下一个质数。

Python的3 - agtoever

from sympy import isprime, primerange
from itertools import count
r=1
r+=1
while isprime(r-2)or r&1<1and r>3:r+=1
print(r)

在线尝试！

MATL，路易斯·门多（Luis Mendo）的序列A000796

原版的：

'pi'td1_&:_1)Y$J)

在线尝试！

破解：

'pi'td1_&:|SQ_1)Y$J)
          ^^^

原始作者偷偷创建了数组[-7:-1]，然后提取并取反了数组的第一个元素以得到7。然后，他用它获得pi 3的第7位四舍五入（即），并将其作为pi的第一个数字呈现。添加后|SQ，原始数组将全部变为正数，对其进行排序，然后对所有数组添加一个。这意味着在获取所有内容之后而不是7获取索引-2之后，它在一个应用程序-3之后，在两个应用程序之后等等获得索引。-之所以重要，是因为它告诉Y$函数不要四舍五入数字。

第四（gforth），A000042，作者NieDzejkob

.( 1)1 .
^^^^^

在线尝试！

平凡的1-byter只是在扩展文字。问题是，最早在第19位溢出64位。简单的解决方法是重复打印一位数字，对吗？是的，但这不是那么容易。尽管添加1 .到末尾确实会打印出我们需要的其他数字，但它们之间将用空格隔开。那是行不通的。

现在，根据Wikipedia的说法，“ .(（.-paren）是一个立即词，用于解析由括号分隔的字符串并显示它。” 幸运的是，该显示没有其他奇怪的字符，因此.(用于打印单个1就足够了。确实如此。右括号后不需要空格，因此可以将这五个字符（右括号后有空格）重复到我们的内心。为了演示，我在TIO中提供了一个示例，该示例将64位int多次溢出。奇迹般有效。

Unefunge-98（PyFunge） ，序列A000108，通过NieDzejkob

1# 2g1+:2p4*6-*2g/.@
 ^^^^^^^^^^^^^^^^^

在线尝试！

重复六遍

允许保留两个字节中的十九个字节！似乎是空格的地方实际上是一个0x01的页眉起始字符。

说明：

这个挑战全部a(n)来自于产生a(n-1)，也许n。OEIS提供了显式公式a(n) = (2n)!/(n!(n+1)!)，可以很容易地将其转换为a(n) = a(n-1) * (4n-6) / n。现在在Funge中实现这一点。

我必须在1和之间插入代码.。那是已经完成的难题的一半。剩下的就是要插入什么代码？Funge在堆栈操作工具中特别缺乏，因此堆栈的底部是禁止进入的。我需要同时跟踪n并a(n)没有增长堆栈。与使用Funge空间相比，如何做得更好呢？

我的计数器是那个0x01字符n。我一直a(n)在堆栈上，因为在我执行完位之后它必须在堆栈上。

1# 2g1+:2p4*6-*2g/.@
1                       Push 1. This is a(0).
 #                        Skip the next instruction. Without this, I believe the instruction pointer will reverse direction upon encountering 0x01.
   2g                     Push the third character in the source, which starts out as 1.
     1+                   Increment it...
       :                  ...copy it...
        2p                ...and put it back. One copy remains atop the stack.
          4*6-            Multiply by four. Subtract six.
              *           Multiply by a(n), leaving the result alone on the stack.
               2g         Push n again...
                 /        ...and divide our intermediate result by it. Ta-da!
                          At this point, the stack is the same as at the start of the indented block, except the one item has been advanced one place in the sequence.
                          The source of the program has changed; the third character holds the number of times this indented block has run.
                  .@    Print and terminate.

tsh的Python 3，A008574

print(1*2+2)
       ^^^^

在线尝试！

V，A000290，作者：DJMcMayhem

é*Ä2é*Ø.
  ^^^^

从1产生平方。

在线尝试！

基数在整个缓冲区中é*插入*并Ø.计算非换行符的数量。插入Ä将顶行复制到其自己的行上，在该行上2é*插入**。插入的串联产生连续的奇数，最大的在顶部。最终Ø.的结果实际上是将前n个奇数相加，从而得出第n个平方。

AsciiDots，序列A019523由安良

\ +++ /
// \ / \

一旦！

两次！

十次！

在试图弄清楚代码/语言的工作方式时，我了解到现有代码的前两行完成了无限输出Fibonacci序列的所有工作。当任何点到达时&，代码终止，因此我只需要在其余行中增加进一步的延迟，以允许输出适当数量的条目。

经过一番尝试，错误和观察，我发现正确的延迟间隔是每个数字16个时间单位。在一行中放入足够的字符似乎是不可行的，因此我需要将延迟分为两行，而实际的延迟则需要保留10个字符。为了使模式与自身匹配，两行必须具有5个字符，并且由于行中的中间三个字符可以被遍历两次，因此可以根据需要提供16个时间单位。

要求将其匹配到&第八列中的要求似乎使这成为不可能，直到我意识到我可以在第三行的内部以换行符开头。这样使倒数第二行的长度正确，并删除了第三行的现在冗余的末尾。

Brachylog，序列A114018由不相关的字符串

原始程序：

≜ṗ↔ṗb&w

要插入的字符串：

≜ṗ↔ṗẹbb&w
    ^^

在线尝试！

说明

首先是对原始程序的说明（知道所使用的序列是“数字反转也是素数的最小n位素数”）

≜         Assign an integer value to a variable named ? 
            (try 0, then 1, then -1, then 2, etc.)
 ṗ        ? must be prime
  ↔ṗ      The reverse of ? must be prime
    b     Remove the first element of ?
     &    Ignore that we removed that element
      w   Write ? to STDOUT

如您所见，该程序非常简单，除了一件事：存在一个完全无用的b - behead谓词调用，该调用删除了数字倒数的第一个元素，而我们不执行任何操作。

这是关于如何找到字符串的明确线索。这个想法是，由于我们想在每次添加字符串时都将数字的长度增加1个数字，因此我们需要一个字符串，该字符串以某种方式使用“无用”来“评估”该数字的长度b。

解决方法是使用ẹb：首先，ẹ - elements将数字转换为数字列表；然后，将数字转换为数字列表。然后，b - behead将删除其第一个元素。诀窍是，b如果数字列表为空，则将失败。因此，每次添加a时b，我们都会将所需数字的长度增加1（因为直到分配给的值?足够高以包含足够多的数字以至于最后一位b应用于一个数字列表，否则它将失败）。

ẹ每次重新申请都无效，因为它已经是一个数字列表。我们一开始只需要一次，因为如果我们将一个数字斩首9001而不是其数字列表，那么我们将001 = 1失去该数字的信息。

VDM-SL，A000312，过期数据

let m={1|->{0}}in hd reverse[let x=x+1 in x**x|x in set m(1)&x<card m(1)]
                             ^^^^^^^^^^^^^

由于VDM-SL的let-expressions可以重新绑定已经在封闭范围内绑定的变量，因此x**x可以在嵌套范围内任意深度地进行评估x，该范围比以前的范围大一个，而原始x范围仍然小于的基数m(1)。

Haskell，A083318 by xnor

f=length     [2]
        $show

在线尝试！

Haskell，A000045（Fibonacci），通过Rin的Fourier变换

f = head $(flip(:)<*>sum.take 2)[0, 1]
         ^^^^^^^^^^^^^^^^^^^^^^^

在线尝试！

准确地为23个字节。

这个很有趣，有点棘手。反转的0和1使我离开了一段时间，然后才意识到这不是问题。$原始版本的缺乏让我尝试了一些粗略的东西，例如$...$id（一个字节太长），然后才意识到我可以将所有内容括在括号中。总而言之，这是一个不错的小难题。

H.PWiz指出，模式匹配可以为我节省至少五个字节：$(\[x,y]->[y,x+y])。那个无意义的挑战使我无处不在。