这是警察和强盗挑战的一部分。去这里参加警察的活动。

强盗的挑战

可以通过从Haystack程序中删除字符的任何子集来破解警察的答案，以便输出Needle而不是Haystack（尽管仍然是使用相同语言的有效提交）。只要您受上述限制的约束是有效的，就不必找到与警察完全相同的解决方案。

如果您可以管理此问题，请在解决方案中发布答案，并链接到警察的答案，然后对警察的答案发表评论，并链接回您的答案。

破解最多警察答案的强盗获胜。领带被破解的警察答案的大小之和打断（赞成强盗破解更长的提交内容）。

每个警察的答案只能破解一次，当然，您也不能破解自己的答案。如果警察的答案在被破解之前或之后被证明是无效的，则不计入强盗的分数。

例子

这是几个使用不同语言的简单示例：

Ruby

Haystack: puts 1>0?"Haystack":"Needle"
Delete:        XXXXXXXXXXXXXXX
Needle:   puts "Needle"

Python 2

Haystack: print "kcatsyaHeldeeN"[-7::-1]
Delete:          XXXXXXXX        XX
Needle:   print "eldeeN"[::-1]

请注意，已删除字符的子集不必是连续的。

code-golf source-layout cops-and-robbers

— 马丁·恩德
source

如果hashing, encryption or random number generation允许强盗使用？（尽管可能性很小）

— l4m2

11

JavaScript，85个字节（ES6）

破解Arnauld的答案

f=(k=b=x=35)=>x--?f(k*4853461&268435455):k&2?'N'+(k^12408877).toString(b):'Haystack'

“针”演示

显示代码段

f=(k=b=x=35)=>x--?f(k*4853461&268435455):k&2?'N'+(k^12408877).toString(b):'Haystack'

console.log(f())

Expand snippet

说明

原始功能是：

f=(k=b=x=35)=>x--?f(k*74837258394056219&268435455):k&2?'N'+(k^124038877).toString(b):'Haystack'

更具可读性：

f = (k=b=x=35) => {
    if (x--) {
        return f(k*74837258394056219&268435455);
    } else {
        if (k&2) {
            return 'N'+(k^124038877).toString(b);
        } else {
            return 'Haystack';
        }
    }
}

请注意n=21625674，当时n.toString(35)为'eedle'。

输入中的35可能无法更改为子集（因为我们想要一个足以容纳所有字母'del'的基数，因此我们需要的基数至少为22）。因此，数字改变是74837258394056219，268435455和124038877。我们想用数字a，b，c代替它们，每个数字都由原始数字的数字的子集组成，这样，函数g(k) = (k * a & b)从开始k=35重复35次，然后与c进行异或运算，得到21625674。

为这一个，思考一下，作为长度小（最大后a具有长度17，b和c具有长度为9），我只是用蛮力:-)写一个C ++程序，以产生所有可能的数字a，b，c形成为子集的原始数字，遍历所有a和b，然后检查是否c在集合中。运行在约15秒，而唯一的输出是a=4853461，b=268435455，c=12408877（匝数列数b不需要改变）。我不确定是否有更聪明的方法来反转此功能。

— ShreevatsaR
source

5

干草堆，82个字节

破解HyperNeutrino的答案

0\1-c\
/    
?10F17+c8F+4+cd8F+3+c6-c1+c,c2+c8+c|
 0   \1++c,c|
F/c++2F8
c\8F+2+cd

在线尝试！

— 火烈鸟241
source

1

真好！我的设置方法是，我最初的解决方案是从字面上删除0：P很高兴看到另一种方法！+1

— HyperNeutrino

5

Brain-Flak，96字节

破解了时髦的计算机人的答案。

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

在线尝试！

这是一个有趣的挑战。

最初将转换y为的-24 a现在用于转换e为M，然后N通过将整个结束循环更改为来转换为原位())。通过删除添加了6的push-pop，将第一个推入的字母k更改为e简单的字母。其余的大部分只是放在适当的位置，在执行过程中有些幽默的错误（包括一个输出为的程序Meddle）。

两种方案的比较：

Haystack: ([((((()()())){}){}){}](()([()](()({}([((((()()()){})))[]])[]({}({})[{}]()({}((()(({}){}){}){}){}())))[][][][][][]))[]))(((()[]){}){({}[()()])}{})
Needle:   ([((((()()())){}){}){}](() [()]   ({}([ (((()()()){})) []])[]({}({}     ()(  ((()(({}){}){}){}){}())))[]              ))   ()  )

— 硝化龙
source

我相信，这将最终像这样

— H.PWiz

那当然行得通，但是我以某种方式说服了自己那N是77而不是78，所以我没有抓住它。

— Nitrodon

反正你的矮一些。

— H.PWiz

有趣的解决方案！如果您希望看到它，我已将我想要的解决方案添加到原始帖子中。

— 小麦巫师

5

哈斯克尔

破解@Laikoni的答案。

s=map;hay=zipWith;a=head;h=s a.(hay(scanr id).s a<*>s(succ<$))$words"Haysta ayst ackH ays k ayst"

在线尝试！

原始代码：

hays=map;hay=zipWith;stack=head;h=stack{-
 hay.(hays.(stackany hay$or id).stack hay
<*>hays(sum$stack haystack<$>hay))-}$words
 "Haystack Hayst ackH aysta ckH aystac k"

用下划线替换已删除的字符：

___s=map;hay=zipWith;__a__=head;h=s______
 _a_.(hay__(s__c_an_______r id).s____ _a_
<*>___s(su_____c________c_<$____))__$words
 "Haysta__ _ayst ackH ays__ _k_ ayst____"

如何Needle构造：将代码末尾的字符串拆分为单词。每个单词的第一个字符递增的次数是单词中字符的多少，例如 Haysta-> H加6个字符-> N。

— 妮米
source

5

六边形，17字节，H.PWiz

]; N @ cl; e ;;（\。s。; _

在线尝试！

与原版比较：

];N.@cl;e@;;(\H/;ya;_.>s.;t//<._  original
];N @cl;e ;;(\       . s.;     _  modified

可视化：

  ] ; N
 @ c l ;
e ; ; ( \
 . s . ;
  _ . .

说明

奖励标记-使用所有6个IP和除其中一个单元以外的所有单元！

IP＃0首先沿着黑色路径进入]。
然后，我们过渡到IP＃1，该IP沿着红色路径前进，先进行打印N，N;然后再卷回]。
然后，我们过渡到IP＃2，该IP沿着蓝色路径前进，存储e在当前存储单元中，然后沿着绿色路径前进，执行打印（在处有反射\），将存储单元从递减到然后再打印。 IP沿橙色路径继续执行，执行打印，并将其存储在当前存储单元中。它沿着棕色路径继续，用;;(;eeedd
Nl;selee;。至此，我们已经完成了打印Needle，其余的工作才刚刚完成。IP存储c，然后点击]。然后，我们过渡到IP＃3，该IP沿着蓝色路径前进，撞击，弹跳并反弹到。然后，我们过渡到IP＃4，该IP沿着绿色路径前进，在上弹跳，然后分支到（因为为正数）。最后，我们过渡到IP＃5，该IP将进行存储，然后使用退出。

\_]
_\]c
e@

— Boboquack
source

真好！那是预期的解决方案。

— H.PWiz

4

Python 2，123字节

破解agtoever的答案

import numpy
print "".join([dir(numpy)[int(i)][0] for i in numpy.poly1d([-143/2e1,-31,14,131,61,184])(numpy.arange(-3,3))])

代表

比较：

print "".join([dir(numpy)[int(i)][1-0] for i in numpy.poly1d([-1*1433/252e1,-3232/1920.,4026./72/2/3.,613/(6*4.)*1,-4723./1.8e2,-9763/120.,-2689/(-1+5*17.),1+138*.4*2])(numpy.arange(-12/3,13%9))])
print "".join([dir(numpy)[int(i)][  0] for i in numpy.poly1d([-1  43 /2  e1,-3    1    ,               1     4    ,       1         3 1   ,  6     1       ,1   8  4  ])(numpy.arange(-   3, 3  ))])

我发现了很多有趣的发现解决方案，这些解决方案可以打印出来，Meedle并且可以Needlf通过将多项式与以开头的每个字母开头的numpy符号的索引的中位数拟合Needle。然后，我尝试用手查找原始程序子集的相似系数，但最终不得不采用蛮力迫使一个系数找到有效的解决方案。

— 雅各布利
source

哇！做得好！我没想到它会很快被破解。

— agtoever

我最初开发基于numpy的1.13的挑战，这是我没有任何REPL环境找到，所以我不得不把它改写为numpy的1.12 ... ;-)

— agtoever

2

Javascript，91个字节

_=>(+{}+[])[+[]]+([][[]]+[])[3]+([][[]]+[])[3]+([][[]]+[])[2]+(![]+['t'])[2]+([][[]]+[])[3]

破解这个。真的很有趣。

显示代码段

let f =

_=>(+{}+[])[+[]]+([][[]]+[])[3]+([][[]]+[])[3]+([][[]]+[])[2]+(![]+['t'])[2]+([][[]]+[])[3]

console.log(f())

Expand snippet

— 我的代词是莫尼卡
source

2

果冻，14 字节

破解乔纳森·艾伦的答案

“¡#ɦṢÞɠ»ḟ“¡pṄ»

在线尝试！

比较：

“¿ọ⁽ṅ*FỊ⁼g£¡#!ʋzoɦṪ£ṢÞḲÐɠ`”m3⁾“»jVḟ“¡!pṄ»
“          ¡#    ɦ  ṢÞ  ɠ      »  ḟ“¡ pṄ»

我曾经œc遍历文字字符串的各个子集，用于tr -d每个可能的过滤器，并grep针对Needle进行编辑。假设答案中未使用第一个字符串中的所有已使用字符，则让它在15秒内找到答案。

— 雅各布利
source

正是我想到的一个Nebbed+ ruble没有任何一个rub。

— 乔纳森·艾伦，

2

Python 2，73个字节

破解user71546的答案。

a,b,s=2707385038437,0b10000000,""
while a>0:
 s=chr(a%b)+s
 a//=b
print s

在线尝试！

用这个程序解决了。

— 雅各布利
source

2

Java（OpenJDK 8），191字节

破解卢克·史蒂文的答案

String d(){int h=3905055,m=55,s=15443;String d="0"+h*2+""+m*20+""+s*7,x="",y;for(int g=0;g<d.length();g+=3){y="";for(int e=0;e<3;e++)y+=d.charAt(e+g);x+=(char)Integer.parseInt(y);}return x;}

在线尝试！

删除的字符：

int h=3609000-5055+911,m=557558,s=15441301-157*10000
       xx  xxx    xxxx     xxxx       x xxxxxxxxxxxx

这使d评估到078101101100108101拼写Needle。

— 牛奶
source

2

红宝石，149字节

破解：https : //codegolf.stackexchange.com/a/144790/74216

模块很小，所以我写了一个多线程的生日礼物，并希望最好。

编辑：然后找到一个更短的答案。

x='hxDKFQOoqJLuVNW'
s="n=x.to_i 36;x.bytjs.jach_cons(3){|a,b,c|n+=n*b%c;n*=a^b};puts n%8675309==1388649 ?'Njjdlj':'Haystack'"
eval s.tr ?j,s.size.chr

在线尝试！

变化：

x='yGwztsPXhxDkBKlCYdFjQnpUROfoHvqmTgbaJSLcEiZrIAuMVNW'
x='        hxD  K    F Q    O o  q     J L       u VNW'

# and here's some more variants for extra pwnage:
x=' G  tsPx     KlCYd  Qn U   o v mT  a SLc    I u  NW'
x='  w  s    D BKl  dF QnpU O        ba SLcEiZrI  MV  '
x='yGwz s Xh Dk K C  F  npU O  Hvq   b   L    rIAu V W'

— cab404
source

2

dc，34个字节

93 9 2*+432212+ 47*4242160 7 2++*P

破解这个。TIO。

我首先获得了Haystack（5215583380252484459）和Needle（86197399743589）的数值表示形式。接下来，我将后者分解为47 * 432323 * 4242169。由此，重建这些数字非常容易。

标记使用的字符：

6 93 3 9 2 2**+*+483622 1 2 3 3*+3*+89 47*+*+3 5 2* 269 158 9**107 97*2 4*++2 3 3*+42 14 2**+*+5*+5 2148 1 6 2*+*+68262 5 280 7 2 3 3*+5 2**+*+*+*+P
  XXX  XXX   XX  X X XX X X     X     XXXX                              X   X      XX X                    X                XXXXX     X     XX     X

— 敏捷的
source

gg！我知道输入这么多数字是个坏主意）

— cab404

@ cab404只是好奇：您是否使用了截然不同的计算方法得出86197399743589？

— agtoever

是的，时间要长很多

— cab404

哇。太好了那可能是另一个代码高尔夫问题：通过删除表达式中的字符有多少种方法来获得特定结果……

— agtoever

我想这通常需要一些认真的数学来计算所有可能性，并证明只有那个数）

— cab404

2

六边形，19字节，马丁·恩德（Martin Ender）

[@;(...e<l.a;./;N>;

在线尝试！

与原版比较

H[@;(...e<l.a;./$.>;\sN;\ac.>).;;;._y
 [@;(...e<l.a;./   ;  N     >  ;

展开代码

  [ @ ;
 ( . . .
e < l . a
 ; . / ;
  N > ;

因此，我从未用Hexagony写过任何东西，但是我认为只有37个字节可以解决这个问题。马丁，希望您知道我花了很多时间来解决这个问题。:)

我可能不正确，但是我将解释我认为这段代码在做什么：

程序以开头[，并自动移至IP＃5。该IP从西角开始，[再次指向IP地址＃4。从这里开始执行，N;e然后前往东南角并执行;，向右弹跳另一个，;然后环绕，然后将(电流递减e到a d。然后继续...;.播放（绕动），然后跳到l并到达[最后一个，移至IP＃3。它执行后;，>重定向到西北，.然后<重定向到西面，击中e，环绕;并终止于@。

详细版本

显示代码段

[   We move to the previous instruction pointer (starting at the e and moving NE)
e   e is entered into the current memory cell
(   Decrements the memory cell to d
[   We move to the previous instruction pointer (starting at the N and moving NW)
N   N is entered into the current memory cell
;   Outputs N
e   e is entered into the current memory cell (IP now wraps to the SE corner)
;   Outputs e
/   Mirrors IP to the east
;   Outputs e (IP now wraps to ( on NW edge)
(   Decrements the memory cell to d
... No-ops (IP now wraps to ; on SW edge)
;   Outputs d
.   No-op
/   Mirrors IP to the NW
l   l is entered into the current memory cell
.   No-op
[   We move to the previous instruction pointer (starting at the ; and moving west)
;   Outputs l
>   Redirects the IP NW
.   No-op
<   Redirects the IP west
e   e is entered into the current memory cell (IP now wraps to ; on the NE corner)
;   Outputs e
@   Terminates the program

Expand snippet

很高兴您为Needle程序使用了正常的六边形尺寸；当我意识到您可以删除任意数量的字符并且会.在末尾自动用s 填充六边形时，我正在检查大小为19的程序（对于长度为3的侧面六边形），这将大大增加破解难度。实际上，Hexagony是应对这一挑战的一种邪恶语言，因为（大多数情况下）删除的任何字符都会改变程序的整个执行路径。话虽这么说，我还是很乐于尝试解决这个问题，即使我最终最终还是蛮横地强迫了它。:)

— 乔
source

如果我弄乱了/错过了任何东西，请告诉我。

— 乔

做得好，这看起来很准确。我将其与本周末的原始水平进行比较。

— 马丁·恩德

1

Java（OpenJDK 8），151字节

破解凯文·克鲁伊森的答案

v->{String h="H";int x=7;return new String(new byte[]{(byte)((-~-~-~-~-~-~1^x++*x)+15),new Byte("10"+h.length())})+new StringBuffer("elde").reverse();}

在线尝试！

比较：

v->{String h="Haystack";int x=-7;return x<0?h:new String(new java.math.BigInteger(new byte[]{(byte)((~-~-~-~-~-~-~-~-~-~1^-x++*x)+151),new Byte("2"+"1+\"0+\"".length()+(x=h.length()*4/x)+"-x-7")}).toByteArray())+(new StringBuffer("hidden".substring(++x%3^4,--x-x--).replaceFirst("dd","e"+(char)(x*211%+93))).reverse());}
v->{String h="H       ";int x= 7;return       new String(                         new byte[]{(byte)(( -~-~-~-~-~-~      1^ x++*x)+15 ),new Byte("    1   0  "          +   h.length()    )        })               + new StringBuffer("    e                                 l          d    e"      )             .reverse() ;}

我觉得最后一部分不是故意的。

— 雅各布利
source

大声笑，这是制作“雪茄”的聪明方法。在摆弄的同时，我已经以为我做得太多了，解决方案的负载是可能的.. ;;）预期的解决方案是：（

v->{String h="Haystack";int x=7;return new String(new java.math.BigInteger(new byte[]{(byte)((~-~-~-~-~-~-~-~1^-x++*x)+15),new Byte(""+10+((x=h.length()*4/x)+x-7))}).toByteArray())+(new StringBuffer("hidden".substring(++x%3,x).replaceFirst("d","e"+(char)(x*21+3))).reverse());}

不知道为什么我包括BigInteger，因为仅字节数组就足够了..），但我更喜欢您。.:)

— Kevin Cruijssen

1

脑筋急转弯，102字节

(((((((((()()()){}){}){}){}()){}()))()()<>)(()()()){}())<>((()((){}<>)))(({})[(((()()){}())(){}){}()])

破解了H.PWiz的答案。

在线尝试！

((((((((((()()()){}){}()){}){}()){}()))<({}[(()()()()){}])(([[]]({})<>)<>)>((()()())){}{})[()]))<[[]()]>((()){}){}((){}[][(<>){}<>])(<>){}(({}<>()[()])[(((()()()){}<[()]>)<(()){}>{}){}()])
 (((((((((()()()){}){}  ){}){}()){}()))      ()()                   <>)     (()()()) {}    () ) <      >((()      ((){}    <>)     )   )  (({}        )[(((()()  ){}  ()  )  () {}   ){}()])

— 硝化龙
source

1

Ly，21个字节

(78)"e"sl(100)"l"l&o;

在线尝试！

破解了LyricLy的答案。

— 硝化龙
source

1

Java by Johnathan S.

import java.util.*;interface Main{static void main(String[]args){Stack<Hay>s=new Stack();s.add(new Needle());System.out.println(s.get(s.indexOf(new Hay())+1).a);}}class Needle extends Hay{{a="Needle";}}class Hay{String a="Haystack";public boolean equals(Object o){return getClass().equals(o.getClass());}}

二氧化钛

只需删除添加干草的环，除了针头，别无其他。

— 提图斯
source

哈，好人-我实际上并没有想到要简单地删除循环！删除equals方法同样有效。

— Jonathan S.

0

Pyth，21个字节

Kr."Dn2û"2+Kr."EL8"Z

破解这个。

在线尝试！

— 漏尼姑
source

当然好这只是第一次尝试，所以破解相当简单；-)

— Xcoder先生17年

0

T-SQL by phroureo，757字节

seleCT 'Needle'

不知何故，我认为这不是预期的解决方案。使用以下字符{}：

create table a(l int,c int)
in{se}rt into a va{l}u{e}s (1,10),(2,1),(3,8),(4,0)
go
;CREATE FUN{CT}ION b(@ varchar(max)) returns varchar(max) as
begin return{ '}char('+@+'),'''','end 
go
;CREATE FU{N}CTION h(@ varchar(max),@a varchar(max), @b varchar(max), @c varchar(max), @d varchar(max), @e varchar(max), @f varchar(max), @g varchar(max), @h varchar(max))
r{e}turns varchar(max) as 
b{e}gin
return replace(replace(replace(replace(@,@a,@b),@c,@d),@e,@f),@g,@h)
end
{d}ec{l}ar{e} @x varchar(max),@ int=1,@y varchar(99)={'}'
,@D varchar(4)='Ha',@O varchar(4)='ys'
,@T varchar(3)='ta',@A varchar(4)='ck'
WHILE @<=4
BEGIN
set @y+=(SELECT dbo.b(c+100)from a where l=@)+' '
set @+=1
END
SELECT @x='select
left(dbo.h('''+@D+@O+@T+@A+''','+ left(@y,len(@y)-1) +'),char(56))'
execute(@x)

— 罗伯特·弗雷泽
source

0

的PHP

破解泰特斯答案

for($i=1;$c=H_aNyesetdalcek[$i+=2];)echo$c;

在线尝试

— 西纳斯基
source

在干草堆中找到针（强盗）

强盗的挑战

例子

JavaScript，85个字节（ES6）

“针”演示

说明

干草堆，82个字节

Brain-Flak，96字节

哈斯克尔

六边形，17字节，H.PWiz

与原版比较：

可视化：

说明

Python 2，123字节

Javascript，91个字节

果冻，14 字节

Python 2，73个字节

Java（OpenJDK 8），191字节

红宝石，149字节

dc，34个字节

六边形，19字节，马丁·恩德（Martin Ender）

与原版比较

展开代码

Java（OpenJDK 8），151字节

脑筋急转弯，102字节

Ly，21个字节

Java by Johnathan S.

Pyth，21个字节

T-SQL by phroureo，757字节

的PHP