Các thách thức

Một thử thách "gián điệp so với gián điệp" đơn giản.

Viết chương trình với các thông số kỹ thuật sau:

1. Chương trình có thể được viết bằng bất kỳ ngôn ngữ nào nhưng không được vượt quá 512 ký tự (như được thể hiện trong một khối mã trên trang web này).
2. Chương trình phải chấp nhận 5 số nguyên 32 bit đã ký làm đầu vào. Nó có thể ở dạng một hàm chấp nhận 5 đối số, một hàm chấp nhận một mảng 5 phần tử hoặc một chương trình hoàn chỉnh đọc 5 số nguyên từ bất kỳ đầu vào tiêu chuẩn nào.
3. Chương trình phải xuất một số nguyên 32 bit đã ký.
4. Chương trình phải trả về 1 khi và chỉ khi năm đầu vào, được hiểu là một chuỗi, khớp với một chuỗi số học cụ thể của sự lựa chọn của lập trình viên, được gọi là "khóa". Hàm phải trả về 0 cho tất cả các đầu vào khác.

Một chuỗi số học có đặc tính là mỗi phần tử liên tiếp của chuỗi bằng với tiền thân của nó cộng với một số hằng số cố định a.

Ví dụ, 25 30 35 40 45là một chuỗi số học vì mỗi phần tử của chuỗi bằng với tiền thân của nó cộng với 5. Tương tự, 17 10 3 -4 -11là một chuỗi số học vì mỗi phần tử bằng với phần tử trước của nó cộng với -7.

Các trình tự 1 2 4 8 16và 3 9 15 6 12không phải là trình tự số học.

Khóa có thể là bất kỳ chuỗi số học nào bạn chọn, với hạn chế duy nhất là các chuỗi liên quan đến tràn số nguyên không được phép. Đó là, trình tự phải được tăng nghiêm ngặt, giảm nghiêm ngặt hoặc có tất cả các yếu tố bằng nhau.

Ví dụ, giả sử bạn chọn khóa 98021 93880 89739 85598 81457. Chương trình của bạn phải trả về 1 nếu các đầu vào (theo thứ tự) khớp với năm số này và 0 khác.

Xin lưu ý rằng các phương tiện bảo vệ chìa khóa nên là thiết kế tiểu thuyết của riêng bạn. Ngoài ra, các giải pháp xác suất có thể trả về dương tính giả với bất kỳ xác suất khác nào đều không được phép. Cụ thể, vui lòng không sử dụng bất kỳ băm mật mã tiêu chuẩn nào, bao gồm các hàm thư viện cho băm mật mã tiêu chuẩn.

Chấm điểm

Bài nộp không bị bẻ khóa ngắn nhất cho mỗi số ký tự sẽ được tuyên bố là người chiến thắng.

Nếu có bất kỳ sự nhầm lẫn, xin vui lòng hỏi hoặc nhận xét.

Thử thách

Tất cả các độc giả, bao gồm cả những người đã gửi chương trình của riêng họ, được khuyến khích "bẻ khóa" bài nộp. Một bài nộp bị bẻ khóa khi khóa của nó được đăng trong phần bình luận liên quan. Nếu một bài nộp tồn tại trong 72 giờ mà không bị sửa đổi hoặc bẻ khóa, nó được coi là "an toàn" và bất kỳ thành công nào sau đó trong việc bẻ khóa, nó sẽ bị bỏ qua vì lợi ích của cuộc thi.

Xem "Tuyên bố miễn trừ trách nhiệm" bên dưới để biết chi tiết về chính sách điểm bẻ khóa được cập nhật.

Đệ trình bẻ khóa được loại bỏ khỏi sự tranh chấp (miễn là chúng không "an toàn"). Họ không nên được chỉnh sửa. Nếu một độc giả muốn gửi một chương trình mới, anh ta nên làm như vậy trong một câu trả lời riêng.

(Các) cracker có số điểm cao nhất sẽ được tuyên bố là người chiến thắng cùng với các nhà phát triển chương trình chiến thắng.

Xin đừng bẻ khóa trình của bạn.

May mắn nhất. :)

Bảng xếp hạng

Bảng xếp hạng áp chót (chờ an toàn khi nộp Dennis 'CJam 49).

Tủ khóa an toàn

1. CJam 49, Dennis
2. CJam 62, Dennis an toàn
3. CJam 91, Dennis an toàn
4. Python 156, Maarten Baert an toàn
5. Perl 256, chilemagic an toàn
6. Java 468, Geobits an toàn

Crackers không thể ngăn cản

1. Peter Taylor [Ruby 130, Java 342, Mathicala 146 *, Mathicala 72 *, CJam 37]
2. Dennis [Pyth 13, Python 86 *, Lua 105 *, GolfScript 116, C 239 *]
3. Martin Büttner [Javascript 125, Python 128 *, Ruby 175 *, Ruby 249 *]
4. Tyilo [C 459, Javascript 958 *]
5. freddieknets [Mathicala 67 *]
6. Ilmari Karonen [Python27 182 *]
7. nitơ [C 212 *]

* đệ trình không tuân thủ

Tuyên bố miễn trừ trách nhiệm (Cập nhật 11:15 PM EST, ngày 26 tháng 8)

Với các vấn đề về điểm số cuối cùng đã đạt đến khối lượng tới hạn (cho hai phần ba số lần gửi bị bẻ khóa cho đến nay không tuân thủ), tôi đã xếp hạng các cracker hàng đầu về số lượng bài nộp bị bẻ khóa (chính) và tổng số ký tự trong các bài nộp bị bẻ khóa tuân thủ (thứ hai).

Như trước đây, các bài nộp chính xác đã bị bẻ khóa, độ dài của bài nộp và trạng thái tuân thủ / không tuân thủ của chúng đều được đánh dấu để độc giả có thể suy ra thứ hạng của chính họ nếu họ tin rằng bảng xếp hạng chính thức mới là không công bằng.

Tôi xin lỗi vì đã sửa đổi các quy tắc này vào cuối trò chơi.

CJam, 62 ký tự

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

Stack Exchange có xu hướng xử lý các ký tự không thể in được, nhưng sao chép mã từ dán này và dán nó trong trình thông dịch CJam hoạt động tốt với tôi.

Làm thế nào nó hoạt động

Sau khi thay thế chuỗi Unicode bằng chuỗi ASCII, đoạn mã sau sẽ được thực thi:

" 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=

Cách tiếp cận này sử dụng Bivium-B (xem phân tích đại số của các thuật toán mã hóa giống như Trivium ), một phiên bản suy yếu của mật mã hóa dòng Trivium .

Chương trình sử dụng chuỗi số nguyên làm trạng thái ban đầu, cập nhật trạng thái 434 lần (354 vòng đạt được độ khuếch tán hoàn toàn) và tạo ra 177 bit đầu ra, so sánh với trạng thái của chuỗi chính xác.

Vì kích thước của trạng thái là chính xác 177 bit, nên điều này đủ để xác định duy nhất trạng thái ban đầu.

Chạy ví dụ

$ 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 ký tự

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

Stack Exchange có xu hướng xử lý các ký tự không thể in được, nhưng sao chép mã từ dán này và dán nó trong trình thông dịch CJam hoạt động tốt với tôi.

Làm thế nào nó hoạt động

Sau khi thay thế chuỗi Unicode bằng số nguyên (bằng cách xem xét các chữ số ký tự của số 65533 cơ sở), đoạn mã sau sẽ được thực thi:

" 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=

Vì 13 là tương đương với tổng của mô đun (tổng số là bí mật, vì vậy bạn sẽ phải tin tưởng tôi), các cơ sở khác nhau sẽ tạo ra kết quả khác nhau, nghĩa là, giải pháp là duy nhất.

Trừ khi ai đó có thể khai thác số mũ nhỏ (13), cách hiệu quả nhất để phá khóa này là nhân tố mô đun (xem bài toán RSA ). Tôi đã chọn một số nguyên 512 bit cho mô-đun, có thể chịu được 72 giờ thử nhân tố.

Chạy ví dụ

$ 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

Con trăn - 128

Hãy thử cái này:

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]))]

(Yêu cầu người dùng nhập 5 số được phân tách bằng dấu phẩy, vd 1,2,3,4,5.)

Java: 468

Đầu vào được đưa ra là k(int[5]). Bảo lãnh sớm nếu không cách đều nhau. Mặt khác, phải mất một chút để tìm ra nếu tất cả mười băm là chính xác. Đối với số lượng lớn, "một chút" có thể có nghĩa là mười giây trở lên, do đó, nó có thể ngăn cản các cracker.

//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;
}

Java: 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;}

Đây là một khóa dựa trên chuỗi phụ thuộc vào cả số lượng ký tự đầu vào và đầu vào cụ thể. Trình tự có thể được dựa trên tài liệu tham khảo văn hóa pop tối nghĩa. Chúc vui vẻ!

Một chút vô duyên:

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;
}

Con trăn, 147

Chỉnh sửa: phiên bản ngắn hơn dựa trên nhận xét của Dennis. Tôi cũng cập nhật trình tự để tránh rò rỉ bất kỳ thông tin.

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

Dựa trên vấn đề logarit rời rạc được cho là không thể bẻ khóa được, tuy nhiên số nguyên tố tôi đang sử dụng có lẽ quá nhỏ để bảo mật (và nó có thể có các vấn đề khác, tôi không biết). Và dĩ nhiên, bạn có thể buộc nó, vì ẩn số duy nhất là hai số nguyên 32 bit.

Javascript 125

Cái này nên được crack khá nhanh. Tôi sẽ theo dõi với một cái gì đó mạnh mẽ hơn.

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

Hồng ngọc, 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

Không giống như sử dụng hàm băm mật mã hoặc srand, điều này có thể chứng minh được là duy nhất (là một manh mối nhỏ). Lấy năm số thông qua STDIN, được phân định bởi bất kỳ ký tự hoặc ký tự không phải chữ số mới nào. Đầu ra cho STDOUT.

GolfScript (116 ký tự)

Lấy đầu vào là số nguyên phân tách không gian.

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

C 459 byte

GIẢI QUYẾT B TyNG Tyilo - ĐỌC EDIT DƯỚI ĐÂY

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;
}

Chúng ta cần ai đó viết một giải pháp C, phải không? Tôi không gây ấn tượng với bất kỳ ai về chiều dài, tôi không phải là người chơi gôn. Tuy nhiên, tôi hy vọng đó là một thử thách thú vị!

Tôi không nghĩ có một cách rõ ràng để bẻ khóa cái này, và tôi háo hức chờ đợi mọi nỗ lực! Tôi biết giải pháp này là duy nhất. Obfuscation rất tối thiểu, chủ yếu để đáp ứng yêu cầu chiều dài. Điều này có thể được kiểm tra đơn giản:

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

PS có một ý nghĩa đối với a[0] với một số theo đúng nghĩa của nó, và tôi muốn thấy ai đó chỉ ra nó trong các ý kiến!

CHỈNH SỬA:

Dung dịch: 6174, 48216, 90258, 132300, 174342

Một lưu ý về nứt:

Mặc dù đây không phải là phương pháp được sử dụng (xem các bình luận), tôi đã tình cờ phá được mật mã của riêng tôi với một sự tàn bạo rất dễ dàng. Tôi hiểu bây giờ điều cực kỳ quan trọng là làm cho số lượng lớn. Đoạn mã sau có thể bẻ khóa bất kỳ mật mã nào có upper_boundgiới hạn trên được biết đến a[0] + a[1] + a[2] + a[3] + a[4]. Giới hạn trên trong các mật mã trên là 457464, có thể được bắt nguồn từ hệ thống các phương trình b[]và một số hoạt động của thuật toán. Nó có thể được chỉ ra rằng 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]);
}

Với a[0] = 6174, vòng lặp này đã phá vỡ công việc của tôi trong một ít dưới một phút.

Toán học 80 67

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

Đang chạy:

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

Có lẽ khá dễ để bẻ khóa, cũng có thể có nhiều giải pháp.

Cập nhật: Cải thiện việc chơi golf bằng cách làm những gì Martin Büttner đề xuất. Chức năng của chức năng và khóa không thay đổi.

Con trăn27, 283 182

Được rồi, tôi rất tin tưởng vào tủ khóa của mình, tuy nhiên nó khá dài vì tôi đã thêm các tính toán 'khó đảo ngược' vào đầu vào, để làm cho nó tốt - khó đảo ngược.

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]

chỉnh sửa: Cảm ơn colevk cho việc chơi gôn hơn nữa. Tôi nhận ra trong quá trình chỉnh sửa rằng có một lỗi cũng như lỗ hổng trong thuật toán của tôi, có lẽ tôi sẽ gặp may mắn hơn vào lần tới.

Toán học 142 146

EDIT : key không phải là duy nhất, đã thêm 4 ký tự, bây giờ là vậy.

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

(Không gian và dòng mới được thêm vào để dễ đọc, không được tính và không cần thiết).

Sử dụng:

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

Bị bẻ khóa bởi @Dennis sau 2 giờ

Chỉ cần một cách đơn giản để bắt đầu mọi thứ - tôi hoàn toàn mong đợi điều này sẽ nhanh chóng bị phá vỡ.

Bình thường , 13

h_^ZqU5m-CGdQ

Đưa đầu vào được phân tách bằng dấu phẩy trên STDIN.

Chạy nó như thế này (-c có nghĩa là lấy chương trình làm đối số dòng lệnh):

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

Đã sửa chương trình - Tôi không hiểu thông số kỹ thuật.

Ngôn ngữ này có thể quá bí truyền cho cuộc thi này - Nếu OP nghĩ vậy, tôi sẽ loại bỏ nó.

Lua 105

Tôi nghi ngờ nó sẽ không tồn tại lâu trước khi nó bị nứt, nhưng ở đây chúng tôi đi:

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

(khoảng trắng được thêm vào cho rõ ràng, nhưng không phải là một phần của tính)

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}}

Tôi đã phải đưa vào rất nhiều logic xử lý lỗi và điều này chắc chắn có thể được đánh xuống nhiều hơn nữa. Nó sẽ in một 1khi bạn nhận được đúng năm số. Tôi hy vọng nó sẽ in một 0thứ cho mọi thứ khác (có thể là lỗi hoặc không có gì, tôi không biết). Nếu bất cứ ai muốn giúp cải thiện mã hoặc chơi golf nhiều hơn, hãy thoải mái giúp đỡ!

Gọi với:

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

Hồng ngọc - 130

Dựa trên Đăng ký thay đổi phản hồi tuyến tính. Đầu vào bằng đối số dòng lệnh.
Nên là duy nhất dựa trên bản chất của LFSR. Clue: tăng dần và tất cả tích cực.

Sẽ cung cấp thêm manh mối nếu không ai giải quyết sớm.

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

Hồng ngọc, 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

Có lẽ vui. Ai cần môn toán?

CJam, 49 ký tự

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

Hãy thử trực tuyến.

Làm thế nào nó hoạt động

" 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.                          ";

%!

Kết quả sẽ là 1 khi và chỉ khi số nguyên thứ hai là một yếu tố của số thứ nhất, là tích của hai số nguyên tố: một số nguyên tương ứng với chuỗi bí mật và một số nguyên khác không tương ứng với bất kỳ chuỗi hợp lệ nào. Do đó, giải pháp là duy nhất.

Factorizing một số nguyên 512 chút không phải là rằng khó khăn, nhưng tôi hy vọng sẽ không có ai có thể trong 72 giờ. Phiên bản trước của tôi sử dụng số nguyên 320 bit đã bị hỏng .

Chạy ví dụ

$ 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

Chuyển đổi các đầu vào thành một số loại dữ liệu và thực hiện một số thao tác có liên quan đến từng loại dữ liệu trên đường đi. Nên khá dễ dàng đảo ngược cho bất cứ ai mất thời gian.

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;
}

C, 239 (Bị bẻ khóa bởi Dennis)

Tới đây để gửi cập nhật của tôi.

Có lẽ có thể được đánh golf kỹ hơn một chút. Phải thừa nhận rằng, tôi đã không dành thời gian để chứng minh khóa là duy nhất (có lẽ không phải vậy) nhưng nó chắc chắn theo thứ tự của một vụ va chạm băm. Nếu bạn crack nó, xin vui lòng chia sẻ phương pháp của bạn :)

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 bởi Orby - Bị nứt

https://codegolf.stackexchange.com/a/36810/31064 bởi Orby có ít nhất hai khóa:

13 103 193 283 373
113 173 233 293 353

Orby yêu cầu phương pháp tôi sử dụng để bẻ khóa nó. Hàm p kiểm tra xem x có phải là số nguyên tố hay không bằng cách kiểm tra x%i==0tất cả i giữa 2 và x (mặc dù sử dụng (x/i)*i==xthay vìx%i==0 ) và trả về true nếu x là số nguyên tố. Hàm f kiểm tra tất cả a, b, c, d và e là số nguyên tố. Nó cũng kiểm tra xem số m, một phép nối các biểu diễn thập phân của e, d, c, b và a (theo thứ tự đó), có phải là số nguyên tố hay không. Điều quan trọng là a, b, c, d, e và m đều là số nguyên tố.

Green và Tao (2004) cho thấy tồn tại vô số chuỗi số nguyên tố cho bất kỳ độ dài k nào, vì vậy chúng ta chỉ cần tìm các chuỗi này cũng thỏa mãn m là số nguyên tố. Bằng cách mất nhiều thời gian khi bị giới hạn bởi -9,223372037e + 18 và 9,223372037e + 18, chúng ta biết rằng để chuỗi nối dài vừa vặn, các số có giới hạn trên là 9999. Vì vậy, bằng cách sử dụng tập lệnh python để tạo ra tất cả các chuỗi số học trong tất cả các số nguyên tố <10000 và sau đó kiểm tra xem phép nối ngược của chúng có phải là số nguyên tố hay không, chúng ta có thể tìm thấy nhiều giải pháp khả thi.

Vì một số lý do, tôi đã đưa ra các kết quả dương tính giả, nhưng hai điều trên là hợp lệ theo chương trình. Ngoài ra, có thể có các giải pháp trong đó e âm tính và phần còn lại là dương (p sử dụng mô đun của x), nhưng tôi đã không tìm kiếm những giải pháp đó.

Các khóa tôi đưa ra đều là các chuỗi số học nhưng tập lệnh của Orby dường như không thực sự yêu cầu các đầu vào phải là một chuỗi số học, do đó cũng có thể có các khóa không hợp lệ.

MATLAB: Rõ ràng không hợp lệ

Rất đơn giản, bạn chỉ cần tạo đúng số ngẫu nhiên.

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

Nó vẫn có thể lỗi, nhưng đó không phải là một vấn đề.

MATLAB (với Hộp công cụ tượng trưng), 173 ký tự

Đây không phải là một mục chính thức và sẽ không được tính vào điểm bẻ khóa của bất kỳ ai, nhưng nó sẽ khiến bạn có quyền khoe khoang điên rồ. ;)

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))));

Hộp công cụ tượng trưng chỉ được yêu cầu để xử lý phép trừ của số nguyên lớn.

Brute buộc nó phải là một con chó, nhưng nếu bạn quen thuộc với loạt nó liên quan, giải pháp là tầm thường.

Con trăn 2 (91)

Chỉnh sửa: Điều này không được phép vì đối số cho tính duy nhất là xác suất. Tôi từ bỏ.

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

Lấy danh sách các số nguyên làm đầu vào, như [1,2,3,4,5] .

Vòng lặp có nghĩa là hoạt động trên các đầu vào một cách khó chịu, để lại một tháp tổng và số mũ. Ý tưởng giống như nhật ký rời rạc, nhưng với sự phức tạp lộn xộn thay vì đơn giản toán học. Có lẽ tính phức tạp của mô đun là một lỗ hổng, trong trường hợp đó tôi có thể làm cho nó giống như7**58+8 .

Tôi thực sự không biết làm thế nào tôi chứng minh rằng khóa của tôi là duy nhất, nhưng phạm vi đầu ra lớn hơn ít nhất 10 lần so với phạm vi đầu vào, vậy có lẽ? Mặc dù có lẽ chỉ một phần nhỏ của đầu ra tiềm năng là có thể đạt được. Tôi luôn có thể tăng số chữ số với chi phí ký tự. Tôi sẽ để nó cho bạn quyết định những gì công bằng.

Hạnh phúc rạn nứt!

Toán học - 72

Phiên bản 2 của tập lệnh của tôi, có cùng khóa với phiên bản dành cho phiên bản 1 của tôi.

Điều này về cơ bản loại bỏ các số nguyên tố âm cho NextPrime.

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

Đang chạy:

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

Con trăn, 86 ký tự

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

Nhập số như thế nào 1,2,3,4,5.

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

Con trăn, 78

(Bẻ khóa bởi Tyilo trong 14 phút)

Vui vẻ!

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

Được rồi, nó không hiển thị đúng ở đây :(

Mong đợi một danh sách năm số, ví dụ. [1,2,3,4,5]

CJam, 37 ký tự (bị hỏng)

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

Hãy thử trực tuyến.

Làm thế nào nó hoạt động

Xem câu trả lời mới của tôi.

Chạy ví dụ

$ 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

C, 212 (Bị nứt)

Đây là ý tưởng tương tự như lần gửi trước của tôi , đã chơi golf kỹ lưỡng hơn, với một lỗi được sửa đã vượt qua 0,0,0,0,0 (Cảm ơn Dennis vì đã chỉ ra lỗi này). Biên dịch với -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);}