Encontre a agulha no palheiro (ladrões)

18

Isso faz parte de um desafio de . 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.

Martin Ender
fonte
Se o uso ladrão hashing, encryption or random number generationé permitido (embora possibilidade minúscula)?
l4m2

Respostas:

11

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"

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.

ShreevatsaR
fonte
5

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!

fireflame241
fonte
1
Agradável! Do jeito que eu o configurei, minha solução original foi literalmente remover 0o princípio: P Bom ver outra abordagem! +1
HyperNeutrino 07/10
5

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:   ([((((()()())){}){}){}](() [()]   ({}([ (((()()()){})) []])[]({}({}     ()(  ((()(({}){}){}){}){}())))[]              ))   ()  )
Nitrodon
fonte
Eu tinha certeza que ele iria acabar como este
H.PWiz
Isso certamente funciona , mas de alguma maneira me convenci de que Ntinha 77 em vez de 78, então não entendi.
Nitrodon 7/10
O seu é mais curto de qualquer maneira.
H.PWiz
Solução interessante! Adicionei minha solução pretendida à postagem original, se você quiser vê-la.
Wheat Wizard
5

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.

nimi
fonte
5

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!

Caminhos coloridos

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 .
Caminhos coloridos 2
\_]
_\]c
e@

boboquack
fonte
Agradável! Essa foi a solução pretendida.
H.PWiz
4

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.

jacobly
fonte
Uau! Bom trabalho! Eu não esperava que fosse quebrado tão cedo.
agtoever
I originalmente desenvolvido o desafio baseado em numpy 1,13, o que eu não encontrei em qualquer ambiente repl, então eu tive que reescrevê-lo para numpy 1,12 ... ;-)
agtoever
2

Javascript, 91 bytes

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

Racha isso . Na verdade, foi divertido.

meu pronome é monicareinstate
fonte
2

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.

jacobly
fonte
Exatamente o que eu tinha em mente Nebbed+ rublesem nenhum rub.
Jonathan Allan
2

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.

leite
fonte
2

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'
cab404
fonte
2

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
de qualquer maneira
fonte
gg! Eu sabia que colocar esse tanto números foi uma má idéia)
cab404
@ cab404 Apenas curioso: você usou um cálculo muito diferente para obter o 86197399743589?
agtoever
Sim, é muito mais longo #
cab404 11/11
Uau. Isso é notável. Isso poderia ser uma outra questão codegolf: quantas maneiras existem para obter um determinado resultado por exclusão de caracteres em uma expressão ...
agtoever
eu acho que, em geral, exigem um pouco de matemática séria para calcular todos os posibilities e provar que há apenas esse número deles)
cab404
2

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

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. :)

Jo.
fonte
Se eu errei / perdi alguma coisa, entre em contato.
Jo.
Bom trabalho, isso parece bastante preciso. Vou comparar com o que eu tinha originalmente no fim de semana.
Martin Ender
1

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.

jacobly
fonte
Lol ok, essa é uma maneira inteligente de fazer "edle". Enquanto brincava, já pensei que fiz um pouco demais e seria possível um monte de soluções ..;) A solução pretendida foi: 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());}(não sei por que incluí o BigInteger, já que apenas a matriz de bytes é suficiente ..) , mas como o seu melhor .. :)
Kevin Cruijssen
1

Flak cerebral , 102 bytes

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

Racha a resposta de H.PWiz .

Experimente online!

((((((((((()()()){}){}()){}){}()){}()))<({}[(()()()()){}])(([[]]({})<>)<>)>((()()())){}{})[()]))<[[]()]>((()){}){}((){}[][(<>){}<>])(<>){}(({}<>()[()])[(((()()()){}<[()]>)<(()){}>{}){}()])
 (((((((((()()()){}){}  ){}){}()){}()))      ()()                   <>)     (()()()) {}    () ) <      >((()      ((){}    <>)     )   )  (({}        )[(((()()  ){}  ()  )  () {}   ){}()])
Nitrodon
fonte
1

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.

Titus
fonte
Ah, legal - eu não tinha pensado em simplesmente remover o laço! A remoção do equalsmétodo também funciona.
Jonathan S.
0

Pitão , 21 bytes

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

quebra isso .

Experimente online!

Freira Furada
fonte
Claro, legal. Foi apenas uma primeira tentativa, então o crack era bastante trivial ;-)
Mr. Xcoder
0

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)
Robert Fraser
fonte