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

Su tarea será dos escribir dos programas (o funciones) de modo que sean anagramas entre sí y uno realice el inverso izquierdo del otro. Estos programas pueden aceptar y generar tantos números enteros o números complejos como desee. Si elige tomar los números como puntos de carácter o cualquier otro medio razonable, debe indicar que lo está haciendo en su respuesta. Si elige restringir el dominio de su función, también debe indicar el dominio restringido en su respuesta.

Luego presentará el primer programa en forma de una respuesta con el inverso izquierdo oculto para que los ladrones lo encuentren.

El programa que se muestra debe implementar una función inyectiva (de lo contrario, sería imposible que exista una respuesta oculta).

Si su respuesta no se ha descifrado en una semana, puede revelar la respuesta oculta y marcarla como segura . Los ladrones no pueden descifrar respuestas seguras y permanecerán sin descifrar indefinidamente.

El objetivo será crear la respuesta sin descifrar más corta en bytes.

Ejemplo

Puede mostrar el siguiente programa de Python que agrega uno a la entrada

lambda x:~-x

Una solución podría ser:

lambda x:-~x

Esto resta uno de la entrada

Python 3, 80 bytes ( agrietado )

bhmq = int(input())
print(bhmq ** 2)
(1 or [(sqrt),(specification+of*integerr)])

Dominio: enteros positivos. La función es solo cuadrar un número. Entrada a stdin, salida a stdout, así como en la función inversa. Tenga en cuenta que Python ignora la tercera línea aquí, porque es sintácticamente válida y 1 ya es un valor verdadero, por lo que Python ni siquiera mira si la parte correcta de 'o' está bien definida.

Los ladrones deben escribir una función sqrt que funcione correctamente en todos los cuadrados que no sean cero, imprimiendo el valor entero tal cual, sin coma flotante (por lo tanto, la entrada '4' salida debe ser '2' o '2 \ n', no '2.0' o '2.0 \ n').

Python 3, 46 bytes, agrietado

lambda x:x*(1999888577766665//844333333222200)

Duplica la entrada.

7 7 , 9 bytes, agrietado

Este programa está lleno de caracteres no imprimibles, así que aquí hay un hexdump:

00000000: 2573 dc01 7e13 dcb6 1f                   %s..~....

Nota: esto utiliza una rutina de entrada numérica que es incapaz de ingresar números negativos, por lo que este envío está restringido solo a enteros no negativos.

Un problema con policías y ladrones desafíos de es que no escribes explicaciones del código (para que sea más difícil de descifrar). Por otro lado, esto significa que no tengo que preocuparme aquí.

Elegí 7 como idioma porque, especialmente en su notación comprimida, es bastante difícil de leer, y no veo por qué debería ser solo yo quien tiene que molestarse en mover trozos de programas de 8 bits escritos en Una codificación de 3 bits. ¡Buena suerte!

Explicación

Ahora que el programa ha sido descifrado (por fuerza bruta, desafortunadamente; eso siempre es un peligro en estas soluciones cortas), también podría explicar a qué me estaba refiriendo. Esto fue en realidad bastante solucionable leyendo el programa; Podría haberlo hecho mucho más difícil, pero me pareció una mala idea cuando existen grietas por fuerza bruta.

Comenzaremos representando el programa en una codificación más natural. Como de costumbre, los números en negrita indican comandos que se ejecutan inmediatamente (no todos son representables en un programa; 6y 7son pero2 a 5no lo son), los números representan unbolded sus equivalentes escapado ( 0a 5, todos los cuales son representables en el programa original; nota eso 0es un escape 6y 1es un escape 7):

112 7 1 7 34002 77 023 67 13303

El conjunto de comandos disponibles en una fuente de 7 programas significa que es básicamente un literal que representa la pila original (no hay nada más que pueda hacer con los comandos que se escapan 6y 7). Entonces, lo primero que hará un programa es empujar un montón de cosas a la pila. Así se ve la pila después de la ejecución del programa ( |separa los elementos de la pila, como es habitual en 7):

772 | 7 | 34662 | 023 | 73363

El elemento final de la pila se copia para convertirse en el código a ejecutar (mientras permanece en la pila). Resulta que esta es la única parte del programa que es código; todo lo demás son solo datos. Esto es a lo que se traduce:

73363 
7       Empuje un elemento vacío en la pila
  3      Imprima el elemento superior de la pila, descarte el elemento inferior
 73      Efecto combinado de estos: descarte el elemento superior de la pila
   de     la pila superior 3 Genere el de la pila superior, descarte el elemento de abajo
    6    Escape del elemento de la pila superior, luego añádelo al elemento a continuación
     3   Imprime el elemento de pila superior, descarta el elemento a continuación

En otras palabras, esto es principalmente un montón de instrucciones de E / S. Analicemos esto en detalle:

• 73descarta el 73363que todavía está en la parte superior de la pila.
• 3genera el 023, y descarta el 34662. Por lo tanto, se puede ver que el34662 es un comentario, que se utilizó para almacenar los bytes necesarios en la otra versión del programa. En cuanto a lo que 023hace cuando sale, selecciona el formato de E / S 0 (enteros), luego 23es una directiva que solicita la implementación para ingresar un entero (en 7, ingresa a través de la salida de códigos específicos que solicitan entrada). La entrada se realiza haciendo copias del elemento de pila a continuación, por ejemplo, si el entero de entrada es 10, el siguiente elemento de pila (actualmente 7) se convertirá 7777777777. Por lo tanto, estamos aceptando la entrada del usuario en decimal, pero se está almacenando como unario.
• 6 escapa al elemento de la pila superior (cambiando cada instancia de 7 a 1; así es como las cadenas consisten completamente en7 se escapan las s), luego lo agrega al elemento de pila antes ( 772). Entonces nuestros datos ahora son algo así como7721111111111 .
• Finalmente, 3genera el elemento de pila en cuestión (y muestra un elemento de pila en blanco que forma parte de la pila inicial predeterminada). Su valor se calcula tomando el número de 1sy7 s, y restando el número de 0s y 6s. (El 2medio se ignora en la mayoría de los casos; si está al final de la cadena, se convertirá en una nueva línea final en lugar de ignorarse, pero las reglas PPCG no se preocupan por eso). Por lo tanto, el resultado es el original entrada más 2.

En este punto, no hay nada útil en la pila y nada en el programa, por lo que el programa se cierra.

¿Cómo revertimos esto? Es una simple cuestión de cambiar el 11a 00, de modo que estamos anteponiendo caracteres a la entrada que lo hacen 2 más bajo, en lugar de 2 más alto. Hay unos 00ocho dígitos octales convenientemente ocultos más adelante en el programa (para que los dígitos octales y los bytes se alineen entre sí), por lo que simplemente podemos intercambiarlo con el 11al comienzo.

JavaScript (ES6), 21 bytes, Agrietado

Esta es una fácil.

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

Devuelve el cubo de la entrada.

Python 2, 83 bytes, agrietado

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

Esto es similar a mi otra respuesta. Sin embargo, esto usa RSA de 64 bits y es criptográficamente bastante débil. Si puedes robar esta respuesta, teóricamente puedes robar mi otra también, con tiempo suficiente.

Python 2, 47 bytes, Agrietado

lambda x:x**2or (iron() and saxifrage.extend())

El dominio para esta función es {x ∈ ℤ | x> 0}. Cuadra su entrada.

nmjcman101 encontró la solución deseada:

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

JavaScript (ES6), 46 bytes, Agrietado

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

Esta función devuelve ln(x+1)donde xes un número no negativo.

Uso

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

Nota: Debido a la naturaleza de los números de coma flotante, es f(g(x))posible que no sean exactamente iguales x. Ejemplo:f(g(4))=3.9999999999999996

J, 8 bytes, agrietados

Otro simple para comenzar.

[:]+:[-:

Duplica la entrada.

Processing.js, 59 bytes, ¡Agrietado!

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

Esta función multiplica la entrada por 204( 17*-4*-3=204). Toma un int como entrada y genera un flotante. Como se esperaba, el inverso divide la entrada por 204.

Puede encontrar un intérprete en línea para Processing-js aquí .

J, 10 bytes, agrietados

1%~<:[@*>:

Otro simple. Devuelve n ² -1.

JavaScript (ES6), 15 bytes, descifrado por Emigna

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

Esta función vuelve n-1.

Puedes probarlo como:

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

Agrietado

Mi solución prevista es un poco diferente al crack de Emigna:

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

J , 29 bytes ( agrietado por millas)

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

Este es un verbo que toma un entero positivo como entrada y hace lo siguiente:

1. Convierte a las bases 2 y 4.
2. Rellene la representación de base 4 con 0 para tener la misma longitud que la representación de base 2.
3. Concatenar las dos representaciones (base-2 primero).
4. Interprete la concatenación como una representación de base 5 y convierta a entero.

Pruébalo en línea!

Mi solución

La lógica es más o menos la misma que en el crack. La conjunción de rango "se puede atascar en muchos lugares diferentes (y la uso para eliminar lo innecesario 0y 3), ya que en realidad no hace nada en la solución.

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

Procesamiento (java), 59 bytes, SEGURO

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

Esta función multiplica la entrada por 204( 17*-4*-3=204). Toma un int como entrada y genera un flotante. Como se esperaba, el inverso divide la entrada por204 . Nota: ambos programas toman un int como entrada y salida como flotante.

Esta respuesta es exactamente la misma que mi otra respuesta, excepto que mi otra respuesta fue escrita en Processing.js. Conozca Processing-java, el primo menos detallado de Java. Puede descargar Processing aquí en processing.org.

La grieta

float ap(int i){return i*pow(blue(get(0,0)),-1);}//++7*4*-3

Este programa divide el argumento entre 204. ¿Pero cómo? Entremos en la función.

i *                              //multiply i by
         blue( get(0, 0) )       //this (evaluates to 204)
    pow(                  , -1)  //raises to the -1 power (ie its reciprocal)

Bastante simple, pero ¿cómo se blue( get(0, 0) )convierte 204? Esta es la pieza central de esta presentación. En primer lugar, get(0,0)obtiene el color del píxel ubicado en (0,0)(la esquina superior izquierda de la ventana, que siempre se abre en un boceto de procesamiento). A continuación, blue()obtiene el valor azul de ese píxel, que es204 !

Para llegar a esta presentación, experimenté imprimiendo los diferentes atributos del color obtenido por get(0,0). He descubierto que los rojos, verde, azul, valores alfa son 204, 204, 204y 255respectivamente. A partir de esto, decidí hacer una operación simple con este número y terminé con esta publicación.

JavaScript (ES6), 63 bytes descifrado por Ilmari Karonen

x=>eval(atob`eCp4KzEvLyAgfXBModLS4TvEn4wp1iys9YRRKC85KLIhNMC=`)

Tiempo para algunos atob tontos. Esta función devuelve x*x+1dondex es un número no negativo.

Uso

(x=>eval(atob`eCp4KzEvLyAgfXBModLS4TvEn4wp1iys9YRRKC85KLIhNMC=`))(5)

Destinado a

x=>eval(atob`Lyp5fMRwICAgKi9NYXRoLnBvdyh4LTEsMC41KS8veCp4KzE=`)

Hay una gran cantidad de posibles soluciones, pero esperaba que los personajes principales desecharan el orden de bytes lo suficiente como para hacer esto más difícil. C'est laatob

Brain-Flak , 26 bytes, agrietado

Original

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

Mi grieta

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

Grieta de 1000000000

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

Python 2, 225 bytes, descifrado por Sp3000

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

El dominio de esta función es [0, n), donde n es el gran número anterior. Sí, esta función es invertible en este dominio. Y a menos que me equivoque, romper esta respuesta es tan difícil como romper el RSA de 512 bits.

J, 15 bytes

(".&,'10.')#.#:

Toma un número entero no negativo n , lo convierte en una lista de dígitos binarios y combina esos dígitos como un número base 10.

Pruébalo en línea!