这是一个警察和强盗的谜题，可以在这里找到强盗的线索。

您的任务将是两个编写两个程序（或函数），使它们彼此相似，并且一个与另一个相反。这些程序可以接受并输出任意数量的整数或复数。如果选择以数字作为字符点或任何其他合理的方式，则必须在答案中指出自己正在这样做。如果选择限制功能域，则还必须在答案中指出限制域。

然后，您将以答案的形式展示第一个程序，其中隐藏了左反函数供强盗查找。

所示程序必须实现一个内射函数（否则将不可能存在隐藏的答案）。

如果您的答案在一周内没有被破解，则可以显示隐藏的答案并将其标记为安全。安全答案不能被强盗破解，并且可以无限期保持不变。

目标是创建最短的未破解答案（以字节为单位）。

例

您可以显示以下python程序，将其添加到输入中

lambda x:~-x

解决方案可能是：

lambda x:-~x

这从输入中减去一个

Python 3，80字节（破解）

bhmq = int(input())
print(bhmq ** 2)
(1 or [(sqrt),(specification+of*integerr)])

域：正整数。功能只是对数字进行平方。输入到stdin，输出到stdout，以及在逆函数中。请注意，Python在这里忽略了第三行，因为它在语法上是有效的，并且1已经是一个真实值，因此Python甚至不会查看'or'的正确部分是否定义明确。

强盗应编写一个sqrt函数，该函数将在所有非零平方上正常工作，按原样打印整数值，不带浮点数（因此在输入“ 4”时，输出应为“ 2”或“ 2 \ n”，而不是“ 2.0”或“ 2.0 \ n”）。

Python 3，46字节，已破解

lambda x:x*(1999888577766665//844333333222200)

将输入加倍。

7，9字节，已破解

该程序充满了不可打印的字符，因此这是一个十六进制转储：

00000000: 2573 dc01 7e13 dcb6 1f                   %s..~....

注意：这使用了不能输入负数的数字输入例程，因此此提交仅限于非负整数。

警察和强盗挑战的一个问题是您不编写代码说明（以使其难以破解）。另一方面，这意味着我不必在这里麻烦。

我之所以选择7作为语言，是因为，尤其是它的压缩表示法，它很难阅读，而且我不明白为什么只有我一个人才需要麻烦去处理用8位代码编写的程序块3位编码。祝好运！

说明

既然程序已被破解（不幸的是，被暴力破解；在这些简短的解决方案中，这始终是一种危险），我也可以解释一下我的意思。通过阅读程序，这实际上可以解决。我本来可以使难度变得更大，但是当存在蛮力裂缝时，那感觉真是个坏主意。

我们将以更自然的编码表示程序。与往常一样，粗体的数字指示的是立即运行（不是所有这些都在一个程序中的可表示;命令6和7是但2以5不），不用粗体数字表示它们的转义当量（0到5，所有这些都是在原始程序中的可表示;注这0是逃脱的6，1也是逃脱的7）：

112 7 1 7 34002 77 023 67 13303

在7个程序源代码中可用的命令集意味着它基本上只是表示原始堆栈的文字（仅对转义的命令6和，您无能为力7）。因此，程序要做的第一件事就是将一堆东西压入堆栈。这是程序运行后堆栈的外观（|按7中的常规分隔堆栈元素）：

772 | 7 | 34662 | 023 | 73363

然后，最后的堆栈元素被复制以成为要运行的代码（同时保留在堆栈中）。碰巧的是，这是程序唯一的代码部分。其他一切都只是数据。它的意思是：

73363 
7将       一个空元素推到堆栈上
  3      输出顶部堆栈元素，丢弃下面的元素
 73的      组合效果：丢弃顶部堆栈元素
   3     输出顶部堆栈元素，丢弃下面的元素
    6    转义顶部堆栈元素，然后将其附加到下面的元素
     3   输出顶部堆栈元素，放弃下面的元素

换句话说，这几乎只是一堆I / O指令。让我们详细分析一下：

• 73丢弃73363仍在堆栈顶部的那一个。
• 3输出023，并丢弃34662。因此可以看出，34662是注释，它用于存储程序其他版本中所需的字节。至于023输出时的操作，它选择I / O格式0（整数），然后23是一个指令，要求实现输入整数（在7中，您通过输出请求输入的特定代码来完成输入）。通过在下面复制堆栈元素来完成输入，例如，如果输入整数为10，则下一个堆栈元素（当前为7）将变为7777777777。因此，我们接受来自用户的十进制输入，但将其存储为一元。
• 6转义顶部的堆栈元素（将的每个实例更改7为1；这是7转义完全由s 组成的字符串的方式），然后将其附加到（772）之前的堆栈元素中。因此，我们的数据现在类似于7721111111111。
• 最后，3输出有问题的堆栈元素（并弹出默认初始堆栈一部分的空白堆栈元素）。它的值是通过取数计算1S和7S，并且减去的数0S和6秒。（2在大多数情况下，中间的会被忽略；如果它在字符串的末尾，它将成为尾随的换行符而不是被忽略，但是PPCG规则对此并不在意。）因此，输出是原始的输入加2。

此时，堆栈上没有任何有用的东西，程序中也没有任何东西，因此程序退出。

我们如何扭转这种情况？只需将11to 更改为一个简单的问题00，这样我们就可以在输入的字符前面加上使其变低2而不是变高2的输入。程序中还有一个00方便隐藏的8个八进制数字（以便八进制数字和字节彼此对齐），因此我们可以11在开始时简单地将其与交换。

JavaScript（ES6），21字节，已破解

这是个简单的。

b=>Math.pow(b,torc=3)

返回输入的多维数据集。

Python 2，83个字节，已破解

#((()))****+,,---/2289;==oppppppqqqqqw~~
lambda n:pow(n,65537,10998167423251438693)

这类似于我的其他答案。但是，它使用64位RSA，并且在密码上非常薄弱。如果您可以抢劫这个答案，那么在足够的时间上，理论上您也可以抢夺我的另一个答案。

Python 2，47字节，破解

lambda x:x**2or (iron() and saxifrage.extend())

此函数的域是{x∈ℤ| x> 0}。它平方其输入。

nmjcman101找到了预期的解决方案：

lambda x:sorted(a**2for a in range(x)).index(x)

JavaScript（ES6），46字节，已破解

x=>Math.log(x+(+String(t=985921996597669)[5]))

此函数返回ln(x+1)where x是非负数。

用法

(x=>Math.log(x+(+String(t=985921996597669)[5])))(5)

注意：由于浮点数的性质，f(g(x))可能不完全相等x。例：f(g(4))=3.9999999999999996

J，8个字节，已破解

另一个简单的开始。

[:]+:[-:

将输入加倍。

Processing.js，59个字节，已破解！

float igetuwebaoli(int p){return p*(((17*-4*-3)))+0+0;}//,,

此功能将输入乘以204（17*-4*-3=204）。它接受一个int作为输入并输出一个float。如预期的那样，逆将输入除以204。

可在此处找到用于processing-js的在线解释器。

J，10个字节，已破解

1%~<:[@*>:

另一个简单的。返回n ² -1。

JavaScript（ES6），15字节，由Emigna破解

t=>(!!0+~~t+~0)

此函数返回n-1。

您可以像这样测试它：

(t=>(!!0+~~t+~0))(6)

开裂

我想要的解决方案与Emigna的破解有所不同：

t=>t+(+!!~~~00)

J，29个字节（按英里数破解）

5#.[:,(3 5&#:(-$]-)7)#.inv"0]

这是一个动词，需要一个正整数作为输入，并执行以下操作：

1. 转换为基数2和4。
2. 用0填充base-4表示，使其长度与base-2表示相同。
3. 连接两个表示形式（首先从base-2开始）。
4. 将串联解释为以5为基的表示形式，然后转换为整数。

在线尝试！

我的解决方案

逻辑与破解中的逻辑几乎相同。等级连接"可以卡在许多不同的位置（并且我用它来消除不必要的0和3），因为它实际上并没有在解决方案中做任何事情。

(7-5)#.[:(]-:&#$,)5#.inv"0 3]

处理（java），59字节，安全

float igetuwebaoli(int p){return p*(((17*-4*-3)))+0+0;}//,,

此功能将输入乘以204（17*-4*-3=204）。它接受一个int作为输入并输出一个float。如预期的那样，逆将输入除以204。注意：两个程序都将int作为输入，并输出float。

该答案与我的其他答案完全相同，除了我的其他答案是使用Processing.js编写的。认识Processing-java，这是Java不太详细的表亲。您可以下载处理这里的processing.org。

裂缝

float ap(int i){return i*pow(blue(get(0,0)),-1);}//++7*4*-3

该程序将参数除以204。但是如何？让我们进入该函数。

i *                              //multiply i by
         blue( get(0, 0) )       //this (evaluates to 204)
    pow(                  , -1)  //raises to the -1 power (ie its reciprocal)

很简单，但是怎么blue( get(0, 0) )变成204？这是此提交的核心内容。首先，get(0,0)获取位于(0,0)（在处理草图中始终打开的窗口的左上角）像素的颜色。接下来，blue()获取该像素的蓝色值，即204！

为了提出这个建议，我通过打印通过获得的颜色的不同属性进行了实验get(0,0)。我已经发现了红，绿，蓝，alpha值是204，204，204和255分别。由此，我决定用这个数字做一个简单的操作，然后结束这篇文章。

JavaScript（ES6），Ilmari Karonen破解了 63个字节

x=>eval(atob`eCp4KzEvLyAgfXBModLS4TvEn4wp1iys9YRRKC85KLIhNMC=`)

是时候atob胡说八道了。此函数返回x*x+1where x是非负数。

用法

(x=>eval(atob`eCp4KzEvLyAgfXBModLS4TvEn4wp1iys9YRRKC85KLIhNMC=`))(5)

意向

x=>eval(atob`Lyp5fMRwICAgKi9NYXRoLnBvdyh4LTEsMC41KS8veCp4KzE=`)

有很多潜在的解决方案，但是我希望前导字符能够摆脱字节顺序，从而使这变得更加困难。塞斯特拉atob

Brain-Flak，26字节，破解

原版的

((((()()())){}[()]){}{}{})

我的裂缝

([(((()())){}()){}{}()]{})

1000000000的裂缝

([(((()())()){}){}{}](){})

Python 2，225个字节，由Sp3000破解

#((()))****+,,---/000555666888;==oppppppqqqqqw~~
lambda n:pow(n,65537,9273089718324971160906816222280219512637222672577602579509954532420895497077475973192045191331307498433055746131266769952623190481881511473086869829441397)

该函数的域是[0，n），其中n是上面的大数。是的，此功能在该域上是可逆的。除非我搞砸了，否则破解此答案就像破解512位RSA一样困难。

J，15个字节

(".&,'10.')#.#:

接受一个非负整数n，将其转换为二进制数字列表，并将这些数字组合为以10为底的数字。

在线尝试！