Este es un rompecabezas de policías y ladrones , el hilo de la policía se puede encontrar aquí.

Su tarea será encontrar un anagrama de los programas proporcionados en el hilo de la policía que realiza su inverso izquierdo.

Una vez que descifre una respuesta, publique la solución como respuesta a continuación y notifique al respondedor original.

Te calificarán en la cantidad de programas que seas el primero en descifrar.

Python 3, 46 bytes, Lynn

lambda x0223334566789:(x0223334566789*89)//178

Python 2, 225 bytes, orlp

p=90930641353124136621573325641513715557077985927835294018496194596645372722158;q=101979812089012306249375934082966806799688507587087308196267706260111970225882#--223444799
lambda n:pow(n,pow(65537,(p*q-2*(p+q))/4,p*q),~p*~q)

Supongo que tuve suerte después de adivinar divisores primos aleatorios todo el día ...

^{(El límite de punto de c4.8xlarge predeterminado es 4, pero pude subirlo a 10 el año pasado. Aunque tuve que ajustar la configuración de FAAS de 16 esclavos a 6 (+3 mpi, 1 maestro). 20m polyselect, 12h 50m tamizado, 2h 25m linalg, 30m sqrt. Costo total ~ $ 70. Al menos @orlp fue lo suficientemente agradable como para elegir un tamaño solucionable, ¡pero no lo volveré a hacer! Gracias a @IlmariKaronen por el último paso, y sí, estoy bromeando sobre el adivinando: P)}

Python 2, 83 bytes, orlp

Original:

#((()))****+,,---/2289;==oppppppqqqqqw~~
lambda n:pow(n,65537,10998167423251438693)

Grieta:

p=3207399658;q=3428998126#--11
lambda n:pow(n,pow(65537,(p*q-2*(p+q))/4,p*q),~p*~q)

Pruébalo en línea!

Craqueo de RSA realizado por Wolfram Alpha . ;)

Python 3, 80 bytes, Wolfram

from bisect import*
q=int(input())
print(bisect([(h+1)**2 for h in range(q)],q))

¡Esto fue realmente difícil de descifrar! Yo uso la biblioteca de bisectos , que se incluye en la distribución Python 3. La bisectfunción toma una lista ordenada y un elemento, y devuelve el índice más a la derecha donde el elemento podría insertarse para mantener el orden. Simplemente le damos la qlista de cuadrados a partir de 1y el elemento q.

Javascript, 21 bytes, Arnauld

Original

b=>Math.pow(b,torc=3)

Grieta

o=>Math.cbrt(o,pbw=3)

Devuelve la raíz cúbica.

7, 9 bytes, ais523

00000000: 0173 dc25 7e13 dcb6 1f                   .s.%~....

¡Porque la fuerza bruta siempre gana, y 9! es solo 362880

Processing.js, 59 bytes, Kritixi Lithos

Original:

float igetuwebaoli(int p){return p*(((17*-4*-3)))+0+0;}//,,

Grieta:

int loabewuteg(float p,i){return (i+0**+0,(p/17/(-4*-3)));}

Bueno, eso fue bastante fácil. La parte más difícil fue averiguar dónde colocar las comas y los asteriscos adicionales. Afortunadamente, parece que Processing permite parámetros de funciones adicionales no utilizados, así como expresiones de coma de estilo C.

JavaScript (ES6), 63 bytes, SLuck49

Original:

x=>eval(atob`eCp4KzEvLyAgfXBModLS4TvEn4wp1iys9YRRKC85KLIhNMC=`)

Grieta:

x=>eval(atob`CgpNYXRoLnBvdyh4LTEsMC41KSAvLw4589CEIKKMRefipyz=`)

El código base64 anterior se decodifica para:

Math.pow(x-1,0.5) //...

donde el ... representa un montón de basura aleatoria que es ignorada por el intérprete JS, ya que está en un comentario.

Encontré esta solución por prueba y error. Al final, la única parte realmente difícil fueron las dos nuevas líneas al principio del código, necesarios para hacer la línea resto correctamente y para conseguir la Men Matha base 64 a codificar en algo que estaba disponible en el juego de caracteres originales. Primero probé espacios, pero " M"codifica en base64 "ICBN"y necesitaba el único disponible Bpara codificar ".po"más adelante en el código. "0+M", "1*M", "1?M"O cualquier otro prefijos no-op similares que podría pensar en no funcionó bien, pero los saltos de línea hicieron.

Sospecho que esto puede no ser exactamente la solución prevista, pero lo que sea, funciona. :)

Manifestación:

var f = x=>eval(atob`eCp4KzEvLyAgfXBModLS4TvEn4wp1iys9YRRKC85KLIhNMC=`)
var g = x=>eval(atob`CgpNYXRoLnBvdyh4LTEsMC41KSAvLw4589CEIKKMRefipyz=`)
for (var i = -0; i <= 10; i++) console.log(i, '->', f(i), '->', g(f(i)))

Brain-Flak, 26 bytes, asistente de trigo

Original (agrega 13)

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

Grieta (resta 13)

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

J, 8 bytes, millas

[:]-:[+:

Intercambio simple de +:for -:(doble por la mitad).

Javascript, 15 bytes, insertar nombre de usuario aquí

Original

t=>(!!0+~~t+~0)

Grieta

t=>(~~!!~0+t+0)

Python 2, 47 bytes, asistente de trigo

lambda x:sorted(a**2for a in range(x)).index(x)

JavaScript (ES6), 46 bytes, SLuck49

Original (calcula ln (x + 1))

x=>Math.log(x+(+String(t=985921996597669)[5]))

Grieta

x=>Math[(lg=19979699+55686).toString(9+25)](x)

Nunca habría resuelto esto si no me hubiera dado cuenta de que el inverso es un elemento Mathincorporado . (lg=19979699+55686).toString(9+25)es solo una forma complicada de regresar "expm1".

J, 10 bytes, millas

1%:@*~>:[<

Tengo que escribir algo aquí porque la respuesta es demasiado corta.

J, 29 bytes, Zgarb

Original

5#.[:,(3 5&#:(-$]-)7)#.inv"0]

Grieta

[:(](07-5)"3 #.-:&#$,)5#.inv]

Pruébalo en línea!

Otro equivalente de crack es

[:((3 ]7-5)#.-:&#$,)5#.inv"0]

Explicación

[:(](07-5)"3 #.-:&#$,)5#.inv]  Input: integer n
                            ]  Get n
                      5        The constant 5
                       #.inv   Get the digits of n in base 5
[:(                  )         Operate on those digits D
                    ,            Flatten D (does nothing since it is already a list)
                  #              Get the length of D
               -:&               Halve it
                   $             Reshape D to half its length (only the base 2 digits)
    (07-5)"3                     The constant 2 with rank 3
             #.                  Convert the front-half of D to a decimal from base 2
   ]                             Return the right result