Это менты-и-разбойники головоломка нить разбойников можно найти здесь .

Ваша задача состоит в том, чтобы написать две программы (или функции) так, чтобы они представляли собой анаграммы друг друга, и одна из них выполняет левую инверсию другой. Эти программы могут принимать и выводить столько целых или комплексных чисел, сколько вы пожелаете. Если вы выбираете брать числа в качестве символов или любым другим разумным способом, вы должны указать, что делаете это в своем ответе. Если вы решите ограничить домен вашей функции, вы также должны указать ограниченный домен в своем ответе.

Затем вы представите первую программу в форме ответа с скрытым слева, чтобы грабители могли его найти.

Показанная программа должна реализовывать инъективную функцию (иначе скрытый ответ был бы невозможен).

Если ваш ответ не был взломан в течение одной недели, вы можете открыть скрытый ответ и пометить его как безопасный . Безопасные ответы не могут быть взломаны грабителями и останутся без взлома бесконечно.

Целью будет создание кратчайшего неоткрытого ответа в байтах.

пример

Вы можете показать следующую программу на Python, которая добавляет одну к входу

lambda x:~-x

Решение может быть:

lambda x:-~x

Это вычитает один из входных

Python 3, 80 байт ( треснувший )

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

Домен: положительные целые числа. Функция - это просто квадрат числа. Ввод в stdin, вывод в stdout, а также в обратную функцию. Обратите внимание, что Python здесь игнорирует третью строку, потому что она синтаксически действительна, а 1 уже является истинным значением, поэтому Python даже не смотрит, правильно ли определена правая часть «или».

Грабители должны написать функцию sqrt, которая будет работать корректно на всех ненулевых квадратах, печатая целочисленное значение как есть, без плавающей запятой (поэтому при вводе '4' вывод должен быть '2' или '2 \ n', а не '2.0' или '2.0 \ n').

Python 3, 46 байт, взломан

lambda x:x*(1999888577766665//844333333222200)

Удваивает ввод.

7 , 9 байт, трещины

Эта программа полна непечатаемых символов, поэтому вот hexdump:

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

Примечание: при этом используется процедура ввода чисел, которая не может вводить отрицательные числа, поэтому эта отправка ограничена только неотрицательными целыми числами.

Одна из проблем, с которыми сталкиваются полицейские и грабители, заключается в том, что вы не пишете объяснения кода (чтобы его было сложнее взломать). С другой стороны, это означает, что мне здесь не нужно беспокоиться.

Я выбрал 7 в качестве языка, потому что, особенно в сжатом виде, его довольно сложно читать, и я не понимаю, почему это должен быть только я должен идти по пути перемещения по 8-битным фрагментам программ, написанных на 3-х битная кодировка. Удачи!

объяснение

Теперь, когда программа взломана (к сожалению, грубой силой; в этих коротких решениях это всегда опасно), я могу также объяснить, к чему я стремился. Это было на самом деле довольно решаемо, читая программу; Я мог бы сделать это намного сложнее, но это казалось плохой идеей, когда существуют грубые трещины.

Начнем с представления программы в более естественной кодировке. Как обычно, полужирный цифры показывают команды , которые выполняются немедленно (не все из которых представима в программе, 6и 7являются , но 2для 5не являются), unbolded числа представляют их уцелевшие эквиваленты ( 0к 5, все из которых представима в исходной программе, к сведению что 0сбежал 6и 1сбежал7 ):

112 7 1 7 34002 77 023 67 13303

Набор команд, доступных в программном источнике 7, означает, что это в основном просто литерал, представляющий исходный стек (больше ничего вы не можете сделать с помощью только экранированных команд 6и 7). Итак, первое, что сделает программа, это поместит кучу вещей в стек. Вот как выглядит стек после запуска программы ( |разделяет элементы стека, как обычно в 7):

772 | 7 | 34662 | 023 | 73363

Последний элемент стека затем копируется, чтобы стать кодом для запуска (оставаясь в стеке). Как это бывает, это единственная часть программы, которая является кодом; все остальное - просто данные. Вот что это переводит на:

73363 
7 Поместите       пустой элемент в стек.
  3      Выведите верхний элемент стека, отбросьте элемент ниже.
 73      Совокупный эффект: отбросьте верхний элемент стека.
   3     Выведите верхний элемент стека, отбросьте элемент ниже.
    6    Сбросьте верхний элемент стека, затем добавьте его к элементу ниже
     3   Выведите верхний элемент стека, отбросьте элемент ниже

Другими словами, это в основном просто набор инструкций ввода / вывода. Давайте проанализируем это подробно:

• 73сбрасывает 73363это все еще на вершине стека.
• 3выводит 023и отбрасывает 34662. Таким образом, можно видеть, что 34662это комментарий, который использовался для хранения байтов, необходимых в другой версии программы. Что касается того, что 023происходит при выводе, он выбирает формат ввода / вывода 0 (целые числа), а затем 23является директивой, которая запрашивает реализацию для ввода целого числа (в 7 вы вводите с помощью вывода определенных кодов, которые запрашивают ввод). Ввод осуществляется путем создания копий элемента стека, указанного ниже, например, если целое число ввода равно 10, следующий элемент стека (в настоящее время 7) станет 7777777777. Таким образом, мы принимаем ввод от пользователя в десятичном виде, но он сохраняется как унарный.
• 6экранирует верхний элемент стека (изменяя каждый экземпляр 7на 1; таким образом 7экранируются строки, состоящие полностью из s), затем добавляет его к элементу стека before ( 772). Таким образом, наши данные теперь что-то вроде 7721111111111.
• Наконец, 3выводит соответствующий элемент стека (и выводит пустой элемент стека, который является частью начального стека по умолчанию). Его значение рассчитывается путем взятия числа 1s и 7s и вычитания числа 0s и 6s. ( 2Посередине в большинстве случаев игнорируется; если он находится в конце строки, он будет становиться завершающим символом новой строки вместо того, чтобы игнорироваться, но правила PPCG не заботятся об этом.) Таким образом, вывод является исходным вход плюс 2.

На данный момент в стеке нет ничего полезного и ничего в программе, поэтому программа завершается.

Как мы можем изменить это? Это простой вопрос об изменении 11в 00, так что мы добавляем символы на входе , которые делают его 2 ниже, а не 2 выше. Там в 00удобно скрытые восемь восьмеричных цифр далее в программе (так что восьмеричные цифры и байты выстраиваются друг с другом), поэтому мы просто не можем поменять его с 11самого начала.

JavaScript (ES6), 21 bytes, Cracked

This is an easy one.

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

Returns the cube of the input.

Python 2, 83 bytes, cracked

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

This is similar to my other answer. However, this uses 64-bit RSA, and is cryptographically quite weak. If you can rob this answer, you can theoretically rob my other one as well, given enough time.

Python 2, 47 bytes, Cracked

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

The domain for this function is {x ∈ ℤ | x > 0}. It squares its input.

nmjcman101 found the intended solution:

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

JavaScript (ES6), 46 bytes, Cracked

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

This function returns ln(x+1) where x is a non-negative number.

Usage

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

Note: Due to the nature of floating point numbers f(g(x)) may not exactly equal x. Example: f(g(4))=3.9999999999999996

J, 8 bytes, cracked

Another simple one to start off with.

[:]+:[-:

Doubles the input.

Processing.js, 59 bytes, Cracked!

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

This function multiplies the input by 204 (17*-4*-3=204). It takes in an int as input and outputs a float. As expected, the inverse divides the input by 204.

An online interpreter for processing-js can be found here.

J, 10 bytes, cracked

1%~<:[@*>:

Another simple one. Returns n²-1.

JavaScript (ES6), 15 bytes, cracked by Emigna

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

This functions returns n-1.

You can test it like:

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

Cracked

My intended solution is a bit different than Emigna's crack:

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

J, 29 bytes (Cracked by miles)

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

This is a verb that takes a positive integer as input, and does the following:

1. Convert to bases 2 and 4.
2. Pad the base-4 representation with 0s to have the same length as the base-2 representation.
3. Concatenate the two representations (base-2 first).
4. Interpret the concatenation as a base-5 representation and convert to integer.

Try it online!

My solution

The logic is pretty much the same as in the crack. The rank conjunction " can be stuck in many different places (and I use it to get rid of the unnecessary 0 and 3), since it doesn't really do anything in the solution.

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

Processing (java), 59 bytes, SAFE

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

This function multiplies the input by 204 (17*-4*-3=204). It takes in an int as input and outputs a float. As expected, the inverse divides the input by 204. Note: both programs take an int as input and output a float.

This answer is exactly the same as my other answer, except that my other answer was written in Processing.js. Meet Processing-java, the less verbose cousin of Java. You can download Processing here at processing.org.

The Crack

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

This program divides the argument by 204. But how? Let's go inside the function.

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

Simple enough, but how does blue( get(0, 0) ) become 204? This is the centrepiece of this submission. First of all, get(0,0) gets the colour of the pixel located at (0,0) (the top left corner of the window, which always opens in a Processing sketch). Next, blue() gets the blue value of that pixel, which is 204!

To come up with this submission, I experimented by printing the different attributes of the colour obtained by get(0,0). I have found out that the red, green, blue, alpha values are 204, 204, 204 and 255 respectively. From this, I decided to do a simple operation with this number and ended up with this post.

JavaScript (ES6), 63 bytes Cracked by Ilmari Karonen

x=>eval(atob`eCp4KzEvLyAgfXBModLS4TvEn4wp1iys9YRRKC85KLIhNMC=`)

Time for some atob nonesense. This function returns x*x+1 where x is a non-negative number.

Usage

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

Intended

x=>eval(atob`Lyp5fMRwICAgKi9NYXRoLnBvdyh4LTEsMC41KS8veCp4KzE=`)

There's a large number of potential solutions, but I was hoping that the leading characters would throw off the byte order enough to make this harder. C'est la atob

Brain-Flak, 26 bytes, Cracked

Original

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

My Crack

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

1000000000's Crack

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

Python 2, 225 bytes, cracked by Sp3000

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

Domain of this function is [0, n), where n is the huge number above. Yes, this function is invertible on this domain. And unless I messed up, breaking this answer is as hard as breaking 512 bit RSA.

J, 15 bytes

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

Takes a non-negative integer n, converts it to a list of binary digits, and combines those digits as a base 10 number.

Try it online!