这是警察的话题。强盗的线索在这里。

最后的警察和强盗线索已经在4个月前。

警察的任务

• 警察的任务是编写一个程序/函数，该程序/函数采用一个正（或非负）整数并输出/返回另一个整数。
• 如果程序不能容忍零，则警察必须声明它。
• 警察将提供至少2个样本输入/输出。
• 例如，如果我决定编写斐波那契数列，则可以在答案中写成：

a（0）返回0
a（3）返回2

• 示例的数量取决于警察的判断。
• 但是，该序列实际上必须存在于IntegerSequences®的在线百科全书中，因此没有适合您的伪随机数生成器。:(
• 警察可以根据需要隐藏尽可能多的字符。
• 例如，如果我的程序是：

function a(n)
    if n>2 then
        return n
    else
        return a(n-1) + a(n-2)
    end
end

• 然后，我可以根据需要隐藏这些字符：

function a(n)
    if ### then
        ########
    else
        ######################
    end
end

强盗的任务

• 显然是在寻找原始源代码。
• 但是，只要在OEIS中也可以找到任何建议的产生相同输出集的源代码，那么这些源代码也将视为有效。

警察提示

• OEIS中的搜索功能仅适用于连续项，因此，如果您想隐藏序列，则只需在任何地方留一个空洞即可。
• 显然没有办法隐藏序列。选择顺序时，请记住这一点。

您的分数是代码中的字节数。

获胜者将是7天内未破解的最低分数。

只有2016年4月发布的作品才有资格获奖。欢迎晚于此发布的投稿，但不能获胜。

为了获得胜利，您需要显示完整的代码和OEIS序列（7天后）。

您的帖子应采用以下格式（NN是字符数）：

Lua，98个字节

输出：

a(0) returns 0
a(3) returns 2

代码（#标记未公开的字符）：

function a(n)
    if ### then
        ########
    else
        ######################
    end
end

如果代码被破解，请插入[Cracked](link to cracker)标题中。如果提交是安全的，请在标题中插入“安全”，并在答案中显示完整代码。只有显示完整代码的答案才有资格获胜。

Vim，36击-安全！

i****<esc>:let @q="^*i****$**@***"<cr><n>@qbD

（注意：<n>您在此输入内容）

以下是与数字生成无关的代码：

          :let @q="              "<cr><n>@qbD

意思是我要显示19个字符中的5个。

<n>是输入。以下是一些示例输出：

1@q:    1
2@q:    3
6@q:    18

回答

此代码将打印卢卡斯数字（A000032），与Fibonnaci序列相似，只是它以开头2, 1而不是1, 1。以下是前15个数字：

2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123, 199, 322, 521, 843

这是显示的代码：

i2 1 <esc>:let @q="^diwwyw$pb@-<c-v><c-a>"<cr><n>@qbD

说明：

i2 1 <esc>                          "Insert the starting numbers
          :let @q="....."<cr>       "Define the macro 'Q'

宏说明：

^                      "Move to the first non-whitespace character on the line.
 diw                   "(d)elete (i)nner (w)ord. This is different then 'dw' because it doesn't grab the space. 
                      "It also throws people off since 'i' is usually used for inserting text.
    wyw$               "Move to the next number, yank it then move to the end of the line 
        pb             "(p)aste the yanked text and move (b)ack
          @-     <c-a> "@- is the register holding the word we deleted. Increment the current number that many times.
            <c-v>      "Since we're adding <c-a> this from the command line, we need to type it as a literal.

现在，我们只需要删除第二个数字，因为第一个数字是我们想要的卢卡斯数字。所以我们做

b   "move (b)ack
 D  "(D)elete to the end of the line.

另外，如果我没记错的话，这是第一个安全提交！挺酷的。

05AB1E，5个字节，安全

今天的最后一个：p。输出：

a(0) = 9
a(5) = 4
a(10) = 89

码：

___m_

混淆的字符用表示_。在线尝试！-链接。使用CP-1252编码。

解：

žhžm‡

说明：

žh       # Short for [0-9].
  žm     # Short for [9-0].
    ‡    # Translate.

在线尝试！或尝试所有测试用例！。

元素，7个字节，已破解

输出：

a(3) = 111
a(7) = 1111111

该#是隐藏人物，而且都是可打印的ASCII。我认为这实际上是相当困难的（因为仅缺少5个字符）。

###,##}

为了方便起见，这是“ 在线试用”和Esolang Wiki页面。

我原来的程序是：

_'[,$ ` }

诀窍是

]并且}在功能上相同（均}在Perl中翻译为）。另外，我过去常常,$产生一个1额外的混乱层，尽管这样做有可能,完全忽略它,1。

Jolf，5个字节，已破解

输出：

a(2) = 8
a(10) = 4738245926336

所有这些都是至关重要的，我已经展示了5之1。

####x

原始代码：

mPm$x
mP     cube
  m$   catalan number
    x  input

在线尝试！

JavaScript（ES7），10个字节，已破解

输出量

f(0) -> 1
f(1) -> -1

码

t=>~t##**#

每晚在Firefox中对其进行测试。该代码是一个匿名函数。这可能很容易，因为只隐藏了三个字符，但至少很短！：P

我的原始代码是：

t=>~top**t

但是在强行使用自己的代码寻求解决方案之后，我很快意识到

t=>~t.x**t（x可以是任何变量名字符）

也可以使用。这行得通，因为

在原始的ES7幂运算符规范中，该运算符的优先级比一元运算符低（与常规数学和大多数其他语言不同）。~在t.x（undefined）或top（Object）上执行按位NOT运算，将它们转换为32位带符号整数（像0这样的不可广播对象变为），然后再进行NOT 运算（因此0变为-1）。我对此进行了更深入的研究，最近，该规范已更改为不允许使用类似的歧义（对于将来的高尔夫D：不利），但是大多数ES7引擎尚未更新到该规范的最新版本。

05AB1E，4字节（破解）

样本输出：

a(5) = 51
a(8) = 257

对于代码：

###^

我透露了最后一个。不过应该很容易，我很难找到一个序列:(

所有隐藏的字符都是可打印的。

MATL，5个字节，已破解

隐藏的字符用表示%。

%5%*%

输出：

a(1) = 3
a(2) = 6
a(4) = 12

输入0有效。

原始代码：

35B*s

那是，

35    % push number 35
B     % convert to binary: array [1 0 0 0 1 1]
*     % multiply element-wise by implicit input n: gives [n 0 0 0 n n]
s     % sum of array: gives 3*n

SWIFT，55字节，已破解

func M(n:Int)->Int{
return(n*****) ?M(**n****):n***;
}

* 标记隐藏字符

输出：

M(30) -> 91
M(60) -> 91
M(90) -> 91
M(120)-> 110
M(150)-> 140

功能接受 0

Ruby，46个字节，安全

编辑以添加免责声明/道歉：此序列以f [0]开头，而OEIS条目以f [1]开头。值是相同的。

混淆的代码（#是任何字符）：

->####or x##1###(#..##0#);x*=3;end;#.###ect:+}

打电话喜欢

->####or x##1###(#..##0#);x*=3;end;#.###ect:+}[3] (returns 39)

输出：

f[0] = 0
f[1] = 3
f[2] = 12
f[3] = 39
f[4] = 120
f[5] = 363
f[6] = 1092
f[7] = 3279
f[8] = 9840
f[9] = 29523

解：

f=->*x{for x[-1]in(0..x[0]);x*=3;end;x.inject:+}

序列：

http://oeis.org/A029858

说明：

这里的一个小技巧是将参数声明为*x而不是x。这意味着，如果您传入2，x则首先设置为[2]...。的主要伎俩利用离奇，公正地晦涩，的Ruby语法在这里你可以设置迭代器，for循环的赋值表达式的任何有效的左手边，而不是像一个迭代变量i。因此，它从0循环到（在此示例中）2，将每个数字分配给x[-1]，这意味着它将覆盖x的最后一个值。然后，循环主体x*=3通过将x连接到自身3次来进一步使x变异。因此，首先x变为[0]，然后[0,0,0]。在接下来的循环就成了[0,0,1]，然后[0,0,1,0,0,1,0,0,1]。最后我们传入2，它变成[0,0,1,0,0,1,0,0,2]，然后[0, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 1, 0, 0, 2]。然后，我们使用inject方法对结果求和，该方法+通过依次将（传入的方法）应用于每个元素来减少数组。如果我们考虑每次迭代如何变化的总和，我们看到，我们有效地通过3加1（用一个元素覆盖的最后一个元素一个更高版本），然后乘以自3*(n+1) = 3*n + 3上所描述的，这个工具亚历山大Wajnberg的递推关系的序列页。

05AB1E，3个字节，已破解

输出：

a(9) = 165
a(10) = 220

隐藏的代码：

##O

在线尝试可能会派上用场。

六角形，7个字节，已破解

输出：

a(1) = 2
a(2) = 4

隐藏的代码：

?#####@

或者：

 ? #
# # #
 # @

在线尝试可能会派上用场。

PHP，41字节，已破解

是的，最后又是警察与强盗的挑战。希望我没有那么容易。

输出量

a(5)   = 0
a(15)  = 1
a(35)  = 0
a(36)  = 1
a(45)  = 1

资源

____________________$argv[1]____________;
####################        ############

笔记

• 这是一个完整的程序，而不是一个功能。
• 从命令行读取输入（显然）。
• 不包含任何PHP开头标签。

开裂

我显然很容易做到，并且没有提供足够的示例。我想到的顺序是A010054：

如果n是一个三角数，则a（n）= 1，否则为0。

这是我的原始源代码：

echo(int)($r=sqrt(8*$argv[1]+1))==$r?1:0;

它测试输入是否为三角数并输出1还是0相应地。

Jolf，11字节，已破解，A011551

c*______x__

c*mf^+91x~P

原始代码：

c*^c"10"x~P

例子：

0 -> 1

12 -> 1618033988749

MATL，9字节，已破解

码：

3#2###*##

输出：

a(1)  = 3
a(2)  = 6
a(4)  = 12
a(12) = 37

a(0) 已验证。

开裂

原始序列： A059563

原始代码：

3L2^Ze*sk
3L          % Push [1 -1j] from the clipboard
  2^        % square
    Ze      % exp
      *     % times input
       s    % sum
        k   % floor

Java，479字节，已破解

输出：

a(10) = 81
a(20) = 35890

（通过命令行参数提供输入）

代码（#标记隐藏字符）：

import java.util.*;
public class A{

    public static int#########
    public boolean###########

    static A a = new A();

    public static void main(String[] args){
        int input = Integer.parseInt(args[0]);

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);
        l.add(0);
        l.add(0);

        for(int ix = 0; ################if(##>##{
            ###########d#
            #######+##p##########+##########(#######
        }

        System.out.println(#########################
            ###(A.#############(#5#####)));
    }
}

程序从索引0开始。

（请注意，SE \t用4个空格替换了所有缩进，使总字节数变为569。单击此处以查看带有\t缩进而不是空格缩进的程序。）

原始代码：

import java.util.*;
public class A{
    public static interface B{
    public boolean C(int i);} 

    static A a = new A();

    public static void main(String[] args){
        int input = Integer.parseInt(args[0]);

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);
        l.add(0);
        l.add(0);

        for(int ix = 0; ix<input; ix++)cif(i->  {
            return l.add(
            l.pop()+l.peekFirst()+l.peekLast());});{    
        }

        System.out.println(l.get(1));}static boolean 
            cif(A.B b5){return (b5.C((0)));
    }
}

（相同的代码，但格式正常）：

import java.util.*;

public class A {
    public static interface B { //functional interface for lambda expression
        public boolean C(int i); //void would have given it away
    }

    static A a = new A(); //distraction

    public static void main(String[] args) {
        int input = Integer.parseInt(args[0]);//Input

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);//Set up list
        l.add(0);
        l.add(0);

        for (int ix = 0; ix < input; ix++)
            cif(i -> { //Fake if statement is really a lambda expression
                return l.add(l.pop() + l.peekFirst() + l.peekLast());
            });
        { //Distraction
        }

        System.out.println(l.get(1));//Output
    }

    static boolean cif(A.B b5) { //Used to pass in lambda expression.
                  //The A. and b5 were both distractions
        return (b5.C((0)));
    }
}

八度，34字节，破解

@(m)(m###m#####m##)&isprime(#)####

输出：

ans(1) = 0
ans(6) = 5
ans(7) = 10
ans(8) = 15

序列从ans(1)OEIS中开始。

C，71字节已破解

############
#####
main(){
 scanf("%d",##);
 ###6#;
 printf("%d",##);
}

输出：

a(1) = 0   a(2) = 0   a(5) = 1
a(6) = 1   a(7) = 1   a(9) = 2

这适用于gcc，并且是完整程序。它接受0作为输入。

Pyth，70个字节，已破解

DhbI|qb"#"qb"#"R!1Iqb"#"#####+""s####2###;##lY+Q1Ih+""Z#####)=Z+Z1;@YQ

# 是隐藏的字符

已经破解了，所以这里是没有隐藏字符的versionn：

DhbI|qb"4"qb"0"R!1Iqb"1"R!0Rh+""sm^sd2cb1;W<lY+Q1Ih+""Z=Y+YZ)=Z+Z1;@YQ

样本输出：

a(2) -> 10
a(4) -> 19

希望能在OEIS上找到它，我个人未能从这些示例中找到它（即使序列很容易发现）。

Ruby，38个字节，已破解

混淆的代码（#可以是任何字符）：

->#{(s=#########).sum==#3333&&eval(s)}

输出：

输入乘以10（A008592）。适用于任何整数，包括0。例如

->#{(s=#########).sum==#3333&&eval(s)}[3]  => 30
->#{(s=#########).sum==#3333&&eval(s)}[10] => 100

05AB1E，5个字节，已破解

输出：

a(0) = 0
a(1) = 0
a(2) = 1
a(3) = 1
a(4) = 1
a(5) = 1
a(6) = 1
a(7) = 1
a(8) = 1
a(9) = 1
a(10) = 0
a(11) = 0

混淆代码：

_____

在线尝试！-链接。

05AB1E，4个字节，已破解

那么，我想我对CnR的上瘾了……混淆代码（_表示通配符）：

____

序列：

a(1) = 2
a(4) = 6720

OEIS中的序列从a（1）= 2开始。

在线尝试！-链接

Lua，45字节，已破解

一个小提示：

a(0) will make the program crash :)

输出量

a(1)=>0
a(2)=>1

码

用于#隐藏代码:)。

a=function(n)#####n###### and #or ########end

我正在使用OEIS A007814和以下代码：

a=function(n)return n%2>0 and 0or 1+a(n/2)end

Pyke，15字节，安全

输出量

a(2) = 21
a(15) = 17

显示的代码：

#R#D######+##)#

解：

OEIS A038822
wR}DSR_Q*L+#P)l
我在这里使用了几个红色的鲱鱼，wR}用于生成数字100并显示R通常用于旋转堆栈的字符。我还使用#P)l了更简单的方法mPs来计算序列中的素数。

C，82字节，安全

####=############
main(i){scanf("%d",##);
for(i=1;i++/4<#;)##=2;
printf("%d",##);}

与gcc一起使用，它是一个完整的程序，可以从stdin读取输入并将其输出打印到stdout。这里的序列是A004526，floor（n / 2）。

a(0) = 0    a(1) = 0    a(2) = 1
a(3) = 1    a(4) = 2    a(5) = 2
a(6) = 3    a(7) = 3    a(8) = 4

解：

a;*b=(char*)&a+1;
main(i){scanf("%d",&a);
for(i=1;i++/4<2;)a*=2;
printf("%d",*b);}

仅在小型字节序计算机上有效，并且仅在char1字节的大小时才有效。
并且仅当该字节高于最高字节的字节的a值为0时。我认为这对于gcc是正确的，因为默认情况下，未初始化的全局变量进入bss段，而已初始化的全局变量进入数据段（请参阅https：// stackoverflow.com/questions/8721475/（如果将a-global-variables-is-initialized-to-0-will-it-go-bss）。
因此，仅a进入bss（唯一的其他全局变量b被初始化，因此进入数据段）。如果a不是在bss的末尾，则比bss的最高位字节高的字节a也在bss中，因此值为0。

05AB1E，1个字节，已破解

_

_ 表示隐藏的代码。

f(1) == 1
f(18) == 6

元素，10个字节，已破解

输出：

a(3) = 6561
a(4) = 4294967296

在Element中可能只有几种方法可以计算此序列。我找到了9个字符的解决方案，但是我发现这个10字符的解决方案实际上更困难。该#是隐藏字符。

#_####@^#`

为了方便起见，这是“ 在线试用”和Esolang Wiki页面。

原来是

2_3:~2@^^`

Pyth，18个字节

# 标记未公开的字符。

L?Jtb##5#m##S#2 #y

输出（从开始1）：

1 -> 2
2 -> 3
3 -> 5
4 -> 7

在线口译

05AB1E，5个字节，已破解

我希望这个提交不像我其他的提交那样容易：p。输出：

a(0) = 0
a(1) = 1
a(2) = 6
a(3) = 24
a(4) = 80
a(5) = 240

混淆代码：

####O

虽然包含一些非ASCII字符，但使用CP-1252编码。

在线尝试！可能会派上用场：p。

Jolf，11个字节，已破解。

输出：

a(10) = 4
a(20) = 6
a(30) = 8

以及部分隐藏的代码：

####xd###x#

暗示：

当我按顺序浏览这些序列时，我并没有走很远就找到了这个序列。

破解版与我的原始代码不太一样。我目前不在电脑上，所以我没有它，但是它是这样的：

l fzxd!m%xH

（我不确定的唯一部分是!m。它检查变量是否为零。）

派克（Pyke），6个字节，已破解

###X#s

输出：

a(2) = 8
a(8) = 80
a(10) = 120

N <1时不起作用

原始解决方案：

hSmX$s