Соревнование

Простая задача «шпион против шпиона».

Напишите программу со следующими характеристиками:

1. Программа может быть написана на любом языке, но не должна превышать 512 символов (как представлено в блоке кода на этом сайте).
2. Программа должна принимать 5 знаковых 32-битных целых в качестве входных данных. Он может принимать форму функции, которая принимает 5 аргументов, функции, которая принимает один массив из 5 элементов, или полной программы, которая считывает 5 целых чисел из любого стандартного ввода.
3. Программа должна вывести одно 32-разрядное целое число со знаком.
4. Программа должна возвращать 1 в том и только в том случае, если пять входов, интерпретируемых как последовательность, соответствуют определенной арифметической последовательности по выбору программиста, называемой «ключом». Функция должна возвращать 0 для всех остальных входов.

Арифметическая последовательность обладает тем свойством, что каждый последующий элемент последовательности равен своему предшественнику плюс некоторая фиксированная константа a.

Например, 25 30 35 40 45является арифметической последовательностью, поскольку каждый элемент последовательности равен его предшественнику плюс 5. Аналогично, 17 10 3 -4 -11это арифметическая последовательность, поскольку каждый элемент равен его предшественнику плюс -7.

Последовательности 1 2 4 8 16и 3 9 15 6 12не являются арифметическими последовательностями.

Ключом может быть любая арифметическая последовательность по вашему выбору, с единственным ограничением, что последовательности с целочисленным переполнением не допускаются. То есть последовательность должна строго увеличиваться, строго уменьшаться или иметь все элементы равными.

В качестве примера предположим, что вы выбрали ключ 98021 93880 89739 85598 81457. Ваша программа должна вернуть 1, если входы (последовательно) соответствуют этим пяти числам, и 0 в противном случае.

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

Скоринг

Самые короткие не взломанные представления на количество персонажей будут объявлены победителями.

Если есть путаница, пожалуйста, не стесняйтесь спрашивать или комментировать.

Встречный вызов

Всем читателям, включая тех, кто представил свои собственные программы, предлагается «взломать» материалы. Отправка взламывается, когда ее ключ публикуется в соответствующем разделе комментариев. Если представление сохраняется в течение 72 часов без изменения или взлома, оно считается «безопасным» и любой последующий успех в взломе будет проигнорирован ради контеста.

См. «Отказ от ответственности» ниже для получения подробной информации об обновленной политике оценки взлома.

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

Взломщики с наивысшим количеством баллов будут объявлены победителями вместе с разработчиками победивших программ.

Пожалуйста, не взламывайте ваши собственные представления.

Удачи. :)

Leaderboard

Предпоследний зачет (в ожидании безопасности представления Дениса CJam 49).

Безопасные шкафчики

1. CJam 49, Деннис
2. CJam 62, Денис Сейф
3. CJam 91, сейф Денниса
4. Питон 156, Maarten Baert сейф
5. Perl 256, безопасный для чилимагов
6. Java 468, Geobits безопасно

Неостановимые крекеры

1. Питер Тейлор [Ruby 130, Java 342, Mathematica 146 *, Mathematica 72 *, CJam 37]
2. Деннис [Pyth 13, Python 86 *, Lua 105 *, GolfScript 116, C 239 *]
3. Мартин Бюттнер [Javascript 125, Python 128 *, Ruby 175 *, Ruby 249 *]
4. Тийло [C 459, Javascript 958 *]
5. Фреддиекнец [Mathematica 67 *]
6. Илмари Каронен [Python27 182 *]
7. закись азота [C 212 *]

* несоответствующая подача

Отказ от ответственности (Обновлено 23:15 EST, 26 августа)

Когда проблемы с оценками наконец достигли критической массы (учитывая, что две трети взломанных представлений пока не соответствуют), я оценил лучшие взломщики с точки зрения количества взломанных отправлений (основной) и общего количества символов в совместимых взломанных отправках. (вторичные).

Как и прежде, точные данные о взломе, длительность представлений и их статус соответствия / несоответствия помечены так, чтобы читатели могли сделать вывод о своих собственных рейтингах, если они считают, что новые официальные рейтинги несправедливы.

Приношу свои извинения за внесение изменений в правила в конце игры.

CJam, 62 символа

"ḡꬼ쏉壥떨ሤ뭦㪐ꍡ㡩折量ⶌ팭뭲䯬ꀫ郯⛅彨ꄇ벍起ឣ莨ຉᆞ涁呢鲒찜⋙韪鰴ꟓ䘦쥆疭ⶊ凃揭"2G#b129b:c~

Stack Exchange склонен к обработке непечатаемых символов, но копирование кода из этой вставки и вставка его в интерпретатор CJam прекрасно работает для меня.

Как это работает

После замены строки Unicode строкой ASCII выполняется следующий код:

" Push 85, read the integers from STDIN and collect everything in an array.               ";

85l~]

" Convert the array of base 4**17 digits into and array of base 2 digits.                 ";

4H#b2b

" Split into chunks of length 93 and 84.                                                  ";

93/~

" Do the following 611 times:

    * Rotate array A (93 elements) and B one element to the left.
    * B[83] ^= B[14]
    * T = B[83]
    * B[83] ^= B[0] & B[1] ^ A[23]
    * A[92] ^= A[26]
    * Rotate T ^ A[92] below the arrays.
    * A[92] ^= A[0] & A[1] ^ B[5].                                                        ";

{(X$E=^:T1$2<:&^2$24=^+\(1$26=^_T^@@1$2<:&^3$5=^+@}611*

" Discard the arrays and collects the last 177 generated bits into an array.              ";

;;]434>

" Convert the into an integer and check if the result is 922 ... 593.                     ";

2b9229084211442676863661078230267436345695618217593=

Этот подход использует Bivium-B (см. Алгебраический анализ тривиумоподобных шифров ), ослабленную версию потокового шифра Trivium .

Программа использует последовательность целых чисел в качестве начального состояния, обновляет состояние 434 раза (354 раунда достигают полной диффузии) и генерирует 177-битный результат, который сравнивается с таковым в правильной последовательности.

Поскольку размер состояния составляет ровно 177 бит, этого должно быть достаточно для однозначной идентификации исходного состояния.

Пример запуска

$ echo $LANG
en_US.UTF-8
$ base64 -d > block.cjam <<< IgThuKHqrLzsj4nlo6XrlqjhiKTrrabjqpDqjaHjoanmipjvpb7itozuoIDtjK3rrbLul7bkr6zqgKvvjafpg6/im4XlvajqhIfrso3uprrotbfvmL/hnqPojqjguonhhp7mtoHujLPuipzlkaLpspLssJzii5npn6rpsLTqn5PkmKbspYbnlq3itorlh4Pmj60iMkcjYjEyOWI6Y34=
$ wc -m block.cjam
62 block.cjam
$ cjam block.cjam < block.secret; echo
1
$ cjam block.cjam <<< "1 2 3 4 5"; echo
0

CJam, 91 символов

q~]KK#bD#"᫖࿼듋ޔ唱୦廽⻎킋뎢凌Ḏ끮冕옷뿹毳슟夫΢眘藸躦䪕齃噳卤"65533:Bb%"萗縤ᤞ雑燠Ꮖ㈢ꭙ㈶タ敫䙿娲훔쓭벓脿翠❶셭剮쬭玓ୂ쁬䈆﹌⫌稟"Bb=

Stack Exchange склонен к обработке непечатаемых символов, но копирование кода из этой вставки и вставка его в интерпретатор CJam прекрасно работает для меня.

Как это работает

После замены строки Unicode на целые числа (с учетом цифр символов из базовых 65533 чисел) выполняется следующий код:

" Read the integers from STDIN and collect them in an array.                               ";

q~]

" Convert it into an integer by considering its elements digits of a base 20**20 number.   ";

KK#b

" Elevate it to the 13th power modulus 252 ... 701.                                        ";

D#
25211471039348320335042771975511542429923787152099395215402073753353303876955720415705947365696970054141596580623913538507854517012317194585728620266050701%

" Check if the result is 202 ... 866.                                                      ";

20296578126505831855363602947513398780162083699878357763732452715119575942704948999334568239084302792717120612636331880722869443591786121631020625810496866=

Поскольку 13 является взаимно простым для модуля модуля (этот термин является секретным, поэтому вам просто нужно доверять мне), разные базы будут давать разные результаты, т. Е. Решение является уникальным.

Если кто-то не может использовать небольшой показатель степени (13), самый эффективный способ сломать эту блокировку - это факторизовать модуль (см. Проблему RSA ). Я выбрал 512-битное целое число для модуля, которое должно выдерживать 72 часа попыток факторизации.

Пример запуска

$ echo $LANG
en_US.UTF-8
$ base64 -d > lock.cjam <<< cX5dS0sjYkQjIgHuiJHhq5bgv7zrk4velOWUse6zjuCtpuW7veK7ju2Ci+uOouWHjOG4ju+Rh+uBruWGleyYt+u/ueavs+6boOyKn+Wkq86i55yY6Je46Lqm5KqV6b2D5Zmz75Wp5Y2kIjY1NTMzOkJiJSIB6JCX57ik4aSe74aS6ZuR54eg4Y+G44ii6q2Z44i244K/5pWr5Jm/5aiy7ZuU7JOt67KT7rO26IS/57+g4p2275+K7IWt5Ymu7Kyt546T4K2C7IGs5IiG77mM4quM56ifIkJiPQ==
$ wc -m lock.cjam
91 lock.cjam
$ cjam lock.cjam < lock.secret; echo
1
$ cjam lock.cjam <<< "1 2 3 4 5"; echo
0

Python - 128

Давайте попробуем это:

i=input()
k=1050809377681880902769L
print'01'[all((i>1,i[0]<i[4],k%i[0]<1,k%i[4]<1,i[4]-i[3]==i[3]-i[2]==i[2]-i[1]==i[1]-i[0]))]

(Ожидается, что пользователь введет 5 чисел, разделенных запятыми, например 1,2,3,4,5.)

Ява: 468

Вход дан как k(int[5]). Залог рано, если не равномерно. В противном случае, потребуется немного выяснить, правильны ли все десять хешей. Для больших чисел «немного» может означать десять секунд или больше, поэтому это может отговорить взломщиков.

//golfed
int k(int[]q){int b=q[1]-q[0],i,x,y,j,h[]=new int[]{280256579,123883276,1771253254,1977914749,449635393,998860524,888446062,1833324980,1391496617,2075731831};for(i=0;i<4;)if(q[i+1]-q[i++]!=b||b<1)return 0;for(i=1;i<6;b=m(b,b/(i++*100),(1<<31)-1));for(i=0;i<5;i++){for(j=1,x=b,y=b/2;j<6;x=m(x,q[i]%100000000,(1<<31)-1),y=m(y,q[i]/(j++*1000),(1<<31)-1));if(x!=h[i*2]||y!=h[i*2+1])return 0;}return 1;}int m(int a,int b,int c){long d=1;for(;b-->0;d=(d*a)%c);return (int)d;}

// line breaks
int k(int[]q){
    int b=q[1]-q[0],i,x,y,j,
    h[]=new int[]{280256579,123883276,1771253254,1977914749,449635393,
                  998860524,888446062,1833324980,1391496617,2075731831};
    for(i=0;i<4;)
        if(q[i+1]-q[i++]!=b||b<1)
            return 0;
    for(i=1;i<6;b=m(b,b/(i++*100),(1<<31)-1));
    for(i=0;i<5;i++){
        for(j=1,x=b,y=b/2;j<6;x=m(x,q[i]%100000000,(1<<31)-1),y=m(y,q[i]/(j++*1000),(1<<31)-1));
        if(x!=h[i*2]||y!=h[i*2+1])
            return 0;
    }
    return 1;
}
int m(int a,int b,int c){
    long d=1;for(;b-->0;d=(d*a)%c);
    return (int)d;
}

Ява: 342

int l(int[]a){String s=""+(a[1]-a[0]);for(int b:a)s+=b;char[]c=new char[11];for(char x:s.toCharArray())c[x<48?10:x-48]++;for(int i=0;i<11;c[i]+=48,c[i]=c[i]>57?57:c[i],i++,s="");for(int b:a)s+=new Long(new String(c))/(double)b;return s.equals("-3083.7767567702776-8563.34366442527211022.4345579010483353.1736981951231977.3560837512646")?1:0;}

Вот строковый шкафчик, который зависит как от количества вводимых символов, так и от конкретного ввода. Последовательность может быть основана на неясных ссылках на поп-культуру. Повеселись!

Немного разгульный

int lock(int[]a){
    String s=""+(a[1]-a[0]);
    for(int b:a)
        s+=b;
    char[]c=new char[11];
    for(char x:s.toCharArray())
        c[x<48?10:x-48]++;
    for(int i=0;i<11;c[i]+=48,
                     c[i]=c[i]>57?57:c[i],
                     i++,
                     s="");
    for(int b:a)
        s+=new Long(new String(c))/(double)b;
    return s.equals("-3083.7767567702776-8563.34366442527211022.4345579010483353.1736981951231977.3560837512646")?1:0;
}

Питон, 147

Изменить: более короткая версия на основе комментария Денниса. Я также обновил последовательность, чтобы избежать утечки информации.

def a(b):
    c=1
    for d in b:
        c=(c<<32)+d
    return pow(7,c,0xf494eca63dcab7b47ac21158799ffcabca8f2c6b3)==0xa3742a4abcb812e0c3664551dd3d6d2207aecb9be

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

Javascript 125

Этот должен быть взломан довольно быстро. Я сделаю что-то более сильное.

function unlock(a, b, c, d, e)
{
    return (e << a == 15652) && (c >> a == 7826) && (e - b == d) && (d - c - a == b) ? 1 : 0;
}

Рубин, 175

a=gets.scan(/\d+/).map(&:to_i)
a.each_cons(2).map{|x,y|x-y}.uniq[1]&&p(0)&&exit
p a[2]*(a[1]^a[2]+3)**7==0x213a81f4518a907c85e9f1b39258723bc70f07388eec6f3274293fa03e4091e1?1:0

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

GolfScript (116 символов)

Принимает ввод как разделенные пробелом целые числа.

~]{2.5??:^(&}%^base 2733?5121107535380437850547394675965451197140470531483%5207278525522834743713290685466222557399=

C 459 байт

Решено Tyilo - ЧИТАТЬ РЕДАКТИРОВАТЬ НИЖЕ

int c (int* a){
int d[4] = {a[1] - a[0], a[2] - a[1], a[3] - a[2], a[4] - a[3]};
if (d[0] != d[1] || d[0] != d[2] || d[0] != d[3]) return 0;
int b[5] = {a[0], a[1], a[2], a[3], a[4]};
int i, j, k;
for (i = 0; i < 5; i++) { 
for (j = 0, k = 2 * i; j < 5; j++, k++) {
k %= i + 1;
b[j] += a[k];
}
}
if (b[0] == 0xC0942 - b[1] && 
b[1] == 0x9785A - b[2] && 
b[2] == 0x6E772 - b[3] && 
b[3] == 0xC0942 - b[4] && 
b[4] == 0xB6508 - b[0]) return 1;
else return 0;
}

Нам нужен кто-то, чтобы написать решение C, не так ли? Я никого не впечатляю длиной, я не игрок в гольф. Надеюсь, это интересный вызов!

Я не думаю, что есть очевидный способ взломать этот, и я с нетерпением жду всех попыток! Я знаю, что это решение уникально. Очень минимальное запутывание, в основном для удовлетворения требований к длине. Это можно проверить просто:

int main(){
    a[5] = {0, 0, 0, 0, 0} /* your guess */
    printf("%d\n", c(a));
    return 0;
}

PS Существует значение для a[0]числа как такового, и я хотел бы, чтобы кто-то указал на это в комментариях!

РЕДАКТИРОВАТЬ:

Решение: 6174, 48216, 90258, 132300, 174342

Примечание о взломе:

Хотя этот метод не используется (см. Комментарии), мне удалось взломать мой собственный шифр с помощью очень простого брутфорса. Теперь я понимаю, что очень важно сделать цифры большими. Следующий код может взломать любой шифр, для upper_boundкоторого известна верхняя граница a[0] + a[1] + a[2] + a[3] + a[4]. Верхняя граница в приведенном выше шифре 457464, которая может быть получена из системы уравнений b[]и некоторой проработки алгоритма. Можно показать, что b[4] = a[0] + a[1] + a[2] + a[3] + a[4].

int a[5];
for (a[0] = 0; a[0] <= upper_bound / 5; a[0]++) {
    for (a[1] = a[0] + 1; 10 * (a[1] - a[0]) + a[0] <= upper_bound; a[1]++) {
        a[2] = a[1] + (a[1] - a[0]);
        a[3] = a[2] + (a[1] - a[0]);
        a[4] = a[3] + (a[1] - a[0]);
        if (c(a)) {
            printf("PASSED FOR {%d, %d, %d, %d, %d}\n", a[0], a[1], a[2], a[3], a[4]);
        }
    }
    printf("a[0] = %d Checked\n", a[0]);
}

С a[0] = 6174этим циклом моя работа прервалась чуть меньше минуты.

Mathematica 80 67

f=Boole[(p=NextPrime/@#)-#=={18,31,6,9,2}&&BitXor@@#~Join~p==1000]&

Бег:

f[{1,2,3,4,5}] (* => 0 *)

Вероятно, довольно легко взломать, может также иметь несколько решений.

Обновление: улучшил игру в гольф, выполнив то, что предложил Мартин Бюттнер. Функциональность функции и клавиши не изменилась.

Python27, 283 182

Хорошо, я очень уверен в своем шкафчике, но это довольно долго, так как я добавил «трудно перевернуть» вычисления к входу, чтобы сделать его хорошо - трудно перевернуть.

import sys
p=1
for m in map(int,sys.argv[1:6]):m*=3**len(str(m));p*=m<<sum([int(str(m).zfill(9)[-i])for i in[1,3,5,7]])
print'01'[p==0x4cc695e00484947a2cb7133049bfb18c21*3**45<<101]

Редактировать: Спасибо Colevk для дальнейшего игры в гольф. Во время редактирования я понял, что в моем алгоритме есть и ошибка, и, может быть, в следующий раз мне повезет больше.

Mathematica 142 146

РЕДАКТИРОВАТЬ : ключ не был уникальным, добавил 4 символа, теперь это так.

n=NextPrime;
f=Boole[
    FromDigits /@ (
        PartitionsQ[n@(237/Plus@##) {1, ##} + 1] & @@@ 
            IntegerDigits@n@{Plus@##-37*Log[#3],(#1-#5)#4}
    ) == {1913001154,729783244}
]&

(Пробелы и символы новой строки добавлены для удобства чтения, не учитываются и не нужны).

Использование:

f[1,2,3,4,5]   (* => 0 *)

Взломанный @Dennis через 2 часа

Просто, чтобы начать работу - я полностью ожидаю, что это будет быстро взломано.

Пиф , 13

h_^ZqU5m-CGdQ

Принимает разделенный запятыми ввод на STDIN.

Запустите его так (-c означает принять программу в качестве аргумента командной строки):

$ echo '1,2,3,4,5' | python3 pyth.py -c h_^ZqU5m-CGdQ
0

Исправил программу - я не понял спецификацию.

Этот язык может быть слишком эзотерическим для этого соревнования - если OP так думает, я его уберу.

Луа 105

Я подозреваю, что это не займет много времени, прежде чем он взломан, но здесь мы идем:

function f(a,b,c,d,e)
   t1=a%b-(e-2*(d-b))
   t2=(a+b+c+d+e)%e
   t3=(d+e)/2
   print(t1==0 and t2==t3 and"1"or"0")
end

(пробелы добавлены для ясности, но не являются частью подсчета)

Perl - 256

sub t{($z,$j,$x,$g,$h)=@_;$t="3"x$z;@n=(7,0,split(//,$g),split(//,$h),4);@r=((2)x6,1,1,(2)x9,4,2,2,2);$u=($j+1)/2;for$n(0..$#r+1){eval{substr($t,$j,1)=$n[$n]};if($@){print 0; return}$j+=$r[$n]*$u}for(1..$x){$t=pack'H*',$t;}eval$t;if($@||$t!~/\D/){print 0}}

Мне пришлось добавить много логики обработки ошибок, и это, безусловно, может привести к гораздо большему. Он напечатает, 1когда вы получите правильные пять чисел. Он с надеждой напечатать 0для всего остального (может быть ошибки или ничего, я не знаю). Если кто-то хочет помочь улучшить код или играть в гольф, не стесняйтесь помочь!

Звоните с:

t(1,2,3,4,5);

Рубин - 130

На основе регистра сдвига с линейной обратной связью. Входные данные по аргументам командной строки.
Должно быть уникальным в зависимости от природы LFSR. Подсказка: восходящая и все положительная.

Даст больше подсказок, если никто не решит это в ближайшее время.

x=($*.map{|i|i.to_i+2**35}*'').to_i
(9**8).times{x=((x/4&1^x&1)<<182)+x/2}
p x.to_s(36)=="qnsjzo1qn9o83oaw0a4av9xgnutn28x17dx"?1:0

Руби, 249

a=gets.scan(/\d+/).map(&:to_i)
a.each_cons(2).map{|x,y|x-y}.uniq[1]&&p(0)&&exit
r=(a[0]*a[1]).to_s(5).tr'234','(+)'
v=a[0]<a[1]&&!r[20]&&(0..3).select{|i|/^#{r}$/=~'%b'%[0xaa74f54ea7aa753a9d534ea7,'101'*32,'010'*32,'100'*32][i]}==[0]?1:0rescue 0
p v

Должно быть весело. Кому нужна математика?

CJam, 49 символов

"腕옡裃䃬꯳널֚樂律ࡆᓅ㥄뇮┎䔤嬣ꑙ䘿휺ᥰ籃僾쎧諯떆Ἣ餾腎틯"2G#b[1q~]8H#b%!

Попробуйте онлайн.

Как это работает

" Push a string representing a base 65536 number and convert it to an integer.            ";

"腕옡裃䃬꯳널֚樂律ࡆᓅ㥄뇮┎䔤嬣ꑙ䘿휺ᥰ籃僾쎧諯떆Ἣ餾腎틯"2G#b

" Prepend 1 to the integers read from STDIN and collect them into an array.               ";

[1q~]

" Convert that array into an integer by considering it a base 2**51 number.               ";

8H#b

" Push the logical NOT of the modulus of both computed integers.                          ";

%!

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

Факторизуя 512 битное целое число не что трудно, но я надеюсь , что никто не сможет в течение 72 часов. Моя предыдущая версия, использующая 320-битное целое число , была сломана .

Пример запуска

$ echo $LANG
en_US.UTF-8
$ base64 -d > flock512.cjam <<< IuiFleyYoeijg+SDrOqvs+uEkNaa76a/5b6L4KGG4ZOF76Gi46WE64eu4pSO5JSk5ayj6pGZ5Ji/7Zy64aWw57GD5YO+7I6n6Kuv65aG7qK04byr6aS+6IWO7rSn7YuvIjJHI2JbMXF+XThII2IlIQ==
$ wc -m flock512.cjam
49 flock512.cjam
$ cjam flock512.cjam < flock512.secret; echo
1
$ cjam flock512.cjam <<< "1 2 3 4 5"; echo
0

Javascript 958

Преобразует входные данные в несколько типов данных и выполняет некоторые манипуляции, относящиеся к каждому типу данных. Должен быть довольно легко изменен для любого, кто берет время.

function encrypt(num)
{
    var dateval = new Date(num ^ (1024-1) << 10);

    dateval.setDate(dateval.getDate() + 365);

    var dateString = (dateval.toUTCString() + dateval.getUTCMilliseconds()).split('').reverse().join('');

    var result = "";

    for(var i = 0; i < dateString.length; i++)
        result += dateString.charCodeAt(i);

    return result;
}

function unlock(int1, int2, int3, int4, int5)
{
    return encrypt(int1) == "5549508477713255485850495848483249555749321109774324948324410511470" && encrypt(int2) == "5756568477713252485848495848483249555749321109774324948324410511470" && encrypt(int3) == "5149538477713248485856485848483249555749321109774324948324410511470" && encrypt(int4) == "5356498477713256535853485848483249555749321109774324948324410511470" && encrypt(int5) == "5748568477713251535851485848483249555749321109774324948324410511470" ? 1 : 0;
}

С, 239 (взломано Деннисом)

Пойди сюда для моего обновленного представления.

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

p(long long int x){long long int i;x=abs(x);
for (i=2;i<x;i++) {if ((x/i)*i==x) return 0;}return 1;}
f(a,b,c,d,e){char k[99];long long int m;sprintf(k,"%d%d%d%d%d",e,d,c,b,a);
sscanf(k,"%lld",&m);return p(a)&&p(b)&&p(c)&&p(d)&&p(e)&&p(m);}

C, 212 от Orby - треснувший

/codegolf//a/36810/31064 от Orby имеет как минимум два ключа:

13 103 193 283 373
113 173 233 293 353

Орби попросил метод, который я использовал, чтобы взломать его. Функция p проверяет, является ли x простым, проверяя x%i==0все i между 2 и x (хотя и используя (x/i)*i==xвместо x%i==0), и возвращает true, если x является простым числом. Функция f проверяет, что все a, b, c, d и e простые. Он также проверяет, является ли число m, конкатенация десятичных представлений e, d, c, b и a (в этом порядке), простым. Ключ таков, что a, b, c, d, e и m все простые.

Грин и Тао (2004) показывают, что существует бесконечно много арифметических последовательностей простых чисел для любой длины k, поэтому нам просто нужно искать эти последовательности, которые также удовлетворяют m, являющемуся простым числом. Учитывая, что long ограничен значениями -9.223372037e + 18 и 9.223372037e + 18, мы знаем, что для объединенной строки, чтобы соответствовать long long, числа имеют верхнюю границу 9999. Таким образом, с помощью сценария python для генерации всех арифметические последовательности во всех простых числах <10000, а затем проверяя, является ли их обратная конкатенация простым числом, мы можем найти много возможных решений.

По какой-то причине у меня возникли ложные срабатывания, но два приведенных выше действительны в соответствии с программой. Кроме того, могут быть решения, где e отрицательно, а остальные положительны (p использует модуль x), но я не искал их.

Все ключи, которые я дал, являются арифметическими последовательностями, но сценарий Орби, по-видимому, не требует, чтобы входные данные были арифметической последовательностью, поэтому могут быть и недействительные ключи.

MATLAB: очевидно недействительный

Очень просто, вам просто нужно сгенерировать правильное случайное число.

function ans=t(a,b,c,d,e)
rng(a)
r=@(x)rng(rand*x)
r(b)
r(c)
r(d)
r(e)
rand==0.435996843156676

Это все еще может привести к ошибке, но это не должно быть проблемой.

MATLAB (с набором символов), 173 символа

Это не официальная запись и не засчитывается как чей-то потрясающий результат, но это лишит вас безумных прав на хвастовство. ;)

function b=L(S),c=sprintf('%d8%d',S(1),S(2)-S(1));b=numel(unique(diff(S)))==1&&numel(c)==18&&all(c([8,9])==c([18,17]))&&isequal(c,char(sym(sort(c,'descend'))-sym(sort(c))));

Символический набор инструментов требуется только для обработки вычитания больших целых чисел.

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

Python 2 (91)

Изменить: Это не допускается, потому что аргумент в пользу уникальности является вероятностным. Я сдаюсь.

s=3
for n in input():s+=pow(n,s,7**58)
print s==0x8b5ca8d0cea606d2b32726a79f01adf56f12aeb6e

Принимает списки целых чисел в качестве ввода, как [1,2,3,4,5].

Цикл предназначен для работы на входах раздражающим способом, оставляя множество сумм и показателей. Идея похожа на дискретное бревно, но с математической простотой вместо математической простоты. Может быть, сложность модуля является уязвимостью, и в этом случае я мог бы сделать что-то вроде 7**58+8.

Я действительно не знаю, как я могу доказать, что мой ключ - единственный, но диапазон выходов по крайней мере в 10 раз больше, чем диапазон входов, так что, вероятно? Хотя, возможно, достижима лишь небольшая часть потенциальных результатов. Я всегда мог бы увеличить количество цифр за счет символов. Я оставлю это на ваше усмотрение, чтобы решить, что справедливо.

Счастливого взлома!

Mathematica - 72

Версия 2 моего скрипта, с тем же ключом, который предназначен для моей версии 1.

Это в основном удаляет отрицательные простые числа для NextPrime.

f=Boole[(p=Abs[NextPrime/@#])-#=={18,31,6,9,2}&&BitXor@@#~Join~p==1000]&

Бег:

f[{1,2,3,4,5}] (* => 0 *)

Python, 86 символов

a,b,c,d,e=input()
print 1if(a*c^b*e)*d==0xd5867e26a96897a2f80 and b^d==48891746 else 0

Введите цифры, как 1,2,3,4,5.

> python 36768.py <<< "1,2,3,4,5"
0
> python 36768.py <<< "[REDACTED]"
1

Python, 78

(Взломано Тейло за 14 минут)

Весело!

def L(a): return 1 if a==[(i-i**6) for i in bytearray(' ','utf-8')] else 0

Хорошо, здесь не отображается должным образом :(

Ожидается список из пяти чисел, например. [1,2,3,4,5]

CJam, 37 символов (не работает)

"煷➻捬渓类ⶥ땙ዶ꾫㞟姲̷ᐂ㵈禙鰳쥛忩蔃"2G#b[1q~]4G#b%!

Попробуйте онлайн.

Как это работает

Смотрите мой новый ответ.

Пример запуска

$ echo $LANG
en_US.UTF-8
$ base64 -d > flock.cjam <<< IueFt+Keu+aNrOa4k+exu+K2peuVmeGLtuq+q+Oen+Wnsu6AhMy34ZCC47WI56aZ6bCz7KWb5b+p6JSDIjJHI2JbMXF+XTRHI2IlIQ==
$ wc -m flock.cjam
37 flock.cjam
$ cjam flock.cjam < flock.secret; echo
1
$ cjam flock.cjam <<< "1 2 3 4 5"; echo
0

С 212 (треснувший)

Это та же идея , как мое предыдущее представление , golfed более тщательно, с ошибкой исправлена Проходящими 0,0,0,0,0 (спасибо Денниса за указание на ошибке). Компилировать с -std = c99.

#define L long long
p(L x){x=abs(x);for(L i=2;i<x;i++){if((x/i)*i==x)return 0;}return(x>1);}
f(a,b,c,d,e){char k[99];L m;sprintf(k,"%d%d%d%d%d",e,d,c,b,a);sscanf(k,"%lld",&m);
return p(a)&p(b)&p(c)&p(d)&p(e)&p(m);}