Isso faz parte de um desafio de policiais e ladrões . Vá aqui para a parte da polícia.

O desafio dos ladrões

A resposta de um policial pode ser quebrada removendo qualquer subconjunto de caracteres do programa Haystack, para que ele seja exibido em Needlevez de Haystack(embora ainda seja um envio válido no mesmo idioma). Você não precisa encontrar exatamente a mesma solução que o policial pretendia, desde que a sua seja válida pelas restrições acima.

Se você conseguir isso, poste uma resposta com a solução, vinculando-a à resposta do policial e deixe um comentário sobre a resposta do policial voltando para a sua.

O ladrão que consegue mais respostas policiais ganha. Os laços são quebrados pela soma dos tamanhos das respostas dos policiais rachados (a favor do ladrão que racha envios mais longos).

Cada resposta policial pode ser quebrada apenas uma vez e, é claro, você não tem permissão para quebrar sua própria resposta. Se a resposta do policial for inválida antes ou depois de ser quebrada, ela não será contabilizada na pontuação do ladrão.

Exemplos

Aqui estão alguns exemplos simples em diferentes idiomas:

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]

Observe que o subconjunto de caracteres removidos não precisa ser contíguo.

JavaScript, 85 bytes (ES6)

Racha a resposta de Arnauld

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

Demonstração "Needle"

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

console.log(f())

Explicação

A função original era:

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

que é mais legível como:

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';
        }
    }
}

Note que quando n=21625674, então n.toString(35)é 'eedle'.

Os 35 na entrada provavelmente não podem ser alterados para um subconjunto (porque queremos uma base grande o suficiente para conter todas as letras 'del', portanto, precisamos de uma base com pelo menos 22). Assim, os números para mudar são 74837258394056219, 268435455e 124038877. Queremos substituí-los pelos números a, b, c, cada um formado por um subconjunto dos dígitos dos números originais, de modo que a função g(k) = (k * a & b), iniciando k=35e iterando 35 vezes, e depois XORed com c, dê 21625674.

Para este, depois de pensar um pouco, como os comprimentos são pequenos (a máxima atem comprimento 17, be ctem comprimento 9), a utilizado de força bruta :-) escreveu programa um C ++ para gerar todos os números possíveis a, b, cformado como subconjuntos dos números originais, itere por todos ae be verifique se o necessário cestava no conjunto. É executado em cerca de 15 segundos, e a única saída é a=4853461, b=268435455, c=12408877(se torna o número bnão precisa ser alterado). Não tenho certeza se existe uma maneira mais inteligente de inverter esta função.

Palheiro , 82 bytes

Rachaduras na resposta do 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

Experimente online!

Brain-Flak , 96 bytes

Racha a resposta do homem Funky do computador .

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

Experimente online!

Este foi um desafio divertido.

A -24 no início que converte ya ano original é agora usado para converter ea M, que é então convertido Nno lugar, alterando todo o ciclo final para ()). A primeira letra enviada kfoi alterada para esimplesmente removendo um clique que adiciona 6 a ela. O resto simplesmente se encaixou, com alguns erros humorísticos ao longo do caminho (incluindo um programa cuja saída foi Meddle).

Comparação dos dois programas:

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

Haskell

Racha a resposta de Laikoni .

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

Experimente online!

Código original:

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"

substituindo caracteres removidos por sublinhados:

___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____"

Como Needleé construído: a sequência no final do código é dividida em palavras. O primeiro caractere de cada palavra é incrementado quantas vezes houver caracteres na palavra, por exemplo Haysta- -> Hmais 6 caracteres -> N.

Hexagonia , 17 bytes, H.PWiz

]; N @ cl; e ;; (\. S.; _

Experimente online!

Comparação com o original:

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

Visualização:

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

Explicação

Marcas de bônus - usa todos os 6 IPs e todas, exceto uma das células!

O IP # 0 começa indo direto ao longo do caminho preto para o ].
Em seguida, fazemos a transição para o IP nº 1, que segue pelo caminho vermelho, imprimindo Ne N;depois retornando ao ]novo.
Em seguida, fazemos a transição para o IP # 2, que segue pelo caminho azul, armazenando ena célula de memória atual e depois pelo caminho verde, executando (com um reflexo em \) ;;(;que imprime ee, diminui a célula de memória epara ddepois imprime d.
O IP continua no caminho laranja, executando as Nl;seimpressões le os armazenamentos ena célula de memória atual. Ela continua ao longo do caminho castanha, a impressão do ecom;. A essa altura, já imprimimos Needle, então o resto está apenas terminando. O IP é armazenado e c, em seguida, acessado ]. Em seguida, fazemos a transição para o IP # 3, que segue pelo caminho azul, atingindo , saltando para o qual entra . Em seguida, fazemos a transição para o IP # 4, que segue pelo caminho verde, saltando e depois ramificando para (já que é positivo). Por fim, fazemos a transição para o IP nº 5, que armazena e sai com .

\_]
_\]c
e@

Python 2 , 123 bytes

Rachaduras Resposta de 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))])

repl.it

Comparação:

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  ))])

Eu me diverti muito encontrando soluções que imprimiam Meedlee Needlfajustando um polinômio à mediana dos índices dos símbolos numpy que começam com cada uma das letras Needle. Tentei então encontrar coeficientes similares com subconjuntos do programa original manualmente, mas acabei tendo que recorrer à força bruta, forçando alguém a encontrar uma solução válida.

Javascript, 91 bytes

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

Racha isso . Na verdade, foi divertido.

let f =

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

console.log(f())

Gelatina , 14 bytes

Rachaduras Resposta de Jonathan Allan

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

Experimente online!

Comparação:

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

Eu costumava œcpercorrer vários subconjuntos de cadeias literais, usados tr -dpara cada filtro possível e grepeditados para Needle. Usando a suposição de que nenhum dos caracteres usados ​​na primeira sequência foi usado na resposta, deixe-o encontrar uma resposta em menos de 15 segundos.

Python 2 , 73 bytes

Racha a resposta do user71546 .

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

Experimente online!

Resolvido com este programa.

Java (OpenJDK 8), 191 bytes

Racha a resposta de Luke Steven

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;}

Experimente online!

Caracteres excluídos:

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

Isso faz davaliar para 078101101100108101, que feitiços Needle.

Ruby , 149 bytes

Rachaduras: /codegolf//a/144790/74216

O módulo era bem pequeno, então escrevi uma coisa de aniversário com vários tópicos e esperei o melhor.

Edit: E depois disso encontrei uma resposta ainda mais curta.

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

Experimente online!

Alterar:

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'

dc , 34 bytes

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

Racha isso . TIO .

Comecei obtendo a representação numérica do Haystack (5215583380252484459) e Needle (86197399743589). Em seguida, fiz uma fatoração deste último, que é 47 * 432323 * 4242169. A partir disso, foi bastante fácil reconstruir esses números.

Marcando os caracteres usados:

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

Hexagonia , 19 bytes, Martin Ender

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

Experimente online!

Comparação com original

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

Código desdobrado

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

Então, eu nunca escrevi nada em Hexagony, mas imaginei com apenas 37 bytes que eu poderia criar o crack. Martin, espero que saiba que dediquei muito tempo a tentar descobrir isso. :)

Posso estar incorreto, mas explicarei o que esse código está fazendo:

O programa inicia com [, que se move automaticamente para o IP nº 5. Esse IP começa no canto oeste, em direção ao [mais uma vez, que o move para o IP # 4. A partir daqui, ele executa, em N;eseguida, segue para o canto sudeste e executa ;, salta para a direita para outro e ;depois para o (qual diminui a corrente epara a d. Em seguida, ele continua (com uma quebra automática) para ...;.saltar para le chegar à [última vez, passando para o IP nº 3. Ele executa ;, >redireciona para o noroeste e .depois <para o oeste, atingindo e, quebrando ;e terminando no @.

Versão detalhada

[   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

Estou tão feliz que você tenha usado um tamanho normal de hexágono para o programa Needle; Eu estava checando os programas de tamanho 19 (para um hexágono lateral com comprimento 3) quando percebi que era possível remover qualquer número de caracteres e ele preenchia automaticamente o hexágono com .s no final, o que tornaria muito mais difícil de decifrar. Assim, o Hexagony é uma linguagem maligna para esse desafio, porque (principalmente) qualquer caractere removido é alterado por todo o caminho de execução do programa. Dito isto, eu gostei de tentar chegar a isso, mesmo que eu acabasse sendo forçado no final. :)

Java (OpenJDK 8) , 151 bytes

Rachaduras Resposta de Kevin Cruijssen

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();}

Experimente online!

Comparação:

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() ;}

Eu sinto que a última parte não foi intencional.

Flak cerebral , 102 bytes

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

Racha a resposta de H.PWiz .

Experimente online!

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

Ly , 21 bytes

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

Experimente online!

Racha a resposta de LyricLy .

Java por 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());}}

TiO

Simplesmente remova o laço que adiciona o Hay e nada ficará na pilha além da agulha.

Pitão , 21 bytes

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

quebra isso .

Experimente online!

T-SQL por phroureo , 757 bytes

seleCT 'Needle'

De alguma forma, não acho que essa foi a solução pretendida. Usa os caracteres cercados por {}:

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)

PHP

Rachaduras Titus resposta

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

Experimente online