警察线可以在这里找到：神秘字符串打印机（警察）

你的挑战

• 从警察线程中选择一个提交，然后从该线程中的答案中打印出字符串。
• 您选择的提交内容必须不安全（必须晚于7天）。

• 您的程序，函数或REPL脚本需要遵循与警察线程相同的规则。回顾一下：

  • 您的程序必须为≤128个字符（如果警察提交的文件的程序长度较小，则您的程序也必须在该长度范围内。例如，如果警察的程序小于或等于32个字节，则程序的长度必须小于或等于32个字节）。
  • 程序每次运行都必须产生相同的输出。
  • 没有加密功能。
  • 该程序不得输入。
  • 没有标准漏洞。
• 所有新提交的内容必须使用相同的语言。即使不这样做，也可以在制定此规则之前提交意见。

计分

抢劫者的计分方法类似，但略有不同：

• 破解任何≤8个字节的程序可得1分。
• 破解一个≤16字节的程序可获得2分。≤32个字节给出4分，依此类推。
• 每增加一个提交，无论长度如何，均可获得+5积分
• 每个警察的提交只能被破解一次-只有第一个破解每个提交的人才能获得分数。

意见书

每个答案必须包括

• 警察提交的链接。
• 您的程序和编程语言。
• 还应将警察的程序长度（作为2的幂）作为标题中的最后一个数字。

此外，请评论警察的意见书，并附上您答案的链接。

这是生成排行榜的堆栈片段。如果代码段存在问题，请发表评论。如果您想查看所有公开的警察意见，请参阅警察挑战中的摘录。

/* Configuration */

var QUESTION_ID = 60329; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";

/* App */

var answers = [],
  answers_hash, answer_ids, answer_page = 1,
  more_answers = true,
  comment_page;

function answersUrl(index) {
  return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {

  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });

}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      data.items.forEach(function(c) {

        answers_hash[c.post_id].comments.push(c);

      });

      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();

var POINTS_REG = /(?:<=|≤|&lt;=)\s?(?:<\/?strong>)?\s?(\d+)/
var POINTS_REG_ALT = /<h\d>.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;


function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {

  var valid = [];
  var open = [];

  answers.forEach(function(a) {

    var body = a.body;
    var cracked = false;

    var points = body.match(POINTS_REG);
    if (!points) points = body.match(POINTS_REG_ALT);

    if (points) {
      var length = parseInt(points[1]);
      var crackedpoints = 0;
      if (length > 64) crackedpoints = 16;
      else if (length > 32) crackedpoints = 8;
      else if (length > 16) crackedpoints = 4;
      else if (length > 8) crackedpoints = 2;
      else crackedpoints = 1;

      valid.push({
        user: getAuthorName(a),
        numberOfSubmissions: 1,
        points: crackedpoints

      });
    }
  });

  var pointTotals = [];
  valid.forEach(function(a) {

    var index = -1;
    var author = a.user;
    pointTotals.forEach(function(p) {
      if (p.user == author) index = pointTotals.indexOf(p);
    });

    if (index == -1) pointTotals.push(a);
    else {
      pointTotals[index].points += a.points;
      pointTotals[index].numberOfSubmissions++;
    }

  });

  pointTotals.forEach(function(a) {
    a.points += +((a.numberOfSubmissions - 1) * 5);
  });

  pointTotals.sort(function(a, b) {
    var aB = a.points,
      bB = b.points;
    return (bB - aB != 0) ? bB - aB : b.numberOfSubmissions - a.numberOfSubmissions;
  });

  pointTotals.forEach(function(a) {


    var answer = jQuery("#answer-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{SUBMISSIONS}}", a.numberOfSubmissions)
      .replace("{{POINTS}}", a.points);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);


  });

}

body {
  text-align: left !important
}
#answer-list {
  padding: 20px;
  width: 240px;
  float: left;
}
#open-list {
  padding: 20px;
  width: 450px;
  float: left;
}
table thead {
  font-weight: bold;
  vertical-align: top;
}
table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Robber's Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr>

        <td>Author</td>
        <td>Submissions</td>
        <td>Score</td>
      </tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>

<table style="display: none">
  <tbody id="answer-template">
    <tr>
      <td>{{NAME}}</td>
      <td>{{SUBMISSIONS}}</td>
      <td>{{POINTS}}</td>
    </tr>
  </tbody>
</table>

该竞赛现已结束。

总冠军：肯尼

提交人数最多：Sp3000

（请注意，提交的数量并不能完全转换为分数，因为计算分数时会计算出破解程序的长度）。

Pyth，丹尼斯，≤8

V./Tp*FN

该死的很有趣-最难的部分是弄清楚如何在Pyth中做得足够短。

分析

在1234那我们可能处理的数字列表开始提示，打印不使用隔离。让我们尝试以一种有意义的方式对数字进行拆分：

1 2 3 4 4 6 5 8 8 9 6 12 10 12 7 16 16 18 12 15 16 8 24 20 24 14 27 18 20 9 32 32 36 24 30 32 16 36 21 24 25 10

有一些暗示我们走在正确的轨道上：

• 所有数字的素数均小于10
• 许多数字都非常接近列表中的索引

但是，有一些特殊之处。索引23处的数字是24，并且是索引处的数字大于索引本身的唯一情况。但是，更大的线索是某些数字明显小于其邻居，特别是索引15的7，索引22的8和索引30的9。

注意这形成了7-8-9模式，我们还可以看到最后一个数字是索引42处的10。考虑到@Dennis最近对阿贝尔群的疑问，对OEIS的快速检查表明这15, 22, 30, 42是该分区的子序列数字。Pyth有一个内置的分区，可以给我们八个字符中的两个：./

但是请注意，最后一个数字是10，这很可疑，因为10是Pyth中的预初始化变量，如T。./T给出了数字10的42个分区的完整列表，看起来可能派上用场。

现在，无需分隔符即可完成打印，因此暗示使用p。也许我们遍历每个分区，对其做点什么，然后打印p？这为我们提供了以下模板：

V./Tp??N

其中V是一个for循环，它循环遍历可迭代对象，并将每个元素存储在变量中N。

快速查看倒数第二个分区(5, 5)应该可以很明显地看出我们要购买产品。通过乘法减少列表的幼稚方法是

u*GHd1

d问题清单在哪里。但是，这太长了。

不幸的是，这是我不得不拔出蛮力的地方。我已经有一段时间没有跟上Pyth了，所以我不了解许多较新的功能。只剩下两个字符，看起来完全可行。

蛮力然后返回：

V./Tp*FN

哪里*F被折叠*（相乘）。难怪我没有在搜索中找到它-我在查找关键字“ reduce”而不是“ fold”！

Mathematica，alphalpha，≤32

GroupOrder[MonsterGroupM[]]

我讨厌这样说，但我只是当场就认出了这个号码。

> <>，​​VTCAKAVSMoACE，≤64

'9?':?!;1-$:'@'+o'3'*'='%$30.

具有讽刺意味的是，这不仅大大降低了范围限制，而且还便于携带并且可以与在线解释器一起使用。

分析

让我们从目标字符串开始：

yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh[

> <>使用'或"以字符串模式将字符压入堆栈，但是要打印63个字符，并且只能使用64个字节，因此必须使用大写字母（对于标准环回技巧，> <>中的无效指令）可以直接打印不可能。因此，我们必须对代码点做一些事情。

转换为代码点可以得到（我在这里使用Python）：

>>> L = [ord(c) for c in "yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh["]
>>> L
[121, 104, 91, 99, 80, 87, 78, 107, 122, 94, 69, 75, 76, 66, 105, 81, 77, 117, 83, 118, 73, 96, 110, 92, 89, 119, 124, 74, 86, 88, 68, 85, 98, 90, 109, 102, 111, 82, 67, 95, 120, 114, 113, 123, 84, 108, 112, 72, 106, 71, 116, 93, 79, 97, 100, 70, 65, 115, 103, 101, 121, 104, 91]

请注意，后三个数字与前三个相同。这暗示可能正在进行模循环。

让我们看一下我们有多少个不同的元素：

>>> len(set(L))
60

中有63个元素L，其中前三个与后三个一致。这意味着，除了此碰撞之外，所有其他元素都是唯一的。现在，这暗示着要取幂以质数为模。确实，60 + 1 = 61是素数，这是一个好兆头。

让我们尝试找到最小的元素

>>> min(L)
65

并使用它按比例缩小所有元素，使min元素为1：

>>> M = [x-64 for x in L]
>>> M
[57, 40, 27, 35, 16, 23, 14, 43, 58, 30, 5, 11, 12, 2, 41, 17, 13, 53, 19, 54, 9, 32, 46, 28, 25, 55, 60, 10, 22, 24, 4, 21, 34, 26, 45, 38, 47, 18, 3, 31, 56, 50, 49, 59, 20, 44, 48, 8, 42, 7, 52, 29, 15, 33, 36, 6, 1, 51, 39, 37, 57, 40, 27]

注意after元素1是怎样的51。如果发生某种幂/乘法运算，那么对于我们的乘法器来说是一个不错的猜测。

让我们试一下：

>>> (57*51)%61
40
>>> (40*51)%61
27
>>> all((x*51)%61 == y for x,y in zip(M, M[1:]))
True

答对了！我们现在可以回溯，给出以下代码：

x = 57
for _ in range(63):
    print(chr(x + 64), end="")
    x = (x*51)%61

然后将其翻译为> <>

Pyth，Maltysen，≤4

C.ZG

蛮力花了很长时间，所以我手动做得更快。

分析

C（将字符串转换为256 int基数）是在Pyth中生成大量数字的最简单方法，因此它可能是第一个字符。如果以256为基数进行转换，则得到：

xÚKLJNIMKÏÈÌÊÎÉÍË/(,*.)-+¯¨¬ 

嗯...不是很有启发性。

现在G是字母字符串"abc...z"，看起来它可能是输入长字符串的来源C。查看文档，我发现：

.Z    Compresses or decompresses a string.

如果我们在这里处理压缩，获得各种扩展的ASCII字符也就不足为奇了。C.ZG然后尝试给出了答案。

傅立叶，β衰变，≤32

2~x1~y20(xoy~z*x~yz~xq^~q)

或者，在CJam中：

X0I{_2$+}*]2\f#

分析

在开始时，我们可以看到很多2的力量：

2
1
2
2
4
8
32
256
8192
2097152
...

如果我们以这些数字的对数为底2，则得到：

1 0 1 1 2 3 5 8 13 21 ...

这是Fibonacci系列，从开始1, 0。

蜗牛，雌蕊，≤2个字节

z

这实际上是2个字节；字符z后跟换行符\n。

我不知道它是如何工作或正在做什么的，但是在测试了除~+和之后的所有可能的输入之后~,，这是唯一8作为输出生成的2字节程序。

并且花了很长时间才得到这个结果。难怪它被称为“蜗牛” :-D

^{自我注意：下次对未知软件进行模糊测试时，请在VM内进行测试。}

Rust，Liam Noronha，≤128个字节

fn main(){print!("AACAAEGAAACIIMOAAACAAEGQQQSYYDFAAACAAEGAAACIIMOHHHJHHLNXXXAGGKMAAACAAEGAAACIIMOAAACAAEGQQQSYYDFOOO");}

仅逐字打印字符串就是120个字节...

通心粉0.0.2，门把手，≤64

set x "................................."print x print x print x

Python 2，带有示例的明确问题，<= 64

一种可能的解决方案：

print ''.join([" `{.~{{~||"[int(c)] for c in str(3**4278)])

（9**2139，27**1426并且729**713也给出相同的结果）

CoffeeScript，user2428118，≤64

alert 0+(btoa k.substr -2 for k of document.body.style).join ''

（仅适用于Cop所述的Chrome 46.0.2490.71。）

由于所有“ =”，输出显然是由短base64编码的字符串组成的串联。解码后，我们发现一个2字符字符串的列表，例如

['nt', 'ms', 'lf', 'ne', 'll', 'on', 'ay', 'on', …

这似乎没有意义。但是我发现其中有些奇怪的东西，例如nX和tY。过滤掉这些后，我们得到

>>> # Python
>>>
>>> [i for i in tt if not re.match('[a-z]{2}$', i)]
['nX', 'nY', 'tX', 'tY', 'wX', 'wY', 'r', 'nX', 'nY', 'tX', 'tY', 'nX', 'nY', 'nX', 'nY', 'nZ', 'x', 'y']

这些X和Y似乎表明使用了诸如位置属性之类的原始源代码offsetX/Y。一件特别有趣的nZ物品。为了检查我的假设，我搜索了所有以“ Z”结尾的属性：

// CoffeeScript
checked = []
f = (o) ->
    if !(o in checked) 
        for k of o
            if /Z$/.test(k)
                console.log(o, k)
            if o[k] instanceof Object
                f o[k]
f window

显示吨CSSStyleDeclaration, "webkitTransformOriginZ"。由此我们可以有力地表明，该列表是由style对象的所有键的最后2个字符组成的，上面的测试确实表明这是正确的。

Lua <= 4，埃格·斯克里普诺夫（Egor Skriptunoff）

很多用户在聊天中都对这个答案感到不安，因此，我必须摆脱他们的痛苦。我不了解Lua，也无法对其进行测试，但是如果这不起作用，我将感到非常惊讶。

4^~9

这将是很明显的，但可能没人能做到，因为仅在5.3版中添加了按位运算符。ideone.com仅具有5.2版。

Python 2，histocrat，≤16

[[[51002**3/6]]] 

最大的暗示是它在Python 3中不起作用的承诺。Python 3中有什么变化？最大的怀疑是除法运算符float在Python 3中返回a 。

所以，我认为解决的办法是形式的⌊α ^β /n⌋= C = 22111101102001，因为幂是创造巨大的数字只有一小段路。

如果{α，β，n}确实形成一个解，则（cn）^{1 /} β≈α应该非常接近整数。因此，我使用以下方法尝试对每个n强行{α，β}：

(* Mathematica *)
n=2; Sort[Table[{N[Abs[k - Round@k] /. k -> (22111101102001*n)^(1/b), 12], b}, {b, 2, 50}]]

(* Output: {{0.00262542213622, 7}, ...}

   The first number is the "quality" of the solution, lower is better.
   the second number is β.
   Thus α ≈ (nc)^(1/β) = 89
   But (89^7)/2 = 22115667447764, which is still far away from the answer.

*)

当n = 6时，实际结果很快就会出现。

MATLAB，StewieGriffin，≤16

[36;87]*' |'*5

印刷品：

ans =
        5760       22320
       13920       53940

Matlab，Luis Mendo，≤16

我找到了，是的！

fix(peaks(9).^2)

我不知道Octave也可以做到这一点。

Mathematica，军团哺乳动物978，≤64

Print@Nest[Compress,ExampleData[{"Text","ToBeOrNotToBe"}],13]

Python，spacemanjosh，≤64

n=0;d=1;L=[]
exec("L+=[10/(100-n)**.5];n+=d;d+=2;"*10)
print(L)

光荣的逆符号计算器。打的不好，但是适合。

编辑：我打了它。

print([10/(100-n*n)**.5for n in range(10)])

JavaScript ES6，CᴏɴᴏʀO'Bʀɪᴇɴ，≤128字节

var x=122,s='0037122342526683102122';for(var i=23;i<=505;i+=2)s+=(x+=i);s;

我怀疑这是正确的，因为我不需要128个字节附近的任何内容，但是找到重复序列是一项有趣的挑战。

Thue，ppperry，<= 64

0::=11
1::=22
2::=33
3::=44
4::=55
a::=bbb
b::=000
::=
aaaaaaa

本质上，将2016年分解为其主要因素。62个字符，所以我猜这与您想要的字符相似。

Python，DLosc，≤32

（此解决方案使用Python 2）

a=97
while a<4e31:a^=a*2;print a

> <>，​​Sp3000，<= 8

'l(?; o>

指令指针回绕并且发生以下步骤：

• 'l(?; o>'将的ASCII值压l(?; o>入堆栈
• l 将堆栈的大小压入堆栈
• (比较前两个堆栈元素：size of stack和ord('>')
• ?; 如果堆栈较大，则停止程序
• o将堆栈的顶部元素输出为字符（始终为o）
• > 设置IP方向，此处为无操作
• 我们回到第一步

输出为oooooooooooo。

通过更改[space]为在堆栈上>压入或弹出的内容，并使用另一个有效字符代替，也可以压入或弹出，我们可以获得很多不同的输出。

JavaScript，ev3commander，≤32

console.log(0.1411200080598672)

好，那很容易。

CJam，Reto Koradi，≤4

HJK#

推17，然后推19 ²⁰ = 37589973457545958193355601。

在线尝试。

您只能用四个字节来做很多事情。这个大的整数必须以某种方式包含幂或阶乘，阶乘将具有尾随零。

Pyth <= 4，丹尼斯

ljyG

这是字母表所有子集的换行符的连接长度。

测试运行：

$ pyth -cd 'ljyG'
==================== 4 chars =====================
ljyG
==================================================
imp_print(Plen(join(subsets(G))))
==================================================
939524095

我发现数字2^27 * 7 - 1是一个很强的暗示，它基于yG，2^26元素长。然后，我猜测它必须转换为字符串并打印其长度。但是，我能想到的唯一方法是``，重复。然后我想到了j，这非常适合。

C，土库克西，≤64

main(i){for(i=0;i<11000;++i)if(!(i&2*i))printf("1%d",!(i&1));}

输出均为0和1，但是C无法直接打印二进制，因此很有可能是布尔结果。

1大于0，因此我记录了0s（3, 9, 13, 19, …）的位置，结果是OEIS A075318。但是，这没有用，没有简单的公式可以确定数字在此序列中的位置。

但是我们注意到所有奇数(x-1)/2 = {1, 4, 6, 9, 12, …}都有，因此也许有更多有用的信息。这是A003622。

A003622可以定义为“ A003849中1的位置”，这正是我们在这里需要破解的地方。并且A003849被定义为“ A003714 mod 2”，其中A003714只是所有的整数x & (2*x) == 0。这样我们得到了解决方案。

OEIS约

Dyalog APL，丹尼斯，≤4

*⍨⍟8

计算ln（8）^ ln（8）。StackExchange会停止转换我的答案吗？我将在此处键入一堆东西，以免被评论。

卡住，@ quartata，≤8

以下Pyth程序：

^33 9

产生所需的输出

46411484401953

破解方法：在Google上搜索该号码。

Pyth，xnor，≤4

C`CG

CG（"abc...z"从基数256 转换字母字符串）是生成很大数字的典型Pyth方法。之后，只需将其字符串化并再次从base转换即可。

Python 3，Mego，≤128

（使用Python 3.5.0，未经先前版本测试。 105 98个字节。）

import sys
a=sys.stdout
sys.stdout=None
from this import*
a.write(s.translate(s.maketrans(d))[4:])

红宝石，门把手，≤64

'@@'=~/(.)(.)/
p$~
test 0 rescue p"#$!@@".gsub //,$!.inspect+$/

Matlab /八度，Wauzl，≤16

"234"'*"567"

使用与汤姆·卡彭特的答案相同的想法

（如果它不起作用，请尝试以下操作：）

[50;51;52]*'567'