ความท้าทาย

ความท้าทาย "สายลับกับสายลับ" ที่เรียบง่าย

เขียนโปรแกรมด้วยข้อกำหนดต่อไปนี้:

1. โปรแกรมอาจเขียนเป็นภาษาใดก็ได้ แต่ต้องไม่เกิน 512 ตัวอักษร (ตามที่แสดงในบล็อกรหัสบนเว็บไซต์นี้)
2. โปรแกรมต้องยอมรับจำนวนเต็ม 32- บิตที่ได้รับการรับรอง 5 รายการเป็นอินพุต มันสามารถใช้รูปแบบของฟังก์ชั่นที่ยอมรับข้อโต้แย้ง 5 ฟังก์ชั่นที่ยอมรับอาร์เรย์ 5 องค์ประกอบเดียวหรือโปรแกรมสมบูรณ์ที่อ่านจำนวนเต็ม 5 ตัวจากอินพุตมาตรฐานใด ๆ
3. โปรแกรมจะต้องส่งออกจำนวนเต็ม 32 บิตแบบมีลายเซ็นหนึ่งรายการ
4. โปรแกรมจะต้องส่งคืน 1 ถ้าหากทั้งห้าอินพุตตีความเป็นลำดับตรงกับลำดับเลขคณิตเฉพาะของการเลือกโปรแกรมเมอร์เรียกว่า "กุญแจ" ฟังก์ชันต้องส่งคืน 0 สำหรับอินพุตอื่นทั้งหมด

ลำดับเลขคณิตมีคุณสมบัติที่แต่ละองค์ประกอบที่ต่อเนื่องของลำดับนั้นเท่ากับบรรพบุรุษของมันบวกค่าคงที่คงที่ aลำดับเลขคณิตมีคุณสมบัติที่แต่ละองค์ประกอบต่อเนื่องของลำดับเท่ากับบรรพบุรุษของมันบวกบางคงที่คงที่

ตัวอย่างเช่น25 30 35 40 45เป็นลำดับเลขคณิตเนื่องจากแต่ละองค์ประกอบของลำดับนั้นเท่ากับบรรพบุรุษของมันบวก 5 เช่นเดียวกัน17 10 3 -4 -11เป็นลำดับเลขคณิตเนื่องจากแต่ละองค์ประกอบมีค่าเท่ากับ precessor บวก -7

ลำดับ1 2 4 8 16และ3 9 15 6 12ไม่ใช่ลำดับเลขคณิต

คีย์อาจเป็นลำดับเลขคณิตใด ๆ ที่คุณเลือกโดยมีข้อ จำกัด แต่เพียงผู้เดียวที่ไม่อนุญาตให้ใช้ลำดับที่เกี่ยวข้องกับการล้นจำนวนเต็ม นั่นคือลำดับจะต้องเพิ่มขึ้นอย่างเข้มงวดลดลงอย่างเคร่งครัดหรือมีองค์ประกอบทั้งหมดเท่ากัน

ตัวอย่างเช่นสมมติว่าคุณเลือกกุญแจ 98021 93880 89739 85598 81457ตัวอย่างเช่นสมมติว่าคุณเลือกที่สำคัญโปรแกรมของคุณจะต้องส่งคืน 1 หากอินพุต (ตามลำดับ) ตรงกับตัวเลขห้าตัวนี้และ 0 เป็นอย่างอื่น

โปรดทราบว่าวิธีการป้องกันกุญแจควรเป็นของการออกแบบใหม่ของคุณเอง นอกจากนี้ยังไม่อนุญาตให้ใช้วิธีแก้ไขความน่าจะเป็นที่ส่งกลับผลบวกปลอมด้วยความน่าจะเป็นที่ไม่ใช่ศูนย์ โดยเฉพาะอย่างยิ่งโปรดอย่าใช้แฮชเข้ารหัสลับมาตรฐานใด ๆ รวมถึงฟังก์ชั่นห้องสมุดสำหรับแฮชเข้ารหัสลับมาตรฐาน

เกณฑ์การให้คะแนน

การส่งที่ไม่แตกสั้นที่สุดต่อจำนวนตัวละครจะถูกประกาศให้เป็นผู้ชนะ

หากมีความสับสนใด ๆ โปรดอย่าลังเลที่จะถามหรือแสดงความคิดเห็น

การท้าทาย

ผู้อ่านทุกคนรวมถึงผู้ที่ส่งโปรแกรมของตัวเองได้รับการสนับสนุนให้ "ส่งเสียงดัง" การส่งจะแตกเมื่อคีย์ของมันถูกโพสต์ในส่วนความคิดเห็นที่เกี่ยวข้อง หากการส่งยังคงมีอยู่เป็นเวลา 72 ชั่วโมงโดยไม่มีการดัดแปลงหรือแตกมันจะถือว่า "ปลอดภัย" และความสำเร็จใด ๆ ที่ตามมาในการถอดรหัสจะถูกเพิกเฉยเพราะการประกวด

ดู "ข้อจำกัดความรับผิดชอบ" ด้านล่างสำหรับรายละเอียดเกี่ยวกับนโยบายคะแนนการแคร็กที่อัปเดตแล้ว

การส่งที่แคร็กจะถูกกำจัดออกจากการแข่งขัน (หากไม่ปลอดภัย) ไม่ควรแก้ไข หากผู้อ่านต้องการส่งโปรแกรมใหม่เขาควรตอบด้วยคำตอบที่แยกต่างหาก

แคร็กเกอร์ที่มีคะแนนสูงสุดจะถูกประกาศให้กับผู้ชนะพร้อมกับผู้พัฒนาโปรแกรมที่ชนะ

โปรดอย่าถอดรหัสของคุณเอง

ขอให้โชคดี :)

ลีดเดอร์บอร์ด

อันดับสุดท้าย (ความปลอดภัยที่รอการอนุมัติจากการส่งของ CJam 49 ของเดนนิส)

ตู้เก็บของที่ปลอดภัย

1. CJam 49, เดนนิส
2. CJam 62, เดนนิส ปลอดภัย
3. CJam 91, เดนนิส ปลอดภัย
4. Python 156, Maarten Baert อย่างปลอดภัย
5. Perl 256, chilemagic ปลอดภัย
6. Java 468, Geobits ปลอดภัย

แคร็กเกอร์ผ่านพ้นไม่ได้

1. Peter Taylor [Ruby 130, Java 342, Mathematica 146 *, Mathematica 72 *, CJam 37]
2. เดนนิส [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 [Mathematica 67 *]
6. Ilmari Karonen [Python27 182 *]
7. ไนตรัส [C 212 *]

* การส่งที่ไม่เป็นไปตามข้อกำหนด

ข้อจำกัดความรับผิดชอบ (อัปเดตเมื่อ 15:30 น. EST, 26 สิงหาคม)

ด้วยปัญหาการให้คะแนนในที่สุดก็มาถึงมวลวิกฤต (เนื่องจากสองในสามของการแคร็กที่ส่งมานั้นไม่เป็นไปตามข้อกำหนด) ฉันได้จัดอันดับแครกเกอร์อันดับหนึ่งในแง่ของจำนวนการส่งที่แคร็ก (หลัก) และจำนวนอักขระทั้งหมดในการส่งแคร็กที่สอดคล้อง (รอง)

ก่อนหน้านี้ผลงานที่ส่งเข้ามาจะแตกความยาวของผลงานและสถานะที่เป็นไปตามข้อกำหนด / ไม่ตรงตามข้อกำหนดทั้งหมดจะถูกทำเครื่องหมายเพื่อให้ผู้อ่านอาจอนุมานการจัดอันดับของตนเองหากพวกเขาเชื่อว่าการจัดอันดับอย่างเป็นทางการใหม่นั้นไม่ยุติธรรม

ฉันขอโทษที่แก้ไขกฎนี้ในช่วงปลายเกม

CJam, 62 ตัวอักษร

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

การแลกเปลี่ยนแบบสแต็กมีแนวโน้มที่จะลอกคราบอักขระที่ไม่สามารถพิมพ์ได้ แต่คัดลอกรหัสจาก การวางนี้และวางลงในล่าม 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 ) รุ่นที่อ่อนแอของสตรีมเลขศูนย์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=

การแลกเปลี่ยนแบบสแต็กมีแนวโน้มที่จะลอกคราบอักขระที่ไม่สามารถพิมพ์ได้ แต่การคัดลอกรหัสจากการวางนี้และวางไว้ในล่าม 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 คือ coprime ถึง totient ของโมดูลัส (totient เป็นความลับดังนั้นคุณต้องเชื่อใจฉัน) ฐานต่าง ๆ จะให้ผลลัพธ์ที่ต่างกันนั่นคือวิธีแก้ปัญหานั้นไม่เหมือนใคร

ถ้าไม่มีใครสามารถใช้ประโยชน์จากเลขชี้กำลังขนาดเล็ก (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)

Java: 468

k(int[5])การป้อนข้อมูลจะได้รับเป็น ออกบิลก่อนกำหนดหากไม่เว้นระยะเท่ากัน มิฉะนั้นจะต้องใช้การคิดออกเล็กน้อยหาก hash ทั้งสิบนั้นถูกต้อง สำหรับจำนวนมาก "บิต" อาจหมายถึงสิบวินาทีหรือมากกว่านั้นดังนั้นมันอาจทำให้แครกเกอร์ได้

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

นี่คือล็อกเกอร์แบบอิงสตริงซึ่งขึ้นอยู่กับจำนวนอักขระที่ป้อนเข้าและอินพุตเฉพาะ ลำดับอาจขึ้นอยู่กับการอ้างอิงวัฒนธรรมป๊อปที่คลุมเครือ มีความสุข!

บิต ungolfed:

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

Python, 147

แก้ไข: เวอร์ชันที่สั้นกว่าตามความคิดเห็นของ Dennis ฉันอัปเดตลำดับด้วยเพื่อหลีกเลี่ยงการรั่วไหลของข้อมูลใด ๆ

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

ป.ล. มีความสำคัญต่อ a[0]ฐานะที่เป็นหมายเลขของตัวเองและฉันต้องการเห็นใครบางคนชี้ให้เห็นในความคิดเห็น!

แก้ไข:

วิธีการแก้: 6174, 48216, 90258, 132300, 174342

หมายเหตุเกี่ยวกับการแคร็ก:

ในขณะที่นี่ไม่ใช่วิธีที่ใช้ (ดูความคิดเห็น) ฉันได้เกิดการถอดรหัสตัวเลขของตัวเองด้วย bruteforce ที่ง่ายมาก ฉันเข้าใจแล้วตอนนี้มันเป็นสิ่งสำคัญอย่างยิ่งที่จะทำให้ตัวเลขมีขนาดใหญ่ รหัสต่อไปนี้สามารถถอดรหัสตัวเลขใด ๆ ที่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วงนี้ทำลายงานของฉันในไม่กี่นาที

มาติกา 80 67

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

วิ่ง:

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

น่าจะเป็นเรื่องง่ายที่จะแตกอาจมีหลายวิธีแก้ไข

ปรับปรุง:ปรับปรุงการเล่นกอล์ฟโดยทำในสิ่งที่ Martin Büttnerแนะนำ การทำงานของฟังก์ชั่นและปุ่มไม่เปลี่ยนแปลง

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 สำหรับการเล่นกอล์ฟต่อไป ฉันตระหนักในระหว่างการแก้ไขว่ามีข้อบกพร่องเช่นเดียวกับข้อบกพร่องในอัลกอริทึมของฉันบางทีฉันอาจจะโชคดีขึ้นในครั้งต่อไป

วิชาคณิตศาสตร์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 *)

Cracked by @Dennis in 2 hours

Just a simple one to get things started - I fully expect this to be quickly cracked.

Pyth, 13

h_^ZqU5m-CGdQ

Takes comma separated input on STDIN.

Run it like this (-c means take program as command line argument):

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

Fixed the program - I had not understood the spec.

This language might be too esoteric for this competition - If OP thinks so, I will remove it.

Lua 105

I suspect it won't be long before it's cracked, but here we go:

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

(spaces added for clarity, but are not part of count)

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

I had to put in a lot of error handling logic and this can definitely be golfed down a lot more. It will print a 1 when you get the right five numbers. It will hopefully print a 0 for everything else (might be errors or nothing, I don't know). If anyone wants to help improve the code or golf it more, feel free to help out!

Call with:

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

Ruby - 130

Based on Linear Feedback Shift Register. Inputs by command line arguments.
Should be unique based on the nature of LFSRs. Clue: ascending and all positive.

Will give more clues if no one solves it soon.

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

Ruby, 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

Should be fun. Who needs math?

CJam, 49 characters

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

Try it online.

How it works

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

%!

The result will be 1 if and only if the second integer is a factor of the first, which is a product of two primes: the one corresponding to the secret sequence and another that doesn't correspond to any valid sequence. Therefore, the solution is unique.

Factorizing a 512 bit integer isn't that difficult, but I hope nobody will be able to in 72 hours. My previous version using a 320 bit integer has been broken.

Example run

$ 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

Converts the inputs to a number of data types and performs some manipulations relevant to each data type along the way. Should be fairly easily reversed for anyone that takes the time.

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 (Cracked by Dennis)

Go here for my updated submission.

Could probably be golfed a little more thoroughly. Admittedly, I haven't taken the time to prove the key is unique (it probably isn't) but its definitely on the order of a hash collision. If you crack it, please share your method :)

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 by Orby -- Cracked

https://codegolf.stackexchange.com/a/36810/31064 by Orby has at least two keys:

13 103 193 283 373
113 173 233 293 353

Orby asked for the method I used to crack it. Function p checks whether x is prime by checking x%i==0 for all i between 2 and x (though using (x/i)*i==x instead of x%i==0), and returns true if x is a prime number. Function f checks that all of a, b, c, d and e are prime. It also checks whether the number m, a concatenation of the decimal representations of e, d, c, b and a (in that order), is prime. The key is such that a,b,c,d,e and m are all prime.

Green and Tao (2004) show that there exist infinitely many arithmetic sequences of primes for any length k, so we just need to look for these sequences that also satisfy m being prime. By taking long long as being bounded by -9.223372037e+18 and 9.223372037e+18, we know that for the concatenated string to fit into long long, the numbers have an upper bound of 9999. So by using a python script to generate all arithmetic sequences within all primes < 10000 and then checking whether their reverse concatenation is a prime, we can find many possible solutions.

For some reason I came up with false positives, but the two above are valid according to the program. In addition there may be solutions where e is negative and the rest are positive (p uses the modulus of x), but I didn't look for those.

The keys I gave are all arithmetic sequences but Orby's script doesn't appear to actually require the inputs to be an arithmetic sequence, so there may be invalid keys too.

MATLAB: Apparently invalid

Very simple, you just have to generate the right random number.

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

It can still error out, but that shouldn't be a problem.

MATLAB (with Symbolic Toolbox), 173 characters

This isn't an official entry and won't count towards anyone's cracking score, but it will net you mad bragging rights. ;)

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

The symbolic toolbox is only required to handle subtraction of big integers.

Brute forcing it should be a dog, but if you're familiar with the series it involves, the solution is trivial.

Python 2 (91)

Edit: This isn't allowed because the argument for uniqueness is probabilistic. I give up.

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

Takes lists of integers as input, like [1,2,3,4,5].

The loop is meant to operate on the inputs in an annoying way, leaving a tower of sums and exponents. The idea is like discrete log, but with messy complication instead of mathematical simplicity. Maybe the compositeness of the of the modulus is a vulnerability, in which case I could make it something like 7**58+8.

I don't really know how I'd prove that my key is the only one, but the range of outputs is at least 10 times bigger than the range of inputs, so probably? Though maybe only a small fraction of potential outputs are achievable. I could always increase the number of digits at the cost of characters. I'll leave it up to you to decide what's fair.

Happy cracking!

Mathematica - 72

Version 2 of my script, with the same key as the one intended for my version 1.

This basically removes negative prime numbers for NextPrime.

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

Running:

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

Python, 86 characters

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

Enter the numbers like 1,2,3,4,5.

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

Python, 78

(Cracked by Tyilo in 14 mins)

Fun!

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

Okay, it doesn't display properly here :(

Expects a list of five numbers, eg. [1,2,3,4,5]

CJam, 37 characters (broken)

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

Try it online.

How it works

See my new answer.

Example run

$ 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 (Cracked)

This is the same idea as my previous submission, golfed more thoroughly, with a bug corrected that passed 0,0,0,0,0 (Thanks to Dennis for pointing out the bug). Compile with -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);}