Encuentra la aguja en el pajar (ladrones)

18

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.

code-golf  source-layout  cops-and-robbers 
— Martin Ender
fuente
Si hashing, encryption or random number generationse permite el uso de ladrones (aunque la posibilidad es pequeña)
— l4m2

Respuestas:

11

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"

Mostrar fragmento de código

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.

— ShreevatsaR
fuente
5

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:   ([((((()()())){}){}){}](() [()]   ({}([ (((()()()){})) []])[]({}({}     ()(  ((()(({}){}){}){}){}())))[]              ))   ()  )
— Nitrodon
fuente
Estaba seguro de que iba a terminar como este
— H.PWiz
Eso ciertamente funciona , pero de alguna manera me convencí de que Nera 77 en lugar de 78, así que no lo entendí.
— Nitrodon
El tuyo es más corto de todos modos.
— H.PWiz
¡Solución interesante! Agregué mi solución prevista a la publicación original si desea verla.
— Wheat Wizard
5

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.

— nimi
fuente
5

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!

Caminos de colores

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 .
Caminos de colores 2
\_]
_\]c
e@

— boboquack
fuente
¡Agradable! Esa fue la solución prevista.
— H.PWiz
4

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.

— jacobly
fuente
¡Guauu! ¡Gran trabajo! No esperaba que se rompiera tan pronto.
— agtoever
Originalmente desarrollado el reto basado en numpy 1.13, que no he encontrado en cualquier entorno repl, así que tuve que volver a escribir para numpy 1.12 ... ;-)
— agtoever
2

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.

— jacobly
fuente
Exactamente el que tenía en mente Nebbed+ rublesin ninguno de rub.
— Jonathan Allan
2

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.

— Leche
fuente
2

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'
— cab404
fuente
2

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
— en cualquier lugar
fuente
gg! Sabía que poner tantos números era una mala idea)
— cab404
@ cab404 Por curiosidad: ¿utilizó un cálculo muy diferente para llegar a 86197399743589?
— 2017
— cab404
Guau. Eso es notable Esa podría ser otra pregunta de codegolf: ¿de cuántas maneras hay para obtener un cierto resultado eliminando caracteres en una expresión ...
— Hasta el
supongo que por lo general requeriría un poco de matemática seria para calcular todas las posibilidades y demostrar que sólo hay ese número de ellos)
— cab404
2

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

Mostrar fragmento de código

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

— Jo
fuente
Si me he equivocado / perdido algo, por favor hágamelo saber.
— Jo.
Buen trabajo, esto se ve bastante preciso. Lo compararé con lo que tuve originalmente durante el fin de semana.
— Martin Ender
1

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.

— jacobly
fuente
Lol ok, esa es una forma inteligente de hacer "edle". Mientras jugueteaba, ya pensaba que hice un poco demasiado y que sería posible un montón de soluciones ...;) La solución prevista era: 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());}(no sé por qué he incluido el BigInteger, ya que solo byte-array es suficiente ...) , pero me gusta más el tuyo .. :)
— Kevin Cruijssen
1

Brain-Flak , 102 bytes

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

Rompe la respuesta de H.PWiz .

Pruébalo en línea!

((((((((((()()()){}){}()){}){}()){}()))<({}[(()()()()){}])(([[]]({})<>)<>)>((()()())){}{})[()]))<[[]()]>((()){}){}((){}[][(<>){}<>])(<>){}(({}<>()[()])[(((()()()){}<[()]>)<(()){}>{}){}()])
 (((((((((()()()){}){}  ){}){}()){}()))      ()()                   <>)     (()()()) {}    () ) <      >((()      ((){}    <>)     )   )  (({}        )[(((()()  ){}  ()  )  () {}   ){}()])
— Nitrodon
fuente
1

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.

— Tito
fuente
Ja, agradable, ¡en realidad no había pensado en simplemente eliminar el bucle! Eliminar el equalsmétodo funciona igual de bien.
— Jonathan S.
0

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)
— Robert Fraser
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.