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

需要考虑的一个有趣问题是：

如果我有一个数字序列，那么在清楚我在说什么序列之前，我必须提供几个数字？

例如，如果我想谈的正整数，以便从开始$1$，我可以说，$1,2,3, \dots$，但事实是否真的足够了吗？

我有一个回答这个问题的方法，而作为代码窃贼，它涉及代码高尔夫球。如果产生这些术语的最短代码产生了序列的所有术语，则您已提供了足够的序列术语。如果我们从代码高尔夫的角度来考虑这一点，那意味着您已经提供了足够的测试用例，从而使通过测试用例的最短代码可以完成所需的任务。

挑战

这个挑战是警察和强盗的挑战。警察将在其中展示测试用例，而强盗将不得不寻找一种比预期序列更短的欺骗测试用例的方法。警察将提出以下内容：

• 一段代码，将非负整数作为输入，并产生一个整数作为输出。此代码将定义您的顺序。您的代码不需要支持0作为输入，而是选择将1作为最小输入。如果您的答案是这种情况，则应该很清楚。

• 任何可能影响输出的相关平台或语言要求，例如longint的大小。

• 一个数字$n$，以及该代码计算出的序列的前$n$项。这些将充当“测试用例”。

鼓励您解释序列的作用并链接OEIS（如果存在），但是定义序列的是您的代码，而不是描述。

强盗将使用比所介绍的语言短的语言来找到一个程序，并通过所有测试用例（对于前$n$输入产生与警察代码相同的输出）。强盗的代码在输出上还必须与警察的程序有所不同，即大于某个数字$n$。

警察在提交之前必须能够破解自己的答案。

一周后，警察可能会发现他们的裂缝并将答案标记为“安全”。标记为这样的答案将不再被破解。

计分

警察的答案将根据字节数进行评分，而字节数越少越好。破解答案的得分是无限的。

cQuents，4个字节（已破解）

"::$

在线尝试！

以下是八（n=8）种情况：

1 1
2 12
3 123
4 1234
5 12345
6 123456
7 1234567
8 12345678

代码说明：

"      Stringify sequence (join on "", remove it and see what happens)
 ::    Given input n, output all items in the sequence up to and including n
   $   Each item in the sequence equals the index

这样的序列是1,2,3,4,5 ...，它被连接""起来就变成12345 ...，并::表示它打印到输入。

Python 3， 66 57个字节（裂纹）

在编辑之前，由xnor
破解也由Cat Wizard破解

def f(n):x=n/10-2;return int(x*60-x**3*10+x**5/2-x**7/84)

在线尝试！

你好！这是要破解的序列。它为前40个元素赋予0索引，而不是OEIS序列$n=40$

[-54, -56, -58, -59, -59, -59, -59, -57, -55, -53, -50, -46, -43, -38, -33, -28, -23, -17, -11, -5, 0, 5, 11, 17, 23, 28, 33, 38, 43, 46, 50, 53, 55, 57, 59, 59, 59, 59, 58, 56]

Python 2，44个字节（已破解）

f=lambda n,i=1,p=1:n and-~f(n-p%i,i+1,p*i*i)

在线尝试！

质数。什么顺序可能更纯正？还是更过分了？你的目标是生产出第50个为质数n=1，以n=50。

该代码是从本技巧完全复制的威尔逊定理生成器。

替代顺序的不同值不是由于机器限制（例如溢出和精度）引起的。没有第三方图书馆。

破解由阿尔诺，@PoonLevi和Xcoder先生。

Wolfram语言（Mathematica），39 34字节（安全）

Check[{1,9,7}[[#]],18+Boole[#>9]]&

在线尝试！

看起来很简单，解决方案应该很困难。

1索引并且。该序列在OEIS上不可用。$n = 99$

{1, 9, 7, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19}

上面的列表等于：

Join[{1, 9, 7}, Table[18, 6], Table[19, 90]]

这是用于检查您的解决方案的模板：在线尝试！

预期裂纹

这里的问题是，当位数增加1时，输出增加1，前三个项除外；预期的解决方案与字符串转换有关。

因此，阅读有关在表达式和字符串之间转换的文档，您可以找到该函数SpokenString。

解决方案只是x^n针对各种输入的表达式的口语字符串版本的长度：StringLength@SpokenString[x^#]&

Haskell中，29个字节（裂纹：1，2）

a n=n*ceiling(realToFrac n/2)

在线尝试！

这是A093005：。$a(n)=n\lceil \frac{n}{2} \rceil$

测试用例，即：$0 \leq n \leq 20$map a [0..20]

[0,1,2,6,8,15,18,28,32,45,50,66,72,91,98,120,128,153,162,190,200]

预期解决方案（20字节）

b n=sum$n<$show(3^n)

在线尝试！在处不同，其中a （23 ）= 276和b （23 ）= 253。$n=23$$a(23) = 276$$b(23) = 253$

此函数等同于。由于上限，两个函数对于0到22范围内的整数参数重叠：$b(n) = n\ len(3^n) = n \lceil log_{10}(1+3^n)\rceil$$0$$22$

_资源

JavaScript（ES6），12个字节（已破解）

这很容易。

n=>n*(8*n+1)

在线尝试！

这是A139275：

$0\le n<9$

按照挑战规则，它必须超越。

Malbolge, 10 bytes

ub&;$9]J6

Note that the code ends with an 0x14 (device control 4) byte.

Try it online!

The 0-indexed sequence to crack is [9, 19, 29].

><>, 276 bytes (Cracked)

1$1-:?!v$:      1[0$          >:?!va2[$:{:@%:{$-{,]v
       >$n; v              <  ^   >~{]02.1+1+ffr+1r<
 :}[r]{  [01>:{*@@+$a*l2=?!^~]+ff+9+1g"3"=?v"3"ff+9+1pf0.
 :}[l01-$>    $:0(?v$@$:@@:@)?v@@1-$}v     >"2"ff+9+1p00.
>.       ^-1l v!?} <  .4a}$@@$<   .4a<
^26{]r0[}:{]~{<

Try it online! Call this one with -v n to get the n-th element (1-indexed)

1$1-:?!;$::n84*o1[0$          >:?!va2[$:{:@%:{$-{,]v
            v              <  ^   >~{]02.1+1+ffr+1r<
 :}[r]{  [01>:{*@@+$a*l2=?!^~]+ff+9+1g"3"=?v"3"ff+9+1pf0.
 :}[l01-$>    $:0(?v$@$:@@:@)?v@@1-$}v     >"2"ff+9+1p00.
>.       ^-1l v!?} <  .4a}$@@$<   .4a<
^26{]r0[}:{]~{<

Try it online! Call with -v n to get a list of n-1 elements starting at 1

Online Fish Interpreter

A long and complex one, this is OEIS A004000.

Let a(n) = k, form m by Reversing the digits of k, Add m to k Then Sort the digits of the sum into increasing order to get a(n+1).

Example: 668 -> 668 + 866 = 1534 -> 1345.

Because the code in ><> is quite long, the challenge is to crack it for $n = 34$. These 34 elements make a total of 290 bytes, just a bit too much to hardcode the result ;)
Here are the 34 first elements 1-indexed

1 2 4 8 16 77 145 668 1345 6677 13444 55778 133345 666677 1333444 5567777 12333445 66666677 133333444 556667777 1233334444 5566667777 12333334444 55666667777 123333334444 556666667777 1233333334444 5566666667777 12333333334444 55666666667777 123333333334444 556666666667777 1233333333334444 5566666666667777

Jelly, 6 bytes, Safe!

<4+ạ2ȯ

This defines a zero-indexed sequence where:

As such the first sixteen values $a(0)\cdots a(15)$ are 1,1,1,2,2,3,4,5,6,7,8,9,10,11,12,13

Try it online! (here is a single value version)

This is not currently in the OEIS (although A34138 will work as a crack if short enough)

Intended Crack

The sequence above agrees with the count of decimal digits of the first $16$ terms of A062569, the sum of the divisors of the factorial of $n$ (also zero-indexed).
The $17^{\text{th}}$ term of A062569, however, is $107004539285280$ which has $15$ digits, not $14=a(16)$.

The required code is five bytes in Jelly, !ÆsDL.

JavaScript, 26 bytes (Cracked)

let f=x=>x>1?f(x-1)*f(x-2)+1:1

for (x of [0,1,2,3,4,5,6,7]) {
  console.log(x + ' -> ' + f(x))
}

OEIS A007660

Output is the first 6 elements with 0 indexing (1,1,2,3,7,22)

(somewhat shifted from what OEIS has it listed as)

Just creating a simple to solve answer to kick things off

Try it online!

JavaScript, 16 bytes (Cracked)

g=
x=>Math.exp(x)|0

tmp=[0,1,2,3,4]
console.log(tmp.map(g).join(','))

First 5 elements of OEIS149 ($\lfloor e^n\rfloor$)

Required inputs to match are 0,1,2,3,4.

Try it online!

APL (Dyalog Unicode), 17 15 bytes

⌈∊∘1 5+.633*5-⊢

Try it online!

The first 13 terms (1-based) are:

2 1 1 1 2 2 3 4 7 10 16 25 39

Hint: The intended solution uses one of the least used built-in functions.

Husk, 5 bytes (cracked by Jonathan Allan)

This one is A000030 shifted by $16$:

←d+16

Try it online!

The sequence is 0-indexed, output for $0 \leq n < 23$:

Explanation

←d+16  -- example input:  23
  +16  -- add 16:         39
 d     -- digits:         [3,9]
←      -- extract first:  3

Solution

LdΣ

JavaScript, 25 bytes (Cracked 21 bytes)

f=
x=>[7,11,12,13,13][x]||14

for(i=0;i<15;i++)
  console.log(i+"->"+f(i))

Sequence of 7,11,12,13,13 followed by infinite 14s.

Intended solution 22 bytes:

x=Math.atan(x+1)*10|0

Try it online!

JavaScript, 22 bytes (Cracked)

f=
x=>(3-(5/63)**.5)**x|1

for(y=0;y<16;y++)
  console.log(y +"->"+f(y))

This is 0 indexed and accuracy is required up to an input of 15. It can not be found on OEIS

My solution 20 bytes

x=>163**(32*x/163)|1

Try it online!

><>, 42 bytes, cracked

i3%0v
642 .
840
789
159
a 1
v<<
n
l
?
\/
;

Try it online!

Sequence to crack (0-indexed): 101786, 5844, 19902 (not on OEIS).

Intended solution, for reference.

Perl 6, 53 bytes

{(1,2,2,{$!=++$;prepend(@,2-$!%2 xx$_).pop}...*)[$_]}

Try it online!

Anonymous code-block that returns the 0-indexed Kolakoski sequence (OEIS A000002). Solutions are required to match the first 130 elements, so that for some n > 129 it differs from the Kolakoski sequence.

Pascal (FPC), 86 bytes (cracked)

var n:word;begin read(n);write(n div 2+n div 4+n div 8+n div 16+n div 32+n div 64)end.

Try it online!

The sequence must be equal up to $n=120$. The sequence from input 0 to input 120 is

0   0   1   1   3   3   4   4   7   7   8   8  10  10  11  11  15  15  16  16  18  18  19  19  22  22  23  23  25  25  26  26  31  31  32  32  34  34  35  35  38  38  39  39  41  41  42  42  46  46  47  47  49  49  50  50  53  53  54  54  56  56  57  57  63  63  64  64  66  66  67  67  70  70  71  71  73  73  74  74  78  78  79  79  81  81  82  82  85  85  86  86  88  88  89  89  94  94  95  95  97  97  98  98 101 101 102 102 104 104 105 105 109 109 110 110 112 112 113 113 116

var n,i,s:word;begin read(n);i:=2;repeat s:=s+n div i;i:=i*2until i>n;write(s)end.

but r_64 made it even better!