逆向工程从独特性(警察的线程)


23

给定警察程序(o)的输出,字节数(n)和使用的唯一字节数(c),得出一段相应的代码,该代码n长为c字节,具有与警察的输出相匹配的唯一字节o


这是警察的线索。在这里发布要破解的解决方案。

劫匪线位于此处


警察应该发布这样的解决方案:

#[Language], `n` Bytes, `c` Unique Bytes (c*n points) [Cracked](Link-To-Crack)

    [Output]

---

(Optional spoiler)

规则

  • 您可能没有为程序输入任何信息。
  • 该程序必须至少使用1个字节,但不能超过255个字节。
  • 输出本身也限制为255个字节。
  • 多次执行时,程序必须具有一致的输出结果。
  • 如果您提交的内容在7天内没有被破解,则可以将其标记为“安全”。
    • 标记为安全时,张贴预期的解决方案并将其评分为c*n
    • 仅当您确实希望+15作为可接受的答案时,才将答案标记为“安全” 。看看能走多久会更有趣。

获奖

  • c*n分数最低的未破解职位赢得了警察的支持。
  • 这将在10个安全答案或几周后决定。

注意事项

  • 如果您感到自大,则可以使用扰流器标签告诉用户该算法。

完整的提交内容:

fetch("https://api.stackexchange.com/2.2/questions/147635/answers?order=desc&sort=activity&site=codegolf&filter=!.Fjs-H6J36vlFcdkRGfButLhYEngU&key=kAc8QIHB*IqJDUFcjEF1KA((&pagesize=100").then(x=>x.json()).then(data=>{var res = data.items.filter(i=>!/^#.*cracked/im.test(i.body_markdown)).map(x=>{const matched = /^ ?#{1,3} ?(?:(?:(?:\[|<a href ?= ?".*?">)([^\]]+)(?:\]|<\/a>)(?:[\(\[][a-z0-9/:\.]+[\]\)])?)|([^, ]+)).*[^\d](\d+) ?\[?(?:.*(?:byte|block|codel)s?)(?:\](?:\(.+\))?)? ?(?:\(?(?!no[nt][ -]competing)\)?)?/gim.exec(x.body_markdown);if(!matched){return;}return {link: x.link, lang: matched[1] || matched[2], owner: x.owner}}).filter(Boolean).reverse().forEach(ans=>{var tr = document.createElement("tr");var add = (lang, link)=>{var td = document.createElement("td");var a = document.createElement("a");a.innerHTML = lang;a.href = link;td.appendChild(a);tr.appendChild(td);};add(ans.lang, ans.link);add(ans.owner.display_name, ans.owner.link);document.querySelector("tbody").appendChild(tr);});});
<html><body><h1>Uncracked Submissions</h1><table><thead><tr><th>Language</th><th>Author</th></tr></thead><tbody></tbody></table></body></html>


1
是否允许功能?(假设我返回了字符串)
。– Arnauld

1
@cairdcoinheringaahing。OP曾说过:“该程序在多次执行时必须具有一致的输出结果。”

5
这只是对未来CnR的建议:用户可以选择任意固定输出的挑战对于CnR来说是一个很大的问题,因为人们基本上可以混搭键盘(不限制语法限制)并发布结果,因为警察无需了解他们的操作。程序实际上在做。否则,这是一个巧妙的挑战想法。:)
Martin Ender's

4
@EriktheOutgolfer正如我所说的“禁止语法限制”。关键不是您实际上发布了随机的字符流,而是您不需要理解的随机有效程序。尤其是在许多esolangs中,编写一个输出大量随机垃圾的程序而无需了解该程序的作用是非常容易的。
Martin Ender

1
考虑到此挑战已经有30多个答案,我建议添加一个代码片段,其中列出了如本文所述的未破解提交内容。

Answers:


11

Haskell 173字节8个唯一1384点安全

"[tag:reverse_engineering]"

看起来此答案想为问题提供相关标签,同时仅使用8个不同的字节。

像往常一样,您的解决方案应该通过粘贴到TIO的代码块中来工作:在线尝试!


'[':___':_'':_':':':__':__:__'':__:__':____:__:'_':__:___:_':_'_:___:__:__:__':_'_:___:_':']':[]
_:_:_'':_:_:_:__:_:_':_:_'_:_:_:_:_:___:_:_:_:__':____:___':_:__'':_=['_'..]

是的,这是有效的Haskell代码:在线尝试!

怎么运行的

下划线_在Haskell的模式匹配中用作通配符。'用于字符,例如'a'。但是,_'也是标识符名称允许的字符的一部分(在某些限制下,例如',不能出现在名称的开头)。因此___'_'__''等都是有效的标识符名称。使用一些更具描述性的名称,以上代码变为

'[':t:a:g:':':r:e:v:e:r:s:e:'_':e:n:g:i:n:e:e:r:i:n:g:']':[]
_:_:a:_:_:_:e:_:g:_:i:_:_:_:_:n:_:_:_:r:s:t:_:v:_=['_'..]

"[tag:reverse_engineering]"如果每个变量都分配给正确的字符,则第一行将产生字符串。此分配在第二行中实现:['_'..]产生字符串"_`abcdefghijklmnopqrstuvwxyz{|}~ ... ",witch在模式_:_:a:_:_:_:e:_:g:_:i:_:_:_:_:n:_:_:_:r:s:t:_:v:_上匹配以获得所需的分配a='a'e='e'依此类推。


10

Brain-Flak,共62个字节,唯一6个,372点,已破解

这是您的输出:

10993592

这个数字有一些特别之处,但在OEIS上没有;)

如果您正在考虑使用计算机工具来解决此问题,那么您不走运,整数高尔夫球手会为此数字获取110个字节:

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

在线尝试!

您将必须手动执行此操作。


提示

这里有一些技巧,随着时间的推移,我将揭示更多有用的技巧。祝好运!

10993592是OEIS上序列的第97个术语,但由于仅包含几个术语而未出现。


我的解决方案使用3个循环,但它们嵌套3个级别。


我的解决方案

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

在线尝试!

这使用了我最喜欢的技巧之一,代码

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

计算A090809的第n个项。完整的提交仅用97填充代码即可生成大量代码。


我不禁要注意,PI中的10、993和592出现在十进制范围43-63之间,而前10个中也出现了592。我不知道Brain-Flak是否可以用62个字节来实现这一目标……
Yytsi

ASCII模式还是数字模式?
user202729

@ user202729我使用了数字模式,所以我相信强盗也需要使用数字模式。如果基于以前的尝试在ASCII模式下可以做到这一点,我将感到非常惊讶,因此可能不值得追求。
小麦巫师

1
@ThePirateBay我不认为“它属于哪个OEIS序列”总是有用的信息,请考虑Brain-flak多么深奥。它也是A000027的元素,但是这种观察也没有用。
user202729


7

MATL,6个字节×3个唯一值= 18点。开裂

1+0i 0+1i -1+0i 0-1i

2
该死的,浮点运算!
Stewie Griffin

2
@StewieGriffin我看到你很开心:-D
Luis

顺便说一句,i.^(0:3)在Octave中不会给出浮点数错误,但J4:q^在MATL中会给出...
Stewie Griffin

@StewieGriffin之所以出现差异是因为MATL的显示功能使用 num2str(..., '%.15g ')。例如参见这里。但是对于在Matlab上运行的MATL而言,这不会发生。结论是num2str略有不同在Matlab和倍频的作品
路易斯Mendo

无论如何,这不会影响此答案。可以通过在Matlab和Octave上运行的MATL获得指示的输出。并特别对TIO
路易斯Mendo

6

果冻,7个字节×6个唯一字符= 42点,已破解

843606888284160000

在线尝试!

8!×16!¤



哦,哈哈,我误用尾随零破解了它!
乔纳森·艾伦

@JonathanAllan好吧,例如,可以很容易地替换它。我想现在为时已晚...
Egg the Outgolfer

好吧,我用一个不必要的障碍破解了同样的问题:p
Jonathan Allan

@JonathanAllan如果愿意,尝试破解我的新书!
暴民埃里克(Erik the Outgolfer)'17年

6

Malbolge,15个字节,13个唯一,得分195。安全!

输出:

PPCG

安全!预期的代码:

(&a`#""7[}4XE70

在线尝试!


我确定通过暴力破解构建输出P的程序并在其上构建另一个P等的破解程序。将其提高到15可能会同时利用两个P。
约书亚

马尔博奇是邪恶的。用Malbolge编写程序已经太困难了,更不用说破解提交了。
user202729

6

JavaScript(ES8),103个字节,唯一的42个(4,326点)[安全]

输出十六进制转储:

3E 6E 6D 08 33 7A 22 7D 6C 37 7B 36 61 7B 65 71 3A 37 26 7E 7B 7B 38 7B 7D 69 6A 2B 3D 70 74 07 6F 6C 66 7E 1A 2A 3C 37 2D 36 31 38 6A 78 33 62 30 1E 34 3D 66 7B 37 10 26 6A 6A 32 27 6F 2E 33 1B 30 1E 76 27 27 7E 18 6F 68 26 2D 76 6A 6D 6D 2F 2E 0A 3F 17 7D 2B 73 7A 17 38 62 3A 29 20 0C 61 24 21 27 10 2B 20 63 71 72 17 5D 5F 12 5B 02 14 59 17 5A 11 1E 1D 10 16 07 5F 5F 58 58 4B 18 48 4B 04 5F 06 12 16 14 4D 45 5D 5D 16 3A 1C 1D 11 16 1F 51 59 4E 4B 4C 3D 16 1C 0F 2E 46 0E 08 4B 4B 13 45 21 10 06 0E 11 3F 51 57 3E 00 54 5F 49 05 0E 07 5A 51 3E 08 01 25 10 0B 51 36 43 0B 34 1A 43 47 04 46 0E 55 05 00 06 01 40 33 0F 00 53 36 42 42 45 5F 3D 3A 38 74 39 74 71 71 2C 7C 60 38 38 76 63 44 7F 64 28 66 3E 24 7A 66 57 79 24 3C 3C 21 6A 36 27 30 77 7E 36 7E 2A 3E 29

我知道这个分数异常高,但是无论如何,我认为破解这个分数可能很有趣。该程序是一个返回字符串的函数(为避免混淆,这不是REPL)。

我想这不应该太难,所有事情都与找到模式有关。

根据没有人破解的事实,似乎比我想象的要难。我相信可能有多种易于设计的解决方案。无论如何,这是预期的解决方案:

f = m => [... m = f + f + f] .map((a,p)=> p + 1&256?'':String.fromCharCode((p&4?m [p ^ 17]:a) .charCodeAt^83^p*.3)).join

由于某些原因,它不能正确显示为代码段。这是TIO链接


标记为安全?
user202729 '17

@ user202729。我同意,也许这个难题比我想象的要难,所以现在标记为安全。

5

八度,13字节,5个唯一字符,得分:65。安全!

20085918935040000

这不应该太难。如果您不想立即陷入最困难的困境,那可能是一个不错的第一个挑战:)

注意:当我阅读该问题时,我虽然说:输出数字,而不输出字符串。在TIO上的输出如下所示:

ans =    2.0086e+16

如果有的话,看起来会像这样 format long

ans =  20085918935040000

或者您可以这样打印:

printf('%i',ans)
20085918935040000

我有什么,并解释:

prod prodprod

就那么简单。=)

解释:

通常,您将其编写为:prod('prodprod'),但是Octave将函数名称之后的任何内容都视为字符串(字符数组)。它们隐式转换为它们的ASCII值,然后相乘。



4

Java 8(完整程序),总97个字节,唯一34个,3298点(@RobertoGraham破解

输出:

1.4241570377303032

注意:这是一个完整程序。如果()->允许使用形式的函数:

Java 8(lambda函数),总字节数40,唯一18,720点(@ user202729破解

这可能很难,但是无论如何。.但这并不意味着Java会以这种数量的积分赢得任何东西。


提示:

预期的代码不包含任何单引号或双引号。(该函数返回一个double。)
预期的代码不包含任何数字(0-9)。


预期解决方案:

非常有趣(和令人印象深刻)的是,给定的两个裂纹与我所想的完全不同,但是两个饼干的开头都是!

功能: 完整程序:()->Math.log(Math.hypot(Math.PI,Math.E))
interface M{static void main(String[]a){System.out.print(Math.log(Math.hypot(Math.PI,Math.E)));}}


为什么您似乎有两个程序,但是只有一个输出?
Okx

1
@Okx因为第二个是函数。
暴民埃里克(Erik the Outgolfer)'17年

@Okx正如Erik所说,因为它们都是相同的。顶部作为程序,底部作为函数。我仍在等待Arnauld的评论得到答复,因此我可以删除两者之一
。–

如此接近,字符串的直接打印是正确的长度,但是两个唯一性太多了:-) –实际上,如果不计算换行符,则为1…
Kevin


4

MATL,11个字节,10个唯一,110点。安全!

输出:

10803850202590

只是为了“帮助”您一种方式:

这是以下产品:

[2, 5, 29, 89, 397, 499, 2113]

372884884433rd素数少一


这里是一些真正的技巧。如果几个小时后仍未破解,我将给出解决方案。

  1. -有一个q在那里

  2. -有一个B在那里

  3. -有一个^在那里

  4. -有一个h在那里

  5. -有一个t在那里

真实代码:

9K ^ ZqsBthXB

说明:

按两个数字,9K,然后求幂。创建一个低于该数字的所有素数的列表,并对它们求和。转换为二进制,复制二进制向量并将其与自身连接。转换回十进制并隐式输出。


3

Haskell,10个字节,3个唯一,30点,已破解

2416508937

一个不错的数字,它包含每个数字,尽管只使用了3个唯一字节。

预期的解决方案通过替换以下TIO链接中的代码部分而起作用: 在线尝试!



@ H.PWiz我没想到它会持续很长时间,但这仍然非常快。我期望(或至少希望如此)强盗会首先尝试算术解决方案。
Laikoni '17

3

Haskell,29个字节,15个唯一字节,435点,已破解

"33333333333333333333333333333333333333333333334333333333333333333333333333"

这是一个包含373次的字符串,并且一个偷偷摸摸的4

预期的解决方案通过替换以下TIO链接中的代码部分而起作用:在线尝试!

编辑: H.PWiz找到了一个有效的裂缝(甚至可以打成28个字节),但不是预期的解决方案。

提示:

无需算术。存在单表达式解决方案。




3

爆炸,总9个字节,唯一4个,36点

输出:

22k2Dk}D}

请注意,文档与该语言的实现并不完全一致-我写了这一天,从那以后就没有涉及它,因此,实现中可能存在的任何错误现在绝对是功能。

另外,我认为这种语言不是图灵完备的,因此您可能会蛮力使用它,但这很无聊。

如果您可以将反向工程输出自动化为最佳的简短爆炸代码,我将给您很大的赏金。


您的代码分数是36,对吗?输出也将获得36分,所以我只是确保它没有错误。:)
Stewie Griffin

@StewieGriffin是的,因为当我第一次阅读该问题时,我误读了该问题,并认为代码的长度必须与输出的长度相同。
斯蒂芬

“高尔夫球爆炸代码”应该有多短?
user202729

@ user202729对不起,我应该解释-最佳短爆炸代码,因为它是完全确定的
斯蒂芬

但是问题是人们可能会写暴力代码来“理论上”找到输出,但是在实践中是不切实际的。
user202729


2

Pyth, 7 bytes, 6 unique, 7*6=42 total score

312069475503262125385169244603150327250717758754411025379995130624544231547913731661607993843298516888546865336571981925596

Check out the Pyth tips thread for inspiration ;)


2

Jelly, 3 bytes × 3 unique = 9 points, cracked

263409560461970212832400

Try it online!

Another attempt at Jelly, this time more challenging I hope.

ȷc⁵



@JonathanAllan With my intended solution this time :p I guess it was too easy to brute-force right? There were obviously only 2763520 possible solutions...and, ironically, you use the same function to calculate this number as well as the number to be cracked.
Erik the Outgolfer


2

Excel, 22 bytes, 16 unique, 352 points, Cracked

หนึ่งล้านห้าแสนสามหมื่นสองพันสี่ร้อยเก้าสิบห้าล้านห้าแสนสี่หมื่นแปดร้อยหกสิบห้าล้านแปดแสนเก้าหมื่นล้านล้านล้านล้านล้านล้านบาทถ้วน

This might not be very hard to crack but I get to use a function that I otherwise never get to use. Besides, the score won't win anything unless a lot of others get cracked.


cracked. Probably not your original code, but it works.
wythagoras


2

Jelly, 8 bytes * 6 unique = 48 (Cracked)

241975308641975308641975308641975308641975308641926913580246913580246913580246913580246913580246916

You can try to crack it here.

Intended solution: 7ẋ²Ḍ²ẋ4S



@JonathanAllan Your crack is invalid, sorry (it doesn't print the correct result). You can see the difference here
Mr. Xcoder

@JonathanAllan Heh, tried to solve another challenge at the same time (look at the arguments! :P)
Mr. Xcoder

1
@JonathanAllan Nice, I added the intended solution in my answer too :D
Mr. Xcoder

2

Haskell, 30 bytes, 17 unique, 510 points, cracked

"6666666444444455666666666566555533333334333333333"

The intended solution works by replacing the code part in the following TIO link: Try it online!

This uses the same approach as my previous answer, which was cracked using a different approach.

Some hints:

No arithmetic needed. I have a single-expression solution.


1

2

Javascript, 11 Bytes, 7 Unique Bytes (77 points) (Cracked)

0.022522522522522525

lambda function declaration included in byte count, function call is not.

This should be really easy.


Fixed cracked with the help of @Milk
Arnauld

2

Jelly, 8 bytes, 2 unique, 8×2 = 16 points -- Safe!

-4.408500694095235e-05

(There are only 8,355,840 possible such programs so it should get cracked I guess.)

Get going at Try it online!

How?

⁽⁽°°°°°°
⁽⁽° is a base 250 literal yielding -27221
° converts from radians to degrees. Applying this five times:
-475.09607568537643
-8.291990784013993
-0.1447225407260702
-0.0025258848375215096
-4.408500694095235e-05


Nice! Originally I think some double-byte may be related here, but then I dismissed it. I also considered °, but didn't think about and thought you have to stick with starting from 0.
user202729

@user202729 is different from , they're not related in any way (except that they consume the two chars that follow).
Erik the Outgolfer

@EriktheOutgolfer Sorry, I just mistyped the characters. I meant .
user202729

2

Jelly, 4 bytes, 4 unique, 4 × 4 = 16 points -- Safe!

121713205122350539153771498803599196214022517709999123476340843193655114000078051089267404501704293755399249186132786797198080437408108773592830098754467315464894774875031495160099382422748898046431945143395996374011431649446848855993397955116462522798880

Note that the output is 255 bytes long, right at the limit.

Yep, same score as my other (as yet uncracked) Jelly entry.

Get going at Try it online!

How?

7ÆĊ⁺
7 is a literal seven
ÆĊ gets the nth Catalan number
the 7th Catalan number is 429
repeats the previous atom
the 429th Catalan number is 121713205122350539153771498803599196214022517709999123476340843193655114000078051089267404501704293755399249186132786797198080437408108773592830098754467315464894774875031495160099382422748898046431945143395996374011431649446848855993397955116462522798880.



72 bytes is a little long, yes. You could remove the spaces (62). Also you could use vectorised r between two code-page index lists and concatenate with another code-page index list to get it down to 35 bytes, but there are also still repeated bytes there and 35 >> 4... good luck!
Jonathan Allan

2

C (two's complement machine, sizeof(int) = 4), 76 bytes and 35 unique bytes for a score of 2660, Safe

Output:

10542949672924294967287429496729029742949672954294967287429496728808914294967289429496728742949672946944294967291429496728742949672914964294967294429496728742949672891980429496728842949672874294967295792 

which is 203 bytes long.

#include<math.h>
main(){for(int
i=0;i<40;i++)printf("%u",(int)(cos(i)*10));}

Without the #include it won't work.


Can we use some compiler-specific features like in gcc?

1
@ThePirateBay: I didn't.
Joshua

1
I found an interesting approach but I couldn't golf out the last byte, so I just post it here. main(i){for(;42>i;printf("%u","eirwtlegowvnfemuwphejsno"[abs(24-i++)]-'n'));}
Colera Su

@ColeraSu Probably you can switch from lowercase to uppercase and change 'N' to 78 (char code of N).
user202729

@user202729 but it would not fit the restriction of 35 unique bytes.
Colera Su

2

CJam, 15 bytes * 10 unique = 150 points

453630781352162854505467929721140132016201833205823402832306035643819420004950

Bad score, but hopefully will be hard to crack.

Note: At the moment I have forgotten what the answer is. As such, I will keep it open until either I or somebody else is able to crack it.


Double answered :P flagged to be removed
Christopher

@Christopher2EZ4RTZ What do you mean? These are two separate answers with the same score breakdown, but different outputs.
Esolanging Fruit

Oh wow my bad. XD
Christopher

Ahaha... you, sir, must be a cop that's 2 days from retirement forgetting the answer like that ;P
Magic Octopus Urn

@MagicOctopusUrn Now I've retired, and have no interest in this anymore...
Esolanging Fruit

2

CJam, 15 bytes * 10 unique = 150 points

355605126761554652609272416635107412217265861355621217687464016216276447790261274709847680

Note: At the moment I have forgotten what the answer is. As such, I will keep it open until either I or somebody else is able to crack it.



1

Perl 5, 31 Bytes, 18 Unique Bytes (558 points) -- safe

1.76295255109024e+180

Intended solution (Try it online!):

$_=1;for$=(1..111){$_*=$=}print

(this calculates the factorial of 111)

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.