注意：此挑战已完成。仍欢迎提交，但不能赢取。

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

编写输出整数的代码1。如果添加，删除或替换（选择的）单个字符，则代码应输出integer 2。再更改一个字符（相同或另一个），代码应输出3。尽可能继续这样，但最多可以继续10个。ans = 1接受默认输出格式，例如。您可以忽略输出到STDERR（或等效文件）。

您必须显示语言，初始代码的字节数，其适用的整数数量以及初始代码的可选字符数。注意：您不必显露任何字符，但是请记住，显露字符可能会使强盗更难，因为他们必须在相同位置使用相同字符。您可以选择用于表示未公开字符的字符（例如，下划线），但是请确保指定此字符。

警察可以在一周后提供完整的代码，并将提交的文件称为“ SAFE”。获胜的提交将是产生数字10的最短未破解提交。如果没有未破解的提交能够打印10，则产生9的最短代码将获胜，依此类推。请注意，强盗不必进行与您相同的更改，也不必复制确切的代码（除非您揭示所有字符）。它们只能重现输出。

欢迎晚于11月24日发布的投稿，但不符合获胜资格的条件（因为可能会有更少的抢劫犯）。

示例帖子：

以下文章是该语言的呈文MyLang，长度为9个字节，适用于数字1-8。

MyLang，9个字节，8个数字

该提交适用于1-8。未公开的字符用下划线表示：_。

abc____i

排行榜

免责声明：排行榜未经测试，未破解的提交内容可能不会出现在列表中。

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><style>table th,table td{padding: 5px;}th{text-align: left;}.score{text-align: right;}table a{display: block;}.main{float: left;margin-right: 30px;}.main h3,.main div{margin: 5px;}.message{font-style: italic;}#api_error{color: red;font-weight: bold;margin: 5px;}</style> <script>QUESTION_ID=99546;var safe_list=[];var uncracked_list=[];var n=0;var bycreation=function(x,y){return (x[0][0]<y[0][0])-(x[0][0]>y[0][0]);};var byscore=function(x,y){return (x[0][1]>y[0][1])-(x[0][1]<y[0][1]);};function u(l,o){jQuery(l[1]).empty();l[0].sort(o);for(var i=0;i<l[0].length;i++) l[0][i][1].appendTo(l[1]);if(l[0].length==0) jQuery('<tr><td colspan="3" class="message">none yet.</td></tr>').appendTo(l[1]);}function m(s){if('error_message' in s) jQuery('#api_error').text('API Error: '+s.error_message);}function g(p){jQuery.getJSON('//api.stackexchange.com/2.2/questions/' + QUESTION_ID + '/answers?page=' + p + '&pagesize=100&order=desc&sort=creation&site=codegolf&filter=!.Fjs-H6J36w0DtV5A_ZMzR7bRqt1e', function(s){m(s);s.items.map(function(a){var he = jQuery('<div/>').html(a.body).children().first();he.find('strike').text('');var h = he.text();if (!/cracked/i.test(h) && (typeof a.comments == 'undefined' || a.comments.filter(function(b){var c = jQuery('<div/>').html(b.body);return /^cracked/i.test(c.text()) || c.find('a').filter(function(){return /cracked/i.test(jQuery(this).text())}).length > 0}).length == 0)){var m = /^\s*((?:[^,;(\s]|\s+[^-,;(\s])+).*(0.\d+)/.exec(h);var e = [[n++, m ? m[2]-0 : null], jQuery('<tr/>').append( jQuery('<td/>').append( jQuery('<a/>').text(m ? m[1] : h).attr('href', a.link)), jQuery('<td class="score"/>').text(m ? m[2] : '?'), jQuery('<td/>').append( jQuery('<a/>').text(a.owner.display_name).attr('href', a.owner.link)) )];if(/safe/i.test(h)) safe_list.push(e);else uncracked_list.push(e);}});if (s.items.length == 100) g(p + 1);else{var s=[[uncracked_list, '#uncracked'], [safe_list, '#safe']];for(var i=0;i<2;i++) u(s[i],byscore);jQuery('#uncracked_by_score').bind('click',function(){u(s[0],byscore);return false});jQuery('#uncracked_by_creation').bind('click',function(){u(s[0],bycreation);return false});}}).error(function(e){m(e.responseJSON);});}g(1);</script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/Sites/codegolf/all.css?v=7509797c03ea"><div id="api_error"></div><div class="main"><h3>Uncracked submissions</h3><table> <tr> <th>Language</th> <th class="score">Score</th> <th>User</th> </tr> <tbody id="uncracked"></tbody></table><div>Sort by: <a href="#" id="uncracked_by_score">score</a> <a href="#" id="uncracked_by_creation">creation</a></div></div><div class="main"><h3>Safe submissions</h3><table> <tr> <th>Language</th> <th class="score">Score</th> <th>User</th> </tr> <tbody id="safe"></tbody></table></div>

六边形，18字节，10个数字，安全

该提交适用于1-10。未公开的字符用下划线表示：_。

.__{_]5[$@.;=@$!!1

您可以在这里在线尝试Hexagony。

我的解决方案：

1:   .<[{8]5[$@.;=@$!!10
2:   .<[{8]5[$@);=@$!!10
3:   2<[{8]5[$@);=@$!!10
4:   3<[{8]5[$@);=@$!!10
5:   4<[{8]5[$@);=@$!!10
6:   5<[{8]5[$@);=@$!!10
6:   7<[{8]5[$@);=@$!!10
8:   7<[{8]5[$@);=@$!!10
9:   8<[{8]5[$@);=@$!!10
10:  9<[{8]5[$@);=@$!!10

输出十六进制：

在线尝试！

Full Hex:
  . < [ 
 { 8 ] 5
[ $ @ . ;
 = @ $ ! 
  ! 1 0

Important parts:
  . < .
 . 8 . 5
. $ @ . ;
 . . $ .
  . 1 .

1. 在<内存边缘是0，因此它出现了。
2. 命中 1
3. 跳到 5
4. 越过8，但在处反转<并8继续前进。
5. 5再次点击
6. 跳过 1
7. 点击<此处，内存值为1585，mod 256，恰好是ASCII1
8. 最后打印并退出;@。

输出十六进制：

在线尝试！

Important parts:
  . < .
 . 8 . 5
. $ @ ) ;
 . . $ .
  . 1 .

这遵循相同的路径，但是在返回的途中，它命中了a )，从而将内存边缘增加到1586，即2。

输出3-9的十六进制：

在线尝试！

Important parts:
  2 < [
 . . ] .
. $ . ) .
 . @ . !
  . 1 .

1. 打 2
2. 现在，内存边缘到达时为正<，因此将其调低。
3. 在]改变了指令指针，而是立即用回来[
4. ) 递增到 3
5. ! 版画 3
6. $从前两个数字中遗留下来，所以我们跳过了结尾（@）
7. 1 更改内存边缘，但是现在不重要了。
8. < 向后反射指针。
9. 再次1没有关系，因为我们点击@结束程序。

视网膜，2字节，10个数字，破解

_1

适用于1到10，_是一个隐藏字符。这不应该太难，但是我希望它提供了一个有趣的难题。:)

您可以在这里在线试用Retina。

八度，55字节，10个数字，已破解

(o__(O_o_(@(__o)o__-O}_)_(0<O,{_(_o_O-1)+1_@(_1}_)(__o_

_ 是未知字符。

解

(o=@(O,o)(@(O,o)o{2-O}())(0<O,{@()o(O-1)+1,@()1}))(0,o)然后将最后一个更改0为1,2,3etc

给定x，这会递归计算x+1。它主要由两个匿名函数组成。有人提供了一个if语句来锚定递归：

if_ = @( boolean, outcomes) outcomes{ 2 - boolean}();

这只是在滥用布尔值等于0或的事实1。此函数接受布尔值和两个函数的单元格数组，并根据布尔值评估这两个函数中的一个或另一个。第二部分是实际的递归：

plus_one = @(n,f) if_(0<n ,{@()f(n-1)+1, @()1})

由于匿名函数是匿名的，因此您不能直接从其函数访问它。那就是为什么我们需要第二个论点f第一。稍后，我们将提供函数instelf的句柄作为第二个参数，因此最终函数将如下所示：

plus_one_final = @(n)plus_one(n,plus_one);

因此，在此表示法中，我的提交变为：

(plus_one=@(n,f)(@(boolean,outcomes)outcomes{2-boolean}())(0<n,{@()f(n-1)+1,@()1}))(n,f)

我前不久在stackoverflow上询问了MATLAB中匿名函数的递归锚点。

Python 2、9个字节，10个数字，已破解

print 8/8

没有隐藏的字符。您可以在没有蛮力的情况下破解它吗？

Perl，12个字节，10个数字，已破解！

下划线表示未知字符。

____;say__-9

可能相当容易，如果有多种解决方案，这也不会令我感到惊讶。尽管如此，破解还是很有趣的。

（预期的解决方案与破解相同。从根本上讲，这是一个为四个字符分配变量10的问题，这在Perl中很难实现；与许多高尔夫语言不同，它没有一个变量可以从10.）

Perl，46个字节，10个数字，安全

问题

__b_b_\__}_b_b_b_0_;
$b[0]=10;$b{0}=1;say$b[0]

较短的问题往往很快就会解决，所以我认为我会尝试较长的问题。在较长的也往往会被弄裂了，如果人们留下的空隙足够偷偷东西像顽皮say或exit在，所以这里所有的差距很短。隐藏的字符用表示_。

我的解决方案

sub b{\@_}*b=b$b{0};
$b[0]=10;$b{0}=1;say$b[0]

要打印2，3等，最多9，保持改变分配给该号码$b{0} 在第二行（即$b{0}=2，$b{0}=3等）。9的程序如下所示：

sub b{\@_}*b=b$b{0};
$b[0]=10;$b{0}=9;say$b[0]

然后产生10，在第一行之前添加一个#字符以将其注释掉。

说明

首先要注意的是，该解决方案并没有真正去除空白：如果我们使用更具可读性的空白进行布局，则会得到以下结果：

sub b { \@_ }
*b = b $b{0};
$b[0] = 10;
$b{0} = 1;
say $b[0];

通常，当您在Perl中访问子例程的参数时，可以通过将其复制到中来实现@_。这样做有一个很好的理由：@_给子例程指定的参数加上别名（例如，(sub { $_[0] = 3 })->($x)将其赋给$x），这通常是不希望的。

尽管@_可能看起来很神奇，但实际上它只是使用Perl内部结构的标准功能（XS易于使用，但仅在纯Perl的一些奇怪情况下才会出现，例如它@_本身）：数组不直接存储其元素，而是参考。因此，当我们b在下面的第二行中调用时，Perl生成一个数组（称为@_），该数组的第一个元素是对所$b{0}使用的同一存储的引用。（哈希值也通过引用存储；此时，$ _ [0]和$ b {0}都引用相同的存储。）因为@_从内部结构的角度来看并没有做任何特别的事情，所以我们可以采用引用就像我们对任何其他数组所做的那样，导致它的寿命超过了其定义的子程序。

Perl变量也通过引用引用数据存储。很久以前，人们习惯使用如下代码*x = *y;来设置$x为一个别名$y（通过使它们指向同一件事），同样@x作为一个别名@y，%x作为一个别名%y，等等。这就打破了不变的说法，即名称相似的变量不必具有相似的作用，因此现代的Perl提供了另一种选择。将引用分配给typeglob只会覆盖与引用类型匹配的变量（*x = \%y别名也%x将指向与该引用相同的存储，%y但不要说了$x）。显然，此语法并不在乎您要别名的存储是否具有名称，因此当我们为分配返回值时b（这是一个数组引用，它使该数组以前一直保持@_活动状态）为*b，发生的情况是将@b其更改为对调用的参数列表起别名b（同时保持%b不变）。这意味着，值得注意的是，这$b[0]和$b{0}现在都指向相同的存储，因此分配给一个将改变等。从那时起，一切都是非常简单的。

Perl文档并没有真正讨论这种细节，所以我不惊讶有人破解了它。@_并不是很强调其他数组的本质，并且大多数编码样式都旨在将其产生的影响最小化，而不是放大它们。

JavaScript，30字节，10个数字，已破解

alert(Array(_)________.length)

不应太难，但希望它足以应付挑战。:)未公开的字符用标记_。

Perl，14个字节，10个数字，已破解

say_!"___"%""_

1到10的作品_是隐藏字符。

我认为这不应该太难破解。我有一个更难的文件，为22个字节，如果此文件被破解，我会发布它。

say"!"=~y"%""c

而更换"!"的要打印的号码长度的字符串，例如!，!!，!!!等。

但是，ais523发现了另一种方法：

say"!"+1#"%""r

JavaScript，22字节，10个数字，已破解

可能相当容易破解。

alert(__14_337__xc_de)

_ 成为隐藏人物

八度，17字节，10个数字，破解

_od(3_13_13_7_1_)

原始解决方案

mod(3*1361357,10)
...
mod(3*1361357,17)
mod(3*1361397,17)
mod(9*1361397,17)

_ 是隐藏的角色。

果冻，7 字节，10个数字，已破解

“1‘ỌȮḊ‘

没有通配符。

似乎在该线程中发现了很多裂缝（要使用带参数的eval），而不是预期的裂缝。

预期的裂纹是：

“1‘ỌȮḊ‘ - (prints 1)
“1‘     - code page index list of characters "1": [49]
   Ọ    - cast to ordinals: ['1']
    Ȯ   - print (with no line feed) and return input: effectively prints "1"
        -     (but if left at this would then implicitly print another "1")
     Ḋ  - dequeue: []
      ‘ - increment (vectorises): []
        - implicit print: prints ""

“1‘ỌŒḊ‘ - (prints 2)
“1‘Ọ    - as above: ['1']
    ŒḊ  - depth: 1
      ‘ - increment: 2
        - implicit print: prints "2"

“1‘ỌŒḊ‘‘ - (prints 3)
“1‘ỌŒḊ‘  - as above: 2
       ‘ - increment: 3
         - implicit print: prints "3"

... keep adding an increment operator to print 4 - 10.

Befunge-93，11个字节，超过10个数字，已破解

此提交至少可使用1-10。未公开的字符用表示□。

□□5:**-□-.@

在线尝试

我必须说，两个人可以为此提出独立的解决方案给我留下了深刻的印象，而这两个都不是我所期望的。当马丁第一次到达那里时，我给Sp3000带来了“胜利”以因为他们的解决方案更便于携带。

这是我想要的解决方案：

g45:**-2-.@
g45:**-1-.@
g45:**-1\.@
g45:**-1\+.@
g45:**-2\+.@
...
g45:**-7\+.@

由于Befunge中的堆栈下溢被解释为0，因此g从0,0读取，返回ASCII值“ g”，即103。45:**-减去100，得到3。然后2-得到1。

对于第三次迭代，-（减去）更改为\（交换）指令，因此3成为最顶层的堆栈条目。在第四个迭代中，+插入（加）指令，从而将3加到1上得到4。

R，21字节，10个数字破解

__i___________i______

适用于10个数字。_是隐藏字符。

原始解决方案：

which(letters%in%"a")
which(letters%in%"b")
等等

Ruby，16字节，10个数字，由xsot破解

x=##/=#%#
)
###x

# 是任何字符。

八度，32字节，10个数字。开裂

_n_(isprime(floor(s____i__ i____

_ 是一个隐藏的角色。

您可以在此处在线尝试八度。

原始解决方案：

1： nnz(isprime(floor(sqrt(i):pi')))

2： nnz(isprime(floor('sqrt(i):pi')))

3： nnz(isprime(floor('sqrt(i):pia')))

4： nnz(isprime(floor('sqrt(i):piaa')))

...

八度，17字节，10个数字，破解

_i_(__i__(2_5_))

未显示的字符用标记_。

预期解决方案：

    fix(asind(2/59))
    fix(asind(3/59))
    fix(asind(4/59))
    fix(asind(5/59))
    fix(asind(6/59))
    fix(asind(7/59))
    fix(asind(8/59))
    fix(asind(9/59))
    fix(asind(9/55))
    fix(asind(9/50))

八度，19字节，10个数字，已破解

__sca__1_)___'-_6_'

_ 是隐藏的角色。

预期解决方案：

pascal（10）（'a'-96）'

05AB1E，5个字节，10个数字，已破解！

不是很辛苦，但很有趣:)

_[==_

_是一个随机字符。使用CP-1252编码。在线尝试！

05AB1E，6个字节，10个数字，破解

尝试2，这次没有三个字符的字符串：p。

_ [==_

_是一个随机字符。使用CP-1252编码。在线尝试！

JavaScript，22字节，10个数字，已破解

alert(0_6_4_>_0_2_0_7)

_ 是隐藏的角色。

有关预期解决方案的提示

需要更改以生成所有数字的字符始终是相同的。

JavaScript 21字节，10个数字被破解

alert(b_oa_"3____1"))

未公开的字符标有 _

开裂

我的版本：

alert(btoa|"3"&("1"))
alert(btoa|"3"^("1"))
alert(btoa|"3"^("0"))
alert(btoa|"3"^("7"))
alert(btoa|"2"^("7"))
alert(btoa|"1"^("7"))
alert(btoa|"0"^("7"))
alert(btoa|"0"^("8"))
alert(btoa|"0"^("8"))
alert(btoa|"2"^("8"))

Python 3、19个字节，10个数字，已破解

print(??bin()?????)

未显示的字符用标记?。已在Python 3.5.2中测试。

Python 3、16个字节，10个数字，已破解

print(?%??f?r?t)

未显示的字符用标记?。这可能有点容易，因为只有五个问号，但是我希望它会很有趣。

C＃，90个字节，10个数字，已破解

using ______________________________________________;class C{static void Main(){_______;}}

老实说，我不知道要破解有多困难。

编辑：糟糕，抄录错误。一_过少using。

现在被Hedi 破解，他找到了想要的（没有类名）解决方案。

JavaScript 33字节，10个数字破解了x2

糟糕，我发布了自己的代码行以生成10个Hedi 破解，好像是1个

alert(_to__"_Xc0__0_B6____Zp=="))

打算发布以生成1的版本

alert(_to__"_Xc0__0_Bf____Zp=="))

未公开的字符标有 _

alert(btoa|"0Xc0"-0xBf|!("Zp=="))
alert(btoa|"0Xc0"-0xBe|!("Zp=="))
alert(btoa|"0Xc0"-0xBd|!("Zp=="))
alert(btoa|"0Xc0"-0xBc|!("Zp=="))
alert(btoa|"0Xc0"-0xBb|!("Zp=="))
alert(btoa|"0Xc0"-0xBa|!("Zp=="))
alert(btoa|"0Xc0"-0xB9|!("Zp=="))
alert(btoa|"0Xc0"-0xB8|!("Zp=="))
alert(btoa|"0Xc0"-0xB7|!("Zp=="))
alert(btoa|"0Xc0"-0xB6|!("Zp=="))

Python，超过10个数字，61个字节，已破解！

这是我发布的代码：

try:x
except:print(__import__('sys').??c??n??()[????b????e???

原始代码为：

try:x
except:print(__import__('sys').exc_info()[2].tb_lineno)

基本上，它将引发错误（'x' is not defined），然后打印发现错误所在的行。因此，只需在开头添加换行符即可增加数字。

我知道要破解它并不难-我只是想一种有趣的方式来打印数字-但我并不希望Sp3000这么快地获得它，这是一些专业技能！

05AB1E，11个字节，已破解！

3628801__0_

从1-10开始运作。_是一个隐藏的角色。

预期解决方案：

3628801R¬0+ # 1
3628801R¬1+ # 2
3628801R¬2+ # 3
3628801R¬3+ # 4
3628801R¬4+ # 5
3628801R¬5+ # 6
3628801R¬6+ # 7
3628801R¬7+ # 8
3628801R¬8+ # 9
3628801R¬9+ # 10

八度，24字节，9个数字，已破解

_a__repmat(__one___,__)_

_ 是一个隐藏的角色。

（受@LuisMendo的挑战启发。）

JavaScript，9个字节，10个数字，已破解

alert(__)

_ 是隐藏的角色。

八度，25字节，9个数字。开裂

__a__repmat(__one___,__)_

_ 是一个隐藏的角色。