Ceci est un casse - tête flics-and-robbers le fil des voleurs peut être trouvé ici .

Votre tâche sera deux écrivez deux programmes (ou fonctions) tels qu’ils sont des anagrammes les uns des autres et l’un effectue l’ inverse gauche de l’autre. Ces programmes peuvent accepter et sortir autant d’ entiers que de nombres complexes que vous le souhaitez. Si vous choisissez de prendre les chiffres comme points de caractère ou tout autre moyen raisonnable, vous devez indiquer que vous le faites dans votre réponse. Si vous choisissez de restreindre le domaine de votre fonction, vous devez également indiquer le domaine restreint dans votre réponse.

Vous présenterez ensuite le premier programme sous la forme d'une réponse avec l'inverse gauche caché pour que les voleurs le trouvent.

Le programme montré doit implémenter une fonction injective (sinon, il serait impossible qu'une réponse cachée existe).

Si votre réponse n'a pas été fissurée en une semaine, vous pouvez révéler la réponse cachée et la marquer comme étant sûre . Des réponses sûres ne peuvent pas être craquées par des voleurs et resteront indéfiniment indéchiffrables.

L'objectif sera de créer la réponse la plus courte non fissurée en octets.

Exemple

Vous pouvez afficher le programme python suivant qui en ajoute un à l’entrée

lambda x:~-x

Une solution pourrait être:

lambda x:-~x

Ceci soustrait un de l’entrée

Python 3, 80 octets ( fissuré )

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

Domaine: entiers positifs. La fonction est juste la quadrature d'un nombre. Entrée sur stdin, sortie sur stdout, ainsi que dans la fonction inverse. Notez que Python ignore la troisième ligne ici, car elle est syntaxiquement valide et 1 est déjà une valeur de vérité, de sorte que Python ne regarde même pas si la partie droite de 'ou' est bien définie.

Les voleurs doivent écrire une fonction sqrt qui fonctionnera correctement sur tous les carrés non nuls, en affichant la valeur entière telle quelle, sans virgule flottante (ainsi, l'entrée "4" devrait être "2" ou "2 \ n", et non "2.0" ou '2.0 \ n').

Python 3, 46 octets, fissuré

lambda x:x*(1999888577766665//844333333222200)

Double l'entrée.

7 , 9 octets, fissuré

Ce programme est plein de caractères non imprimables, alors voici un hexdump:

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

Remarque: ceci utilise une routine de saisie numérique incapable de saisir des nombres négatifs. Cette soumission est donc limitée aux entiers non négatifs uniquement.

Un problème avec les problèmes des flics et des voleurs est que vous n'écrivez pas d'explication du code (pour le rendre plus difficile à résoudre). D'un autre côté, cela signifie que je n'ai pas à me préoccuper de la situation.

J'ai choisi 7 comme langage parce que, surtout dans sa notation comprimée, il est assez difficile à lire, et je ne vois pas pourquoi ce devrait être seulement moi qui dois prendre la peine de déplacer des morceaux de programmes 8 bits écrits en un encodage à 3 bits. Bonne chance!

Explication

Maintenant que le programme a été fissuré (par force brutale, malheureusement, cela reste toujours un danger pour ces solutions courtes), je pourrais aussi bien expliquer ce à quoi je voulais en venir. C'était en fait assez soluble en lisant le programme; J'aurais pu rendre les choses beaucoup plus difficiles, mais cela semblait être une mauvaise idée lorsqu'il existe des fissures par force brute.

Nous allons commencer par représenter le programme dans un encodage plus naturel. Comme d' habitude, les chiffres indiquent les commandes bolded maintenant (pas tous qui sont représentables dans un programme, 6et 7sont , mais 2à 5ne sont pas), le nombre unbolded représentent leurs équivalents échappées ( 0à 5, qui sont tous représentables dans le programme original; note c'est 0un évadé 6et 1un évadé 7):

112 7 1 7 34002 77 023 67 13303

L'ensemble des commandes disponibles dans une source de programme 7 signifie qu'il ne s'agit en fait que d'un littéral représentant la pile d'origine (vous ne pouvez rien faire d'autre avec des commandes échappées, 6et 7). Donc, la première chose qu'un programme fera est de mettre un tas de choses sur la pile. Voici à quoi ressemble la pile après l'exécution du programme ( |sépare les éléments de la pile, comme d'habitude dans 7):

772 | 7 | 34662 | 023 | 73363

Le dernier élément de la pile est ensuite copié pour devenir le code à exécuter (tout en restant sur la pile). En l’occurrence, c’est la seule partie du programme qui soit codée; tout le reste n'est que des données. Voici ce que cela traduit:

73363 
7       Poussez un élément vide sur la pile
  3      Sortez l'élément de pile supérieur, jetez l'élément inférieur à
 73      Effet combiné de ceux-ci: éliminez l'élément de pile supérieur
   3     Sortez l'élément de pile supérieur, jetez l'élément inférieur
    6    Échappez l'élément de pile supérieur, puis l'ajouter à l'élément ci-dessous
     3   Sortez l'élément de pile supérieur, supprimez l'élément ci-dessous

En d'autres termes, il ne s'agit généralement que d'un ensemble d'instructions d'E / S. Analysons cela en détail:

• 73élimine le 73363qui est toujours sur la pile.
• 3sort le 023et jette le 34662. On voit donc qu'il 34662s'agit d'un commentaire qui a été utilisé pour stocker les octets nécessaires dans l'autre version du programme. Pour ce 023qui est de la sortie, il sélectionne le format d'E / S 0 (nombres entiers), puis 23une directive qui demande à l'implémentation de saisir un entier (en 7, vous saisissez via la sortie des codes spécifiques qui demandent une entrée). L’entrée est réalisée en faisant des copies de l’élément de pile ci-dessous, par exemple si le nombre entier saisi est 10, l’élément de pile suivant (actuellement 7) deviendra 7777777777. Ainsi, nous acceptons les entrées de l’utilisateur en décimal, mais elles sont stockées de manière unaire.
• 6échappe à l'élément de pile supérieur (en changeant chaque instance de 7en 1; c'est comment les chaînes composées entièrement de 7s sont échappées), puis l'ajoute à l'élément de pile avant ( 772). Donc, nos données sont maintenant quelque chose comme 7721111111111.
• Pour finir, 3affiche l’élément de pile en question (et affiche un élément de pile vide faisant partie de la pile initiale par défaut). Sa valeur est calculée en prenant le nombre de 1s et 7s et en soustrayant le nombre de 0s et 6s. (Le 2dans le milieu est ignoré dans la plupart des cas; s'il se trouve à la fin de la chaîne, il deviendra un saut de ligne au lieu d'être ignoré, mais les règles PPCG ne s'en soucient pas.) Ainsi, la sortie est l'original. entrée plus 2.

À ce stade, il n'y a rien d'utile sur la pile et rien dans le programme, donc le programme se ferme.

Comment inversons-nous cela? Il suffit de changer le 11pour 00, de sorte que nous ajoutons des caractères à l'entrée, ce qui le rend 2 plus bas, plutôt que 2 plus élevés. Il y a 00huit chiffres octaux cachés plus loin dans le programme (de manière à ce que les chiffres octaux et les octets soient alignés), afin que nous puissions simplement les échanger avec 11le début.

JavaScript (ES6), 21 octets, fissuré

C'est facile.

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

Retourne le cube de l'entrée.

Python 2, 83 octets, fissuré

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

Ceci est similaire à mon autre réponse. Cependant, cela utilise RSA 64 bits et est cryptographiquement assez faible. Si vous pouvez dérober cette réponse, vous pouvez théoriquement dérober mon autre aussi, avec suffisamment de temps.

Python 2, 47 octets, fissuré

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

Le domaine pour cette fonction est {x ℤ | x> 0}. Il place son entrée.

nmjcman101 a trouvé la solution envisagée:

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

JavaScript (ES6), 46 octets, fissuré

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

Cette fonction renvoie ln(x+1)où xest un nombre non négatif.

Usage

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

Remarque: en raison de la nature des nombres en virgule flottante, les nombres f(g(x))peuvent ne pas être exactement identiques x. Exemple:f(g(4))=3.9999999999999996

J, 8 octets, fissuré

Un autre simple pour commencer.

[:]+:[-:

Double l'entrée.

Processing.js, 59 octets, fissuré!

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

Cette fonction multiplie l'entrée par 204( 17*-4*-3=204). Il prend un int en entrée et génère un float. Comme prévu, l'inverse divise l'entrée en 204.

Un interprète en ligne pour processing-js peut être trouvé ici .

J, 10 octets, fissuré

1%~<:[@*>:

Un autre simple. Retourne n ² -1.

JavaScript (ES6), 15 octets, fissuré par Emigna

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

Cette fonction retourne n-1.

Vous pouvez le tester comme:

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

Fissuré

Ma solution envisagée est un peu différente de la fissure d'Emigna:

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

J , 29 octets ( fissuré par miles)

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

Ceci est un verbe qui prend un entier positif en entrée et fait ce qui suit:

1. Convertir aux bases 2 et 4.
2. Tapotez la représentation en base 4 avec des 0 pour avoir la même longueur que la représentation en base 2.
3. Concaténer les deux représentations (en base 2 en premier).
4. Interprétez la concaténation en tant que représentation en base 5 et convertissez-la en entier.

Essayez-le en ligne!

Ma solution

La logique est à peu près la même que dans la fissure. La conjonction de rang "peut être bloquée dans de nombreux endroits différents (et je l'utilise pour me débarrasser de l'inutile 0et 3), car elle ne fait vraiment rien dans la solution.

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

Traitement (java), 59 octets, SAFE

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

Cette fonction multiplie l'entrée par 204( 17*-4*-3=204). Il prend un int en entrée et génère un float. Comme prévu, l'inverse divise l'entrée en 204. Remarque: les deux programmes prennent un int en entrée et en sortie un float.

Cette réponse est exactement la même que mon autre réponse, sauf que mon autre réponse a été écrite dans Processing.js. Faites connaissance avec Processing-java, le cousin le moins bavard de Java. Vous pouvez télécharger Processing ici sur processing.org.

Le crack

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

Ce programme divise l'argument par 204. Mais comment? Allons à l'intérieur de la fonction.

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

Assez simple, mais comment blue( get(0, 0) )devient-il 204? Ceci est la pièce maîtresse de cette soumission. Tout d’abord, get(0,0)obtient la couleur du pixel situé en (0,0)(le coin supérieur gauche de la fenêtre, qui s’ouvre toujours dans une esquisse en cours de traitement). Ensuite, blue()obtient la valeur bleue de ce pixel, qui est 204!

Pour arriver à cette soumission, j'ai expérimenté en imprimant les différents attributs de la couleur obtenue par get(0,0). Je l' ai découvert que le rouge, vert, bleu, les valeurs alpha sont 204, 204, 204et 255respectivement. De là, j'ai décidé de faire une opération simple avec ce numéro et j'ai fini avec ce post.

JavaScript (ES6), 63 octets fissuré par Ilmari Karonen

x=>eval(atob`eCp4KzEvLyAgfXBModLS4TvEn4wp1iys9YRRKC85KLIhNMC=`)

Temps pour un non atobsens. Cette fonction renvoie x*x+1où xest un nombre non négatif.

Usage

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

Prévu

x=>eval(atob`Lyp5fMRwICAgKi9NYXRoLnBvdyh4LTEsMC41KS8veCp4KzE=`)

Il y a un grand nombre de solutions potentielles, mais j'espérais que les personnages principaux se débarrasseraient de l'ordre des octets pour rendre cela plus difficile. C'est laatob

Brain-Flak , 26 octets, fissuré

Original

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

Mon crack

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

Crack de 1000000000

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

Python 2, 225 octets, fissuré par Sp3000

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

Le domaine de cette fonction est [0, n), où n est le nombre énorme ci-dessus. Oui, cette fonction est inversible sur ce domaine. Et à moins que je ne me trompe, briser cette réponse est aussi difficile que casser RSA 512 bits.

J, 15 octets

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

Prend un entier non négatif n , le convertit en une liste de chiffres binaires et combine ces chiffres en un nombre de base 10.

Essayez-le en ligne!