Le fil du voleur est ici

La tâche des flics consiste à écrire une fonction ou un programme qui, lorsqu'il reçoit une entrée de lui-même, génère une chaîne déterministe finie. Si le programme reçoit une entrée différente, il doit renvoyer une sortie différente.

Règles:

• Les soumissions consistent en
  • Nom de la langue
    • Si des drapeaux sont utilisés, ils doivent être révélés.
  • Nombre d'octets du programme
  • Nombre d'octets de sortie
  • Production
    • Si elle est particulièrement longue, veuillez fournir une boîte à pâte ou quelque chose de similaire
    • S'il contient des documents non imprimables, veuillez fournir un hexdump.
    • Les sauts de ligne et les espaces doivent être inclus dans la sortie
  • D'où provient l'entrée (STDIN, ligne de commande, etc. )
• Le cas échéant, vous pouvez supposer que l'octet représentant EOF n'est pas présent dans l'entrée, sauf si vous utilisez cet octet dans votre programme.
• Si votre programme est piraté, ajoutez un lien vers la réponse correspondante dans le fil du voleur dans votre titre.
• Votre programme n'est pas sûr jusqu'à ce qu'une semaine se soit écoulée et vous le marquez ainsi.
• Je désapprouve des techniques telles que l'ensemencement aléatoire avec les fonctions d'entrée ou de hachage cryptographique. Je ne peux pas les arrêter, mais je n'accepterai pas une solution qui utilise l'un ou l'autre . Notez également que certaines de ces techniques peuvent avoir des collisions, où une chaîne différente produit la même sortie.
• Votre objectif est d'avoir la sortie la plus courte. La solution sûre la plus courte publiée dans les trois semaines suivant la publication de cette question gagne!

La tâche du voleur est de trouver un programme de taille égale ou inférieure à l'original, qui obéit également aux règles ci-dessus.

Si un voleur déchire votre programme avec une solution différente de celle prévue, vous avez la possibilité de le «décompresser» en prouvant que la solution du voleur est incorrecte. Vous pouvez le faire en trouvant une entrée dans le programme du voleur qui produira la même sortie.

Exemple de soumission:

brainfuck, 10 octets, score: 10

]<.[<],>[,

Cette solution est , [>,] <[. <] Qui inverse simplement l'entrée

Bonne chance!

7 , 31 caractères, score 30, sûr mais peut-être cassé?

Un programme 7 n'est normalement qu'un nombre, mais il peut contenir des espaces, le divisant en plusieurs nombres. Cette soumission se compose donc de deux nombres (qui sont implicitement concaténés par l'interpréteur 7), et le programme prend également deux nombres en entrée, via une entrée standard. (Les "31 caractères" dans l'en-tête sont la longueur totale des deux nombres, plus un caractère d'espacement séparé; les chiffres qui composent les nombres sont interprétés comme octaux lorsqu'ils sont utilisés comme programme, mais décimaux lorsqu'ils sont utilisés comme entrée, et ce sont les chiffres qui sont les mêmes dans les deux cas, pas les nombres réels. Notez que ce n'est pas pertinent soit lorsqu'il est traité comme un programme, soit lorsqu'il est traité comme une entrée, que vous les sépariez par un espace ou une nouvelle ligne; j'espère que cela ne fonctionne pas ne pas invalider la soumission.)

La sortie attendue est le nombre suivant (exprimé ici en décimal, car c'est le format de sortie utilisé par l'interpréteur 7):

238363505302130098723162537059

Notez que l'interpréteur 7 lié à partir du wiki Esolang stocke en interne les nombres en unaire, ce qui signifie qu'il est peu probable que vous ayez suffisamment de mémoire pour exécuter le programme sur lui-même pour voir ce qu'il fait. J'ai vérifié le programme en travaillant manuellement sur son comportement et en le testant sur de petites entrées pour vérifier qu'il faisait ce que je m'attendais à ce qu'il fasse. Une autre approche serait d'écrire un interpréteur qui utilise une méthode plus efficace de stockage des nombres.

Éviter les fissures ici était quelque chose de pénible, mais je suis enfin convaincu maintenant qu'aucun autre nombre que ceux du programme lui-même n'est capable de produire 238363505302130098723162537059 en sortie. ( MODIFIER 1 semaine plus tard: j'ai peut-être eu tort, selon la façon dont vous interprétez la question; voir ci-dessous. )

Solution

Le programme original était:

711170237403706
111723603700633

Ce programme prend deux nombres $x$ et $y$ et calcule le résultat de l'expression $3xy-y-2$ (c'est-à-dire $y(3x-1)-2$ ). Si nous effectuons ce calcul à $x=711170237403706$ et $y=111723603700633$ , nous obtenons un résultat de $238363505302130098723162537059$ comme requis .

Il était prévu qu'aucune autre entrée ne donne le résultat souhaité car:

L'entrée doit être choisie de telle sorte que $y(3x-1)-2=238363505302130098723162537059$ , c'est-à-dire $y(3x-1)=238363505302130098723162537061$ (en ajoutant 2 des deux côtés). Ce nombre est un semi-premier, avec seulement deux facteurs: $111723603700633$ et $2133510712211117$ . Un seul de ces nombres, $2133510712211117$ , peut être exprimé sous la forme $3x-1$ (donnant $(3 \times 711170237403706)-1=2133510712211117$ ). Nous pouvons donc identifier de manière unique quel nombre est$x$ et lequel est$y$ , ce qui signifie qu'une seule entrée fonctionne.

Cependant, selon la façon dont vous interprétez la question, il peut y avoir une deuxième entrée qui produit la sortie souhaitée (invalidant ainsi cette solution):

$1$$1$$3x-1$$x$$79454501767376699574387512354$$1$$8$$9$) qui ne font pas partie du jeu de caractères pour 7 programmes. Donc, si l'entrée est limitée à être dans le même jeu de caractères que le programme, cette solution est valide; mais si l'entrée contenant des caractères extérieurs au jeu de caractères du programme est autorisée, cette solution n'est pas valide.

Explication

Voici comment fonctionne la solution envisagée:

711170237403706 111723603700633
7 7 7 Séparateurs d'éléments de pile
 111023 403706 111723603700633 Éléments de pile initiaux
 111 numéro 3, en unaire
     023 E / S DSL pour "saisir un numéro"
         403706 111723603700633 Programme principal
(Implicite: exécuter une copie de l'élément principal du programme, en préservant l'original)
         40 Échangez {023} au-dessus de {programme}, en l'échappant
           3 Faites des E / S en utilisant {023}; pop {programme}
     0 E / S: numérique
      23 Entrez un nombre en copiant {111} autant de fois
            706 Ajouter "6" au nombre (en le décrémentant)
                11 Poussez deux éléments de pile vides
                  17236 Pousser un élément de pile "23" (sans échappement)
                       0 Escape {23}, consommant un élément vide
                        3 Faites des E / S en utilisant {23}; pop {l'élément ci-dessous}
                    23 Copiez le haut de la pile d' entrée plusieurs fois
                         7006 Ajouter "66" (c'est-à-dire soustraire 2)
                             3 Sortie {sous forme de nombre}
                              3 Quittez le programme (en raison d'une pile faible)

17066612345$3$$123451234512345$

Node.js v10.9.0 , 40 octets, Score: 40, Cracké

Contribution

Il s'agit d'une fonction prenant exactement un paramètre.

Production

&`nij.9=j.,)r31n=+(=ooj`[o.o.)1.s](>=6>t

Un poirier , 46 octets d'ASCII, score 0, fissuré

L'entrée provient de l'entrée standard. La sortie attendue (sur la sortie standard) est une chaîne vide (c'est-à-dire lorsque le programme se donne lui-même comme argument, aucune sortie ne doit être imprimée).

En d'autres termes, le défi ici est d'écrire un programme A Pear Tree qui ne produit rien sur la sortie standard lorsqu'il est donné sur l'entrée standard, et qui produit quelque chose sur la sortie standard lorsqu'il reçoit autre chose que lui-même sur l'entrée standard, en utilisant no plus de 46 octets. (J'ai réussi à le faire tout en maintenant le programme en ASCII imprimable, malgré un poirier utilisant fréquemment des caractères non ASCII et non imprimables.) C'est effectivement la tâche d'écrire un programme d' auto-identification , avec un format de sortie spécifique (c'est-à-dire chaîne nulle lorsque l'auto-identification réussit); cependant, A Pear Tree a au moins deux rebondissements qui rendent la tâche un peu plus difficile qu'il n'y paraît lorsqu'elle est effectuée dans cette langue spécifique (c'est pourquoi je l'ai choisi pour ma soumission de flic).

Ma solution

Ma solution est un peu différente de la fissure:

eval(k=q(print$\=$_="eval(k=q($k))"ne$_;MZpa))

Essayez-le en ligne!

Au lieu d'utiliser exit, je place à la place $_(sortie implicite) et $\(retour à la ligne après la sortie, y compris la sortie implicite) la chaîne nulle s'il y a correspondance (et 1s'il n'y a pas de correspondance). Un printest toujours requis car la sortie implicite n'est activée que s'il y a au moins un octet d'entrée (donc, nous devons explicitement imprimer quelque chose si on nous donne une chaîne vide en entrée, qui est distincte du programme).

Chaque programme A Pear Tree doit contenir une somme de contrôle quelque part (c'est le cas MZpadans cette solution). Ma solution et le crack choisissent les noms de variables (et varient d'autres détails mineurs du code) afin que la somme de contrôle soit entièrement composée de lettres ASCII.

Perl 5 -p0777, 10 octets, score 10, sûr

W)9r46<(k

Le dernier caractère ici est "shift out", code de caractère 14 (décimal) / 0E (hex). Tous les autres sont imprimables en ASCII.

Parce que nous utilisons l'argument d'E / S implicite de Perl -p0777, l'entrée provient de l'entrée standard et la sortie va vers la sortie standard.

Solution

Le programme fait ce qui suit:

NUL remplit l'entrée avec au moins 10 caractères, puis XOR avec la chaîne svgOUT_TOP

ce qui signifie que le programme lui-même, la seule entrée produisant la sortie souhaitée, est:

$ _ ^ = abc | $ ^

Essayez-le en ligne!

Explication

Perl a un certain nombre de variables spéciales. Par exemple, lors de l'utilisation -p0777pour les E / S implicites, $_est entrée au début du programme et sortie à la fin du programme.

La plupart de ces variables ont une valeur par défaut très simple. Cependant, la valeur par défaut de $^, le format de haut de page actuellement sélectionné, est la chaîne beaucoup plus longue STDOUT_TOP. En tant que tel, nous pouvons l'utiliser comme une méthode d'obscurcissement très concise via XORing $^avec la valeur que nous voulons obscurcir (dans ce cas, le programme).

Afin de cacher le témoin _TOPà la fin, j'ai complété le programme lui-même à 10 caractères via l'ajout d'un abc|, ce qui signifie que tous les caractères de STDOUT_TOPseraient XOR avec quelque chose; abc|au début, le choix était un moyen facile de garder la sortie principalement imprimable (et de rendre plus difficile à repérer que j'étais XORing avec une chaîne composée principalement de majuscules, car en ASCII, XOR majuscule en minuscule est en minuscule).

Python 3, 50 octets craqués

Entrée et sortie de / vers stdin / -out. La sortie est différente pour chaque entrée différente. Sortie unique avec le code source:

218216195196222130136136132192197195196130241204136209197216206130201131244155157154215136138204197216138201138195196138195196218223222130131247131131

(C'est 150 chiffres)

Bonne chance!

05AB1E , 35 octets, score: 7

Entrée:
Destdin

Production:
QÕ Ƿe

Cubix , 18 octets, Score 18, sûr

C'est dommage que ce défi n'ait pas attiré plus d'attention, mais c'est parfois ainsi que cela se passe. J'allais laisser cela dangereux, mais j'ai décidé de publier la solution avant de l'oublier.

Cela devrait être assez facile à casser.

Entrée destdin

Production

$`*2aJPJ#74(o);89

Edit: je dois mentionner que cela attend la source dans sa forme raccourcie ... et maintenant j'ai remarqué qu'il y a un octet manquant (non imprimable) du résultat que j'ai cassé quand j'ai posté. Devrait copier maintenant. Les valeurs hexadécimales sont24 60 2a 13 32 61 4a 50 4a 23 37 34 28 6f 29 3b 38 39

Le concept était de supprimer l'impression du premier caractère, puis de supprimer l'index inverse du caractère, par exemple [chars] - [0, len ([chars]) .. 2]

Le code est

$r;#AoW\U-@</u.?;;

qui correspond au cube suivant

    $ r
    ; #
A o W \ U - @ <
/ u . ? ; ; . .
    . .
    . .

Essayez-le ici

Gelée , 14 octets, score: 21, sûr

Le programme et la taille de sortie sont comptés à l'aide de la page de codes Jelly.

Contribution

Premier argument de ligne de commande.

Production

-§ḋẇ"*YdĖDƘ>Ẉed€Ç+æạɦ

Solution

ØJiⱮÄÆNPḃØ⁵ịØJ

Essayez-le en ligne!

JavaScript Firefox, <10 octets, score: 52, à partir de l'entrée d'argument de fonction, fissuré

ZnVuY3Rpb24gYnRvYSgpIHsKICAgIFtuYXRpdmUgY29kZV0KfQ==


btoa

btoa(btoa) code la chaîne suivante:

function btoa() {
    [native code]
}

qui donne:

"ZnVuY3Rpb24gYnRvYSgpIHsKICAgIFtuYXRpdmUgY29kZV0KfQ=="

_{juste copié}

GCC 61-> 61 octets

70 4F 92 73 08 D4 03 E7 65 DC D6 89 B5 AD BA 90 
97 26 31 10 F6 FA 0A 30 8F 24 69 0A A7 8B 59 9E 
A2 42 D5 67 B8 12 3A 1E 9D 25 80 F9 6B 25 32 C2 
EE 46 3F 8D 7E 0C 73 0F F0 93 C6 68 50

Programme complet, prendre l'entrée de stdin et la sortie vers stdout

Perl 6, 43 bytes, Score: 15, from stdin

49671296789805

Pepe , 23 octets, score: 23, craqué par MickyT

Contribution:

la norme

Production:

RDCbn@?K]<[G98765TSR^PO

J , 26 octets, score: 52, sûr

Le programme n'est pas un REPL, mais un script complet qui accepte stdinet imprime explicitement dansstdout .

Contribution

Entrée standard.

Production

6fc42353c98217ef5a2908a3c63d090aa9a55b2558b61294e06a

Non, ce n'est pas une méthode de cryptage.

Solution

echo]hfd]257x#.3&u:stdin''
                   stdin'' Take the whole input
               3&u:        Convert to codepoints
         257x#.     Convert base 257 to integer
     hfd]           "Hex from Decimal"
echo]               Print to stdout

Essayez-le en ligne!

Keg , 6 octets, score: 6

Contribution

De stdin, en utilisant?

Production

5\x1c"\x1c"9

Rappelez-vous que ce sont des séquences d'échappement pour les octets non imprimables. Remplacez les échappements par les caractères littéraux. Texte brut disponible ici

Bonne chance avec celui-ci! A la semaine prochaine!

 Perl 6, 31 bytes, Score: 39, from stdin - Cracké

Craqué ici

().1111111111112222235abcegijkmnorstvy

Solution brute. Pourrait survivre.