与许多C＆R挑战不同，这不需要单独的强盗岗位。强盗的目标是破解先前的答案，然后发布新的答案作为警察。

作为回答者，您将编写一系列看起来像这样的多语种（每列都是一种语言，并且每个条目都是该语言的答案的输出）：

Language:  1  2  3  4  5  6  7  8  ...
Answer 1:  0  1  2
Answer 2:     1  2  3
Answer 3:        2  3  4
Answer 4:           3  4  5
Answer 5:              4  5  6
Answer 6:                 5  6  7
...

（空格表示在这种情况下不需要任何行为）。

每个答案应在3种语言的工作和打印3个不同的连续的数字，它们分别一个超过由先前答案打印的数字（第一个答案打印0，1和2）。每个答案都使用先前提交的两种语言和第三种新语言。答题者应尝试混淆这种第三语言是什么。

要发布新答案，您应该：

• 通过找到第三语言来破解最新的答案。
• 最好为您的裂缝添加说明，并将答案通知发布者。提交文件被破解后，最好也添加一个解释。
• 编写由该答案的第二和第三种语言以及您选择的另一种语言组成的多语种。显示您的前两种语言，但不要显示您的新语言。找到该语言（或它使用的任何其他语言）将是下一个发布者的目标，因此您应该尝试对其进行混淆。

技术指标

• 有效的编程语言的标准与“编程语言测验”（Mark II-警察）的标准相同：

  • 发布此挑战时，该文章有英文Wikipedia文章，esolangs文章或Rosetta Code文章，或者在“ 在线试用”上！。在这些页面中的任何一个链接都有口译员，使该口译员完全合法。
  • 它必须满足关于什么构成编程语言的规则。
  • 它必须有一个免费的口译员（如啤酒）。这里免费意味着任何人都可以使用该程序而无需付费。

• 每个答案必须在一台合理的PC上运行不到一分钟。

• 您可以重用编程语言，但两者之间必须至少有两个答案（因此，单个答案不能重用一种语言）。
• 破解提交包括寻找能够打印出正确结果的任何编程语言，而不仅仅是预期的语言。如果提交使用未声明或无法使用的任何语言运行，则无需执行任何操作。
• 您不能连续发布两次（或更多）。

获胜标准

获胜者的答案是花费大多数时间才能破解的答案。挑战永无止境，因此胜利的答案总是有可能改变的。

Hexagony，Klein（101）和???

  xx={puts/}
gets87!@xx=p

main\

>9.*5,6v

这7在Hexagony，8Klein（101）和9???中打印。

9如果在代码末尾添加了换行符，则该命令将不起作用。如果要在本地测试，请小心。

编辑：直播20小时已经是一个记录，所以从现在开始我将给出一些提示。（此外，由于所使用的语言不是IMO，所以还不为人所知。）

提示

1. “以及9如果在末尾添加换行符，则行不通” 以及前两个空格（Hexagony和Klein均将其忽略）非常重要。
2. 语言在TIO上。
3. 前两个空格使程序跳转到最后一行。（它不是 2D语言。）
4. 没有显式输出命令，该v命令结束程序。

说明（破解的帖子）

在源代码中

abcd={} -- a gaffe avoiding tactic in C++/C#
abcd[!1]=   1+2+3+4+5+6+7+8+9+10+11+12+13+17!
print(abcd[0>1+2+3 and 4+8+6<0-0]//35)
if 0>1 then a.next=';' en\
                    >1+6.@.@

克莱因（101）中的相关说明是：

IP->.....................^...........IP->/
.........................|...................
.........................8
.........................\<-.............IP<-
                         @

克莱因（Klein）是fungelike 2D语言，其中跨越代码区域（是正方形）的边界取决于克莱因拓扑。/并且\是镜子。

IP从面向右的左上角开始。它遇到一个朝向顶部边界的镜子，并重新进入右侧的代码区域，如上所示。然后再次碰到镜子，推入8，然后（经过边界几次后）在停下@。然后将堆栈中的内容打印到stdout，即8。

Befunge-96，Hexagony和???

abcd={} -- a gaffe avoiding tactic in C++/C#
abcd[!1]=   1+2+3+4+5+6+7+8+9+10+11+12+13+17!
print(abcd[0>1+2+3 and 4+8+6<0-0]//35)
if 0>1 then a.next=';' en\
                    >1+6.@.@

此版本6以Befunge-96，7六角形和8??? 打印。

说明

六角形代码在“修饰”时为：

       a b c d = { } - 
      - a g a f f e a v 
     o i d i n g t a c t 
    i c i n C + + a b c d 
   [ f a l s e ] = 1 + 2 + 
  3 + 4 + 5 + 6 + 7 + 8 + 9 
 + 1 0 + 1 1 + 1 2 + 1 3 + 1 
7 ! p r i n t ( a b c d [ 0 > 
 1 + 2 + 3 a n d 4 + 5 + 6 < 
  0 - 0 ] / / 3 5 ) i f 0 > 
   1 t h e n a . n e x t = 
    ' ; ' e n d > 1 + 6 . 
     @ . . . . . . . . . 
      . . . . . . . . . 
       . . . . . . . . 

执行的路径从左上角的东方开始。最上面的一行没有做太多事情。-更改当前内存边沿，使其值为0。执行继续在中间行向东前进，该行在当前内存边缘7!加载7并打印为整数。[将指令指针从变回东北7。之后7+3，执行将到达[，该指令将从东南角开始将指令指针更改为西北。最后，路径是..@哪里@终止程序。

卢阿，脑干，???

abcd = {}-用C ++避免战术的失误
abcd [false] = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14
打印（abcd [0> 1 + 2 + 3和4 + 5 + 6 <0-0] // 35）
如果0> 1，则a.next =';' 结束

在Lua中打印3，在Brainfuck中打印4，在???中打印5。

破解后的说明：

a = 1 + 2 + 3 + 3 + 4 + 5 + 6 + 7 + 8 + 9
b = 1 + 1 + 1
f = 3-（-1）
c = 7 + 9 + 13 + 11 + 12 + 3--1
g = a + b + c + 1 + 2 + 3 + 4 + 5
j = 9 + 7 + g + c + b + a + g + g + g + g + g + g + 1 + 2 + 3 + 4 + 1 + 1
h = 1 + 1 + 1 + 1 + 333 + 1 + 1 + 1 + 111 + 1 + 1 + 1 + 333 + 1 + 1 + 1 + 1 + 1。
打印（f）

• 在Python 3中3--(-1)为2，因此print(f)打印为2（其他东西是不必要的）
• 在Lua中，--同样是一条评论，所以3--(-1)只有3条，所以print(f)打印3条（再次没有其他内容）
• 在Brainfuck中，有57个加号和5个减号，将磁带上的第一个单元格设置为52，.输出字符52为4。

触发器，JavaScript和???

[ //aТ/\\ ][ //е"6
console.log(111-111+12)]
//!'!/-²6-²52

11在触发器，12JavaScript和13中打印REDACTED。

由于到目前为止尚未比其他任何答案破解得更长，因此这里有一些提示：

• 如果您没有注意到，第一行的Т和е是多字节字符。
• [ //而且\\ ][ //没有人。
• 第二行以及-²52都是无效代码。
• 语言没有终止的概念，因此²6形成无限循环。
• 具体来说，UTF-8编码的第二个字节与²一起6形成一个无限循环。
• 输出的数字由 /!'!/
• 该语言不在在线试用，Rosetta代码或Esolangs上。
• 唯一可用的输出形式是1bpp屏幕。
• 屏幕的长宽比为2。
• 虽然该语言最初并非旨在用作机器代码，但确实存在FPGA实现。
• 根据维基百科，该语言的预期目的是视频游戏。
• 进入屏幕的唯一方法是一条特殊指令，该指令将可选寄存器中的坐标以及高度作为立即数，并将8位乘n位图XOR到屏幕上。为了使碰撞检测更加容易，并且可以清除屏幕，当任何像素恢复为关闭状态时，将设置其中一个寄存器。

说明

好吧，这花了一些时间才能破解。让我们看看代码的外观：

0200 5b20    SE VB, V2   ; Skip the next instruction if VB = V2. Since all
0202 2f2f    CALL 0xF2F  ; registers start at 0, this call will be skipped. This
                         ; hides the bytecode from JavaScript.
0204 61d0    LD V1, 0xD0 ; A useless load. Necessary to use a UTF-8 continuation
0206 a22f    LD I, 0x22F ; byte as an instruction and load the address of
                         ; the sprite.
0208 5c5c    SE VC, V5   ; A red herring supposed to suggest symmetry is
                         ; important, as well as a totally intended eliminator
                         ; of inaccurate implementations. Most documentation
                         ; claims that the lowest nibble must be zero, but in
                         ; the original COSMAC VIP implementation it's
                         ; a don't-care.

这意味着，尽管许多可用的仿真器均能正常运行，但按规则实施已链接到Wikipedia页面的第二句。当然，它不能直接在普通PC上运行，但是我发现COSMAC VIP页面上链接到的Emma 02仿真器效果最佳。

020A 205d    CALL 0x05D    ; Skipped.
020C 5b20    SE VB, V2     ; Same as with the very beginning. Red herring.
020E 2f2f    CALL 0xF2F
0210 d0b5    DRW V0, VB, 5 ; Draw the sprite pointed to by I. Since V0 and VB
                           ; haven't been written to yet, the sprite will be drawn
                           ; in the top-left corner of the screen. The height is
                           ; an immediate.
0212 2236    CALL 0x236    ; Jump over the JavaScript and Trigger code. It doesn't
                           ; matter that we never return.
0214-022E *never used*
022F 2f      DB %00101111  ; Sprite data.
0230 21      DB %00100001
0231 27      DB %00100111
0232 21      DB %00100001
0233 2f      DB %00101111
0234-0235 *never used*
0236 b236    JP V0, 0x236  ; Since V0 is still zero, this is an infinite loop.
0238-023C *never used*     ; Together with the previous two lines, it's the
                           ; -²6-²52. It's a red herring supposed to suggest
                           ; prefix, or Polish, notation.

Python 2，Python 3，???

a={1,2}
print(1+#a
--bool(1/2)
)

在Python 2中打印1，在Python 3中打印2，在???中打印3。

破解说明（破解后的帖子）：

#define print(A) main(){puts("0");}
print(1+bool(1/2))

• 0：C：第一行定义了一个类似于函数的宏print，该宏将忽略其单个参数，并计算为main(){puts("0");}，此宏可打印0并退出。1+bool(1/2)当print( )第二行的宏扩展为时，整个表达式将被忽略main(){puts("0");}。

• 1：Python 2：第一行是注释。1/2在Python 2中使用整数除法，得到0。然后将该值解释为布尔值（bool(0)-> False），然后将其添加到1（1+False-> 1），然后打印。

• 2：Python 3：第一行是注释。1/2在Python 3中使用浮点除法，得到0.5。然后将此值解释为布尔值（bool(0.5)-> True），然后将其添加到1（1+True-> 2），然后打印。

JavaScript，CHIP-8和???

[ //aТ/\\ ][ //е"6
console.log(111-111+12)]
//!'!/-²6-²52@++++2345

12在JavaScript中，13在CHIP-8中以及14在???中

我将四肢走动，称其为破解，尽管我无法完全使它正常工作，但我确定该语言是否正确（这似乎是规则所要求的。）

这是不完整的帖子解释

十六进制“ is”中的代码（我可能略有偏离）：

[ 0x5b, 0x20, 0x2f, 0x2f, 0x61, 0xD0, 0xA2, 0x2f, 0x5c, 
0x5c, 0x20, 0x5d, 0x5b, 0x20, 0x2f, 0x2f, 0xD0, 0xB5, 
0x22, 0x36, 0x0a, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 
0x6c, 0x65, 0x2e, 0x6c, 0x6f, 0x67, 0x28, 0x31, 
0x31, 0x31, 0x2d, 0x31, 0x31, 0x31, 0x2b, 0x31, 
0x32, 0x29, 0x5d, 0x0a, 0x2f, 0x2f, 0x21, 0x27, 
0x21, 0x2f, 0x2d, 0xb2, 0x36, 0x2d, 0xb2, 0x35, 0x32 ]

您可以转到此处，单击“二进制工具”，然后将其粘贴到字节数组框中。点击“反编译”。

该代码的关键元素是：指示“数字”在哪里的sprite指令，打印数字的命令，正确的垃圾位置以及以下内容：

: label-0
    0x2F
    0x21
    0x27
    0x21
    0x2F

要查看其含义，可以单击“ Sprite Editor”，然后将这些十六进制粘贴到下面的框中。您会看到答案：

我敢肯定，您可以将任何喜欢的内容放在最后，并且CHIP-8结果不会改变，因此是新条目。

如果有人能完全解决这个问题，而不是我在这里给出的答案的“证明”，我将感到非常高兴。

C，Python 2，???

#define print(A) main(){puts("0");}
print(1+bool(1/2))

这将0在C，1Python 2和2???中打印。

对于了解Python的人来说，这将是非常容易破解的，但是我想要其他答案的起点。随后的答案应尝试混淆第三种语言（我没有这样做）。

Python 3，Lua，???

a=1+2+3+3+4+5+6+7+8+9
b=1+1+1
f=3--(-1)
c=7+9+13+11+12+3--1
g=a+b+c+1+2+3+4+5
j=9+7+g+c+b+a+g+g+g+g+g+g+1+2+3+4+1+1
h=1+1+1+1+333+1+1+1+111+1+1+1+333+1+1+1+1+1.
print(f)

在Python 3中打印2，在Lua中打印3，在???中打印4。

破解后的说明：

a={1,2}
print(1+#a
--bool(1/2)
)

• 在Lua中，-是评论。在Python 2和3中，-表示算术中的双负数。
• 在Python 2和3中，＃是注释。在Lua中，＃是长度运算符。
• 在Python 2中，1/2是底数除法，因此求值为零。在Python 3中并非如此。因为两个版本的Python都将0评估为False，所以bool（1/2）在Python 2中评估为False，在Python 3中评估为True。在算术中使用时，False强制转换为0，True强制转换为1。

> <>，​​Befunge-96和???

abcd={} -- a gaffe avoiding tactic in C++
abcd[false]=1+2+3+4+5+6+7+8+9+10+11+12+13+17!
print(abcd[0>1+2+3 and 4+5+6<0-0]//35)
if 0>1 then a.next=';' end
                    >1+6.@

在???中打印5 in><>，6 inBefunge-96和7。

我知道预期的解决方案是Befunge-93，但我无法抗拒。

说明：

Befunge-96遵循与相同的路径><>，但是忽略了未知指令，最终将1加到5并将其乘以9得到54（ascii代码）6。

评论员，Beatnik，???

// k... nak... naKaka pagpAbaGaBag
static answer: Option<&String> = None;
 
fn llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch(s: &String){
  answer = Some(s);
}
 
fn pneumonoultramicroscopicsilicovolcanoconiosis(){
  println!("{}", answer.unwrap());
}
 
fn main(){
  let s = String::from("17");
  let t = "Hi! I am a cat. AOOOWRRRWWW! Me need Whiskas! Noow! Mee hungry hast bekommen. Feedme! sudo !!. Sad... six cable hostage wire cable diediediediee #               */";
  llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch(&s);
  pneumonoultramicroscopicsilicovolcanoconiosis();
}

在Commentator中输出15，在Beatnik中输出16，在希望找到的一种语言中输出17。

好的，现在是提示时间了：

• 语言的名称是由两个元素组成的，这两个元素组成了您的身体，但是百分比却千差万别（取决于您是否是机器人）。
• 语言本身在TIO上，但是实现不在。
• 哦，拜托

Brainfuck，> <>和???

abcd={} -- a gaffe avoiding tactic in C++
abcd[false]=1+2+3+4+5+6+7+8+9+10+11+12+13+14
print(abcd[0>1+2+3 and 4+5+6<0-0]//35)
if 0>1 then a.next=';' end
                    >1+9*,@

4在Brainfuck，5> <>和6???中打印

• 在脑袋里，什么都没有改变。
• 在> <>中，v向下重定向程序流。该n被Ñ umeric输出。;结束执行。

克莱因（101），Z80高尔夫球，???

!!8@e6v+4>9 \
Almost everything you can find on the internet is true
~Albert Einstein
 ~HUMAN IMAGE MACROS

8在Klein（101），9Z80Golf和10???中打印 。

Beatnik，Rust，???

fn avreg(){}
fn/*azxzzz avreg k zqyzzz ax quke    
>>P0 ++puts++puts[pov]
\@�{>*}++puts++puts++puts++puts++puts++puts++puts++puts%
*/main(){print!("17")}

在Beatnik中打印16，在Rust中打印17，在???中打印18。

第�4行上的字符应替换为ASCII字符18（在TIO链接中未执行此操作，因为它与它们两个都不相关）。

说明（破解）：

上一个答案的语言是Rust：具体地说，Rust用mrustc编译。mrustc是一个实验性的编译器，由于它主要用于引导有效版本的rustc，因此它忽略了借位检查和可变性检查，从而允许@NieDzejkob的代码段进行编译而不会出错。

该程序可与普通的Rust编译器一起使用，因此您无需安装mrustc即可对其进行测试。

提示

由于此答案最长，而且没有被破解，因此我会给您一个提示，并继续定期进行操作，直到被破解为止：

• 秘密语言是二维的。
• 正如我在评论中提到的那样，该语言不在TIO上。
• 该�角色是一个红鲱鱼，具有非常意义不大。大多数字节可以代替它，该程序仍然可以运行。

Z80Golf，Somme，???

!!8@e6v+4>9 \
1((111+111)/111)
00
~tz

在Z80Golf中打印9，在Somme中打印10，在???中打印11。。

感谢Bubbler 破解了以前的文章 Somme，它以列总和作为指示。前三列的计算结果为

A.;

按下10，将其打印并退出。

Somme，Trigger和???

[,,E,D,,$,H,_,K,,$,,_,F,L]=!
[]+[]+!![]+[][111]
_=[111][F+L+E+E];[,J,,A,I,,B,C,S]=
[]+_;$=A+B+C+D+I+H+J+A+I+B+H
R=_[$](H+K+I+J+H+C+S+H+B+B+I)();G=($[$]+[])[14]
R[A+B+C+D+B+E+K][E+B+G](12);`
iP<`

这将10在Somme，11Trigger和12???中打印。

由于后两种语言易于理解，因此我决定将其混合使用。

说明（破解的帖子）

触发器将整个代码视为一系列令牌（令牌化是贪婪的）：

• 单字节（表示A）
• 两个相同的字节，后跟一个不同的字节（表示AAB）
• 三个相同的字节（以表示AAA）
• 四个相同的字节（以表示AAAA）

在源代码中

!!8@e6v+4>9 \
1((111+111)/111)
00
~tz

重要的令牌是((1 11+ 111 111，其中前两个不执行任何操作，而后两个则分别打印1个-因此为11。

CHIP-8，克莱因（100），???

[ //aТ/\\ ][ //е"6
console.log(111-111+12)]
//!'!/-²6-²52@++++2345
 %/    <#> 13
       say 14
 + not not 15

在CHIP-8（我假设）中输出13，在Klein中输出14，在???中输出15。

另一个 Klein拓扑，tsk tsk。我已经将代码保留在之前@，因为我不知道会影响CHIP-8。

线索

我有点迟到了，抱歉。我会尝试每天添加一次。

• 删除程序的前半部分（前三行）仍然有效。
• 这不是2D语言
• 语言在TIO上
• 在notS和say可以在不影响程序中删除

作为参考，没有这些内容的程序如下所示：

 %/    <#> 13
        14
 +   15

在线尝试！

克莱因（100），评论员，???

/@++++2345
start:
program:
 db 'function',10
 add program,program
 jp null+$8
 sbc rbp,rbp
 jnz program
 jr program
 add start
 halt
ex:

输出Klein（100）中的14，注释器中的15，???中的16。

我很难混淆多义词。

说明（破解的帖子）

 %/    <#> 13
        14
 +   15

在Commentator中，常用的注释标记和空格是重要的命令，其他任何字符都将被忽略。

• 空格会增加当前的存储单元。
• <# 对当前存储单元执行XOR 1。
• % 用于将当前存储单元重置为零。

等一下，之后有16个空格%，发生了什么事？

它实际上是解释器中的一个小错误（或功能？）。/被视为2字符命令的开始，因此消耗了它之后的空间。但是它/<space>是未定义的命令（因此为无操作），因此有效地跳过了该空间。