Esto es parte de un desafío de policías y ladrones . Ve aquí por la parte de la policía.

El desafío de los ladrones

La respuesta de un policía se puede descifrar eliminando cualquier subconjunto de caracteres del programa Haystack, de modo que salga en Needlelugar de Haystack(mientras sigue siendo un envío válido en el mismo idioma). No tiene que encontrar exactamente la misma solución que el policía pretendía, siempre que la suya sea válida según las restricciones anteriores.

Si logra esto, publique una respuesta con la solución, vinculando la respuesta del policía, y deje un comentario sobre la respuesta del policía vinculando la suya.

El ladrón que descifra la mayor cantidad de respuestas de policías gana. Los empates se rompen por la suma de los tamaños de las respuestas de los policías descifrados (a favor del ladrón que descifra los envíos más largos).

Cada respuesta de policía solo se puede descifrar una vez y, por supuesto, no puedes descifrar tu propia respuesta. Si la respuesta del policía resulta ser inválida antes o después de ser descifrada, no se cuenta para el puntaje del ladrón.

Ejemplos

Aquí hay un par de ejemplos simples en 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]

Tenga en cuenta que el subconjunto de caracteres eliminados no tiene que ser contiguo.

JavaScript, 85 bytes (ES6)

Rompe la respuesta de Arnauld

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

Demo de "aguja"

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

console.log(f())

Explicación

La función original era:

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

que es más legible 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';
        }
    }
}

Tenga en cuenta que cuando n=21625674, entonces n.toString(35)es 'eedle'.

El 35 en la entrada probablemente no se puede cambiar a un subconjunto (porque queremos una base lo suficientemente grande como para contener todas las letras 'del', por lo que necesitamos una base que sea al menos 22). Así que los números al cambio son 74837258394056219, 268435455y 124038877. Queremos reemplazarlos con los números a, b, c, cada uno formado con un subconjunto de los dígitos de los números originales, de modo que la función g(k) = (k * a & b), comenzando k=35e iterada 35 veces, y luego XORed con c, dé 21625674.

Para éste, después de pensar un poco, ya que las longitudes son pequeñas (el máximo atiene una longitud 17, by ctener una longitud 9), acabo de utilizar fuerza bruta :-) Escrito un programa en C ++ para generar todos los números posibles a, b, cformado como subconjuntos de los números originales, repita todo ay b, y verifique si el requerido cestaba en el conjunto. Se ejecuta en unos 15 segundos, y la única salida es a=4853461, b=268435455, c=12408877(resulta que el número bno tiene que ser cambiado). No estoy seguro de si hay una forma más inteligente de invertir esta función.

Pajar , 82 bytes

Cracks La respuesta de 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

Pruébalo en línea!

Brain-Flak , 96 bytes

Cracks Funky Computer La respuesta del hombre .

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

Pruébalo en línea!

Este fue un desafío divertido.

El -24 al principio que convierte ya aen el original es ahora utilizado para convertir ea M, que se convierte a continuación Nen el lugar por el cambio de todo el bucle final a ()). La primera letra empujada kse cambió a esimplemente eliminando un push-pop que le agrega 6. El resto en su mayoría simplemente cayó en su lugar, con algunos errores humorísticos en el camino (incluido un programa cuyo resultado fue Meddle).

Comparación de los dos programas:

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

Haskell

Cracks @ Laikoni responde .

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

Pruébalo en línea!

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"

Reemplazar los caracteres eliminados con guiones bajos:

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

Cómo Needlese construye: la cadena al final del código se divide en palabras. El primer carácter de cada palabra se incrementa tantas veces como haya caracteres en la palabra, por ejemplo, Haysta-> Hmás 6 caracteres -> N.

Hexagonía , 17 bytes, H.PWiz

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

Pruébalo en línea!

Comparación con el original:

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

Visualización:

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

Explicación

Marcas de bonificación: ¡utiliza las 6 IP y todas las celdas menos una!

La IP # 0 comienza dirigiéndose a lo largo del camino negro hacia el ].
Luego pasamos a IP # 1, que se dirige a lo largo del camino rojo, imprimiendo Ny N;luego volviendo a envolverlo ]nuevamente.
Luego pasamos a IP # 2, que se dirige a lo largo del camino azul, almacenando een la celda de memoria actual, luego a lo largo del camino verde, ejecutando (con un reflejo en \) ;;(;que imprime ee, disminuye la celda de memoria epara dluego imprimir d.
La IP continúa a lo largo del camino naranja, ejecutando lo Nl;seque imprime ly almacena een la celda de memoria actual. Continúa por el camino marrón, imprimiendo econ;. En este punto ya hemos impreso Needle, por lo que el resto está por terminar. La IP almacena c, luego golpea ]. Luego hacemos la transición a IP # 3, que se dirige a lo largo del camino azul, golpeando , rebotando en el que rebota . Luego hacemos la transición a IP # 4, que se dirige a lo largo del camino verde, rebotando y luego ramificándose a (ya que es positivo). Finalmente, hacemos la transición a IP # 5, que almacena y luego sale con .

\_]
_\]c
e@

Python 2 , 123 bytes

Cracks agtoever's Answer

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

Comparación:

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

Me divertí mucho buscando soluciones que imprimieran Meedley Needlfajustando un polinomio a la mediana de los índices de los símbolos numpy que comienzan con cada una de las letras Needle. Luego intenté encontrar coeficientes similares con subconjuntos del programa original a mano, pero terminé teniendo que recurrir a la fuerza bruta para encontrar una solución válida.

Javascript, 91 bytes

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

Rompe esto . En realidad fue divertido.

let f =

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

console.log(f())

Jalea , 14 bytes

Cracks La respuesta de Jonathan Allan

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

Pruébalo en línea!

Comparación:

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

Solía œciterar a través de varios subconjuntos de cadenas literales, utilizado tr -dpara cada filtro posible, y greped para Needle. Suponiendo que ninguno de los caracteres utilizados en la primera cadena se utilizó en la respuesta, le permite encontrar una respuesta en menos de 15 segundos.

Python 2 , 73 bytes

Cracks La respuesta del usuario71546 .

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

Pruébalo en línea!

Resuelto con este programa.

Java (OpenJDK 8), 191 bytes

Rompe la respuesta 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;}

Pruébalo en línea!

Caracteres eliminados:

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

Esto hace devaluar a 078101101100108101, que hechizos Needle.

Ruby , 149 bytes

Rompe esto: /codegolf//a/144790/74216

El módulo era bastante pequeño, así que escribí un artículo de cumpleaños con varios subprocesos y esperé lo mejor.

Editar: Y después de eso encontró una respuesta aún más corta.

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

Pruébalo en línea!

Cambios:

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'

cc , 34 bytes

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

Rompe esto . TIO .

Comencé obteniendo la representación numérica de Haystack (5215583380252484459) y Needle (86197399743589). A continuación, hice una factorización de este último, que es 47 * 432323 * 4242169. A partir de esto, fue bastante fácil reconstruir esos números.

Marcado de los caracteres utilizados:

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

Hexagonía , 19 bytes, Martin Ender

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

Pruébalo en línea!

Comparación con el original

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

Código desplegado

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

Entonces, nunca he escrito nada en Hexagony, pero pensé que con solo 37 bytes podría encontrar el crack. Martin, espero que sepas que dediqué mucho tiempo a tratar de resolver esto. :)

Puede que sea incorrecto, pero explicaré lo que creo que está haciendo este código:

El programa comienza con [, que automáticamente pasa a IP # 5. Esta IP comienza en la esquina oeste, en dirección a la [una vez más, que la mueve a la IP # 4. A partir de aquí, se ejecuta, N;eluego se dirige a la esquina sureste y se ejecuta ;, rebota hacia la derecha para otro, ;luego se envuelve, lo (que disminuye la corriente ea a d. Luego continúa (con una envoltura) para ...;.luego rebotar ly llegar a la [última vez, moviéndose a IP # 3. Se ejecuta ;, >redirige al noroeste para .luego <redirigir al oeste, golpeando e, envolviendo ;y terminando en el @.

Versión detallada

[   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

Estoy muy contento de que haya utilizado un tamaño de hexágono normal para el programa Needle; Estaba comprobando programas de tamaño 19 (para un hexágono lateral de longitud 3) cuando me di cuenta de que podía eliminar cualquier número de caracteres y automáticamente llenaría el hexágono con .s al final, lo que haría que sea mucho más difícil de descifrar. Tal como están las cosas, Hexagony es un lenguaje maligno para este desafío porque (en su mayoría) cualquier personaje que se elimine cambia toda la ruta de ejecución del programa. Dicho esto, disfruté tratando de llegar a esto, incluso si terminé por obligarlo al final. :)

Java (OpenJDK 8) , 151 bytes

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

Pruébalo en línea!

Comparación:

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

Siento que la última parte no fue pensada.

Brain-Flak , 102 bytes

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

Rompe la respuesta de H.PWiz .

Pruébalo en línea!

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

Ly , 21 bytes

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

Pruébalo en línea!

Rompe la respuesta de LyricLy .

Java de 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

Simplemente quite el lazo que agrega el heno y no quedará nada en la pila excepto la aguja.

Pyth , 21 bytes

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

resuelve esto .

Pruébalo en línea!

T-SQL por phroureo , 757 bytes

seleCT 'Needle'

De alguna manera, no creo que esa sea la solución prevista. Utiliza los personajes rodeados 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

Grietas Titus respuesta

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

Pruébalo en línea