लॉकर्स बनाम क्रैकर्स: द फाइव-एलिमेंट सीक्वेंस

31

चुनौती

एक सरल "जासूस बनाम जासूस" चुनौती।

निम्नलिखित विशिष्टताओं के साथ एक कार्यक्रम लिखें:

  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। यदि इनपुट्स (क्रम में) इन पांच नंबरों से मेल खाते हैं, और 0 अन्यथा तो आपका कार्यक्रम 1 पर लौटना चाहिए।

कृपया ध्यान दें कि कुंजी की सुरक्षा के साधन आपके स्वयं के उपन्यास डिजाइन के होने चाहिए। इसके अलावा, संभाव्य समाधान जो किसी भी गैर-अनिर्दिष्ट संभावना के साथ झूठी सकारात्मक लौट सकते हैं, की अनुमति नहीं है। विशेष रूप से, कृपया मानक क्रिप्टोग्राफिक हैश के लिए पुस्तकालय कार्यों सहित किसी भी मानक क्रिप्टोग्राफिक हैश का उपयोग न करें।

स्कोरिंग

प्रति वर्ण गणना में सबसे छोटा गैर-क्रैक जमा (ओं) को विजेता घोषित किया जाएगा।

यदि कोई भ्रम है, तो कृपया बेझिझक पूछें या टिप्पणी करें।

द काउंटर-चैलेंज

सभी पाठकों, जिनमें से अपने स्वयं के कार्यक्रम प्रस्तुत किए गए हैं, उन्हें "दरार" प्रस्तुत करने के लिए प्रोत्साहित किया जाता है। जब संबंधित कुंजी अनुभाग में इसकी कुंजी पोस्ट की जाती है, तो सबमिशन क्रैक हो जाता है। यदि सबमिशन संशोधित या क्रैक किए बिना 72 घंटे तक रहता है, तो इसे "सुरक्षित" माना जाता है और इसे क्रैक करने में किसी भी बाद की सफलता को प्रतियोगिता के लिए नजरअंदाज कर दिया जाएगा।

अद्यतन क्रैकिंग स्कोर नीति के विवरण के लिए नीचे "अस्वीकरण" देखें।

क्रैक किए गए सबमिशन को विवाद से समाप्त कर दिया जाता है (बशर्ते वे "सुरक्षित" न हों)। उन्हें संपादित नहीं किया जाना चाहिए। यदि कोई पाठक एक नया कार्यक्रम प्रस्तुत करना चाहता है, तो उसे एक अलग उत्तर में ऐसा करना चाहिए।

उच्चतम स्कोर वाले पटाखे (ओं) को विजेता कार्यक्रमों के डेवलपर्स के साथ विजेता घोषित किया जाएगा।

कृपया अपनी खुद की सबमिशन क्रैक न करें।

शुभकामनाएँ। :)

लीडरबोर्ड

दंडात्मक स्टैंडिंग (डेनिस 'सीजेएम 49 सबमिशन की लंबित सुरक्षा)।

सुरक्षित लॉकर

  1. सीजाम 49, डेनिस
  2. सीजेम 62, डेनिस सुरक्षित
  3. सीजाम 91, डेनिस सुरक्षित
  4. पायथन 156, मार्टन बर्ट सुरक्षित
  5. पर्ल 256, चिलम्रेजिक सेफ
  6. जावा 468, जियोबिट्स सुरक्षित

अजेय पटाखे

  1. पीटर टेलर [रूबी 130, जावा 342, गणितज्ञ 146 *, गणितज्ञ 72 *, सीजेएम 37]
  2. डेनिस [पायथ 13, पायथन 86 *, लुआ 105 *, गोल्फस्क्रिप्ट 116, सी 239 *]
  3. मार्टिन ब्यूटनर [जावास्क्रिप्ट 125, पायथन 128 *, रूबी 175 *, रूबी 249 *]
  4. टायिलो [सी 459, जावास्क्रिप्ट 958 *]
  5. फ़्रेडिडेनेट्स [गणितज्ञ 67 *]
  6. इल्मारी करोनें [पायथन 272 *]
  7. नाइट्रस [C 212 *]

* गैर-अनुपालन प्रस्तुत

अस्वीकरण (अद्यतित 11:15 बजे ईएसटी, 26 अगस्त)

स्कोरिंग समस्याओं के साथ अंत में महत्वपूर्ण द्रव्यमान तक पहुंच गया (दो तिहाई दरारें प्रस्तुत की गई हैं, इस प्रकार अब तक गैर-अनुपालन योग्य हैं), मैंने शीर्ष पटाखे को क्रैक किए गए सबमिशन की संख्या (प्राथमिक) और कुल मिलाकर क्रैक किए गए सबमिशन में पात्रों की संख्या के आधार पर रैंक किया है। (माध्यमिक)।

पहले की तरह, सटीक प्रस्तुतियाँ टूट गईं, प्रस्तुतियाँ की लंबाई, और उनके अनुरूप / गैर-अनुपालन की स्थिति सभी को चिह्नित किया गया है ताकि पाठकों को अपनी रैंकिंग का अनुमान हो सके अगर वे मानते हैं कि नई आधिकारिक रैंकिंग अनुचित हैं।

इस खेल में देर से नियमों में संशोधन के लिए मेरी माफी।

code-golf  sequence  obfuscation  cops-and-robbers 
— COTO
स्रोत
6
आप कैसे सत्यापित करेंगे कि कार्यक्रम बिंदु 4 से मिलते हैं? क्या आप उम्मीद करते हैं कि लोग प्रमाण जोड़ने के लिए अपने सुरक्षित उत्तरों को संपादित करेंगे। क्या संभाव्य प्रस्तुतियाँ यह मानने के आधार पर अनुमत हैं कि हैश फ़ंक्शन आदर्श हैं और 48-बिट (ऊपर आपके अनुमान के अनुसार) के किसी अन्य तत्व के साथ टकराव की संभावना नगण्य है?
— पीटर टेलर
2
स्कोरिंग प्रणाली पटाखे को कम से कम तालों को नजरअंदाज करने के लिए प्रोत्साहित करती है क्योंकि वे दो छोटे तालों की तुलना में दो लंबे तालों को तोड़कर बेहतर स्कोर करते हैं।
— पीटर टेलर
3
@ COTO मुझे लगता है कि समस्या यह है कि आप केवल 2 क्रैकिंग स्कोर प्राप्त कर सकते हैं, और केवल सबसे छोटा। तो क्यों न इंतज़ार किया जाए और उम्मीद और लंबे समय तक दिखाई दें? उदाहरण के लिए, मार्टिन के पास अब मेरे (लंबे) लॉक को क्रैक करने के लिए कोई प्रोत्साहन नहीं है , क्योंकि वह पहले से ही दो छोटे लोगों को क्रैक कर चुका है। जो कोई भी मेरा पीछा करता है, वह अब उसे एक दूसरे को भी किए बिना हरा देगा।
— Geobits 17
1
मुझे लगता है कि एक बेहतर स्कोरिंग प्रणाली प्रश्न और दरार के बीच कुल समय का योग हो सकती है। इस तरह, आसान लोगों का एक समूह क्रैकिंग पीटा जा सकता है, और असली इनाम वास्तव में कठिन लोगों को क्रैक करने से आता है।
— isaacg
1
मैं गोल्फ के लिए नया हूं, इसलिए शायद यह एक बेवकूफ सवाल है, इसके लिए खेद है। वर्णों में कोड लंबाई क्यों मापी जाती है और बाइट्स में नहीं? उत्तरार्द्ध वस्तुतः स्मृति स्थान है जो एक कार्यक्रम में रहता है, इसलिए मेरे लिए यह अधिक तार्किक लगता है। उदाहरण के लिए। CJam का उत्तर वर्णों में सबसे छोटा है, लेकिन जब इसके आकार (यूनिकोड के कारण 326) को देखते हैं तो यह शीर्ष 5 में भी नहीं होता है। इसलिए मुझे आश्चर्य है कि क्या बाइट्स के बजाय चार्ट को गिनना गोल्फिंग में आम सम्मेलन है?
— freddieknets 13

जवाबों:

3

CJam, 62 वर्ण

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

स्टाॅक एक्सचेंज में गैर-कानूनी चरित्रों का ताना-बाना होता है , लेकिन इस पेस्ट से कोड को कॉपी करके CJam दुभाषिया में चिपकाना मेरे लिए ठीक काम करता है।

यह काम किस प्रकार करता है

यूनिकोड स्ट्रिंग को 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 का उपयोग करता है (देखें ट्रिगियम की तरह बीजगणित विश्लेषण बीजगणित ), धारा सिफर ट्रिवियम का एक कमजोर संस्करण ।

यह प्रोग्राम पूर्णांक के अनुक्रम को प्रारंभिक स्थिति के रूप में उपयोग करता है, राज्य को 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
— डेनिस
स्रोत
6

CJam, 91 वर्ण

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

स्टाॅक एक्सचेंज में गैर-कानूनी चरित्रों का ताना-बाना होता है , लेकिन इस पेस्ट से कोड को कॉपी करके CJam दुभाषिया में चिपकाना मेरे लिए ठीक काम करता है।

यह काम किस प्रकार करता है

पूर्णांक के साथ यूनिकोड स्ट्रिंग को बदलने के बाद (आधार संख्या 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) का शोषण नहीं कर सकता, तब तक इस ताला को तोड़ने का सबसे कारगर तरीका मापांक को कारक बनाना है (देखें आरएसए समस्या )। मैंने मापांक के लिए 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
— डेनिस
स्रोत
मैंने एक नया संस्करण पोस्ट किया है क्योंकि मैं पहले से एक अनावश्यक चरित्र को हटाना भूल गया हूं। गुप्त अनुक्रम अभी भी समान है, इसलिए आप किसी एक को क्रैक करने का प्रयास कर सकते हैं।
— डेनिस
FYI करें, मैं अपने फैक्टरिंग प्रयास को निरस्त कर रहा हूं। खुद को 276 घंटे की समय सीमा निर्धारित करें, लेकिन यह सिर्फ कारक आधार के निर्माण के लिए था। उस समय में यह found 1740001 rational and 1739328 algebraic entries; चूंकि उन्हें संसाधित करने के लिए लगभग 100 घंटे थे, और रिपोर्ट sieving in progress b = 46583, 0 complete / 0 batched relations (need 44970493)।
— पीटर टेलर
@PeterTaylor: ऐसा लगता है कि 512 बिट्स ओवरकिल थे। क्या आप मेरे अन्य उत्तर या इस एक में पूर्णांक को कारक बनाने की कोशिश कर रहे थे?
— डेनिस
ओह, उफ़। हाँ, अन्य एक।
— पीटर टेलर
4

अजगर - 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।)

— फ़ाल्को
स्रोत
3
32416190039,32416190047,32416190055,32416190063,32416190071
— मार्टिन एंडर
वाह, यह तेज़ था! आप सही हे! और मैं बाहर हूं।
— फाल्को
3
Btw, यह वास्तव में मान्य नहीं है, क्योंकि आपके पाँच पूर्णांक 32-बिट पूर्णांक में फिट नहीं होते हैं।
— मार्टिन एंडर
4

जावा: 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;
}
— Geobits
स्रोत
1
यदि इनपुट अंकगणितीय अनुक्रम नीचे उतर रहा है तो आपका कोड लटका रहता है। या कम से कम, वास्तव में लंबा समय लगता है। जो मुझे लगता है कि गुप्त कोड चढ़ रहा है ...
— कीथ रान्डेल
3
@KeithRandall ऊप्स। अवरोही क्रम बनाने के लिए चार बाइट्स जोड़ते हैं , जो आपके विश्वास को और मजबूत करते हुए असामान्य रूप से कम समय लेता है।
— Geobits
4

जावा: 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;
}
— Geobits
स्रोत
2
8675309? 90210?
— मलाची
1
@ मालेची दो बकाया संदर्भ, इसमें कोई संदेह नहीं है, लेकिन मैं इस अभ्यास के लिए उनकी प्रयोज्यता की न तो पुष्टि कर सकता हूं और न ही इनकार कर सकता हूं।
— Geobits
योग्य, मुझे पूरी तरह से पता नहीं चला है कि यह चुनौती पूरी तरह से कैसे काम करती है, मैं इसे बाद में एक शॉट दे सकता हूं जब मैं घर पर हूं।
— मालाची
1
प्रारंभिक शब्द है -8675309, डेल्टा है 5551212।
— पीटर टेलर
@PeterTaylor अच्छी तरह से किया :)
— Geobits
4

अजगर, 147

संपादित करें: डेनिस की टिप्पणी पर आधारित छोटा संस्करण। मैंने किसी भी जानकारी को लीक करने से बचने के लिए अनुक्रम को भी अपडेट किया।

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

असतत लघुगणक समस्या के आधार पर, जो माना जाता है कि यह अनियंत्रित है, हालांकि मैं जिस प्राइम का उपयोग कर रहा हूं वह शायद सुरक्षित होने के लिए बहुत छोटा है (और इसके अन्य मुद्दे हो सकते हैं, मुझे नहीं पता)। और आप इसे बेशक कर सकते हैं, क्योंकि केवल अज्ञात दो 32-बिट पूर्णांक हैं।

— Maarten Baert
स्रोत
असतत लघुगणक एक बहुत कठिन है जो मैंने सोचा था। मेरा पटाखा इस पर 26 घंटे के लिए है। मैं हार मानता हूं।
— डेनिस
आप साइन इनीशियल c=1, कंप्यूटिंग c=(c<<32)+dऔर उसके अनुसार स्थिरांक को बदलकर समस्या का समाधान कर सकते हैं ।
— डेनिस
3

जावास्क्रिप्ट 125

यह एक बहुत जल्दी टूट जाना चाहिए। मैं कुछ मजबूत के साथ पालन करेंगे।

function unlock(a, b, c, d, e)
{
    return (e << a == 15652) && (c >> a == 7826) && (e - b == d) && (d - c - a == b) ? 1 : 0;
}
— rdans
स्रोत
6
0, 3913, 7826, 11739, 15652
— मार्टिन एंडर
हाँ, आपको यह मिला :)
— rdans
3

रूबी, 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, यह काफी अनोखा है (जो एक मामूली सुराग है)। एसटीडीआईएन के माध्यम से पांच नंबर लेता है, किसी भी गैर-अंक, गैर-न्यूलाइन वर्ण या वर्णों द्वारा सीमांकित। STDOUT में आउटपुट।

— histocrat
स्रोत
हां, भूल गए कि वे हस्ताक्षर किए गए थे।
— हिस्टोक्रेट 16
2
622238809,1397646693,2173054577,2948462461,3723870345(मेरे पिछले अनुमान में गलती थी, लेकिन यह एक परीक्षण है)। मुझे नहीं लगता कि यह मान्य है, क्योंकि अंतिम संख्या एक हस्ताक्षरित 32-बिट पूर्णांक में फिट नहीं है।
— मार्टिन एंडर
3

गोल्फस्क्रिप्ट (116 वर्ण)

अंतरिक्ष-पृथक पूर्णांकों के रूप में इनपुट लेता है।

~]{2.5??:^(&}%^base 2733?5121107535380437850547394675965451197140470531483%5207278525522834743713290685466222557399=
— पीटर टेलर
स्रोत
2
-51469355 -37912886 -24356417 -10799948 2756521
— डेनिस
अच्छा काम। क्या आपने छोटे एक्सपोनेंट का शोषण किया?
— पीटर टेलर
2
नहीं, मैंने मापांक फैक्टर किया है। प्राइमो की मल्टीपल पोलिनोमियल क्वाड्रेटिक चलनी और PyPy का उपयोग करके केवल 13 सेकंड का समय लिया ।
— डेनिस
उस मामले में मैं अपने वर्तमान गोल्फिंग को एक कॉम्पैक्ट रूप से व्यक्त मापांक का उपयोग करके इसे छोड़ सकता हूं। यदि परिणाम को 1024 बिट्स की तरह कुछ होना चाहिए, तो वह फैक्टरिंग से सुरक्षित हो सकता है, तब भी आधार-256 प्रतिनिधित्व का उपयोग करना बहुत लंबा होने वाला है।
— पीटर टेलर
मुझे आशा नहीं है। मेरा उत्तर आपके समान विचार का उपयोग करता है, लेकिन एक 512 बिट मापांक और उससे भी छोटे घातांक (13) के साथ। 72 घंटे की समय सीमा को देखते हुए, यह पर्याप्त हो सकता है ...
— डेनिस
3

C 459 बाइट्स

टायिलो द्वारा हल किया गया - पढ़ें संपादित करें

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

खुर के बारे में एक नोट:

हालांकि यह प्रयोग की जाने वाली विधि नहीं है (टिप्पणियों को देखें), मैंने बहुत आसान ब्रूटफोर्स के साथ अपने सिफर को क्रैक करने के लिए किया। मैं समझता हूं कि संख्याओं को बड़ा करने के लिए अब यह महत्वपूर्ण है। निम्न कोड किसी भी सिफर को क्रैक कर सकता है, जहां के 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, इस पाश ने एक मिनट के भीतर मेरे काम को तोड़ दिया।

— BrainSteel
स्रोत
6
समाधान: 6174, 48216, 90258, 132300, 174342।
— Tyilo
वाह जो तेज था। अच्छा है। Bruteanted, या क्या आपने कुछ चतुर पाया जो मैंने याद किया?
— ब्रेनसैट
मैं Mathematica का प्रतीकात्मक मूल्यांकन इसलिए की तरह इस्तेमाल किया: ghostbin.com/paste/jkjpf : स्क्रीनशॉट i.imgur.com/2JRo7LE.png
— Tyilo
संपादन संपादित करें: मैंने मूल रूप से एक ही काम किया था, लेकिन ऊपरी भाग को 500k पर फिट किया। जवाब मिला और देखा कि टायलो ने पहले ही इसे पोस्ट कर दिया था :(
— जोबिट्स
@Geobits यह आश्चर्यजनक रूप से सटीक अनुमान है। उन संख्याओं के सिरों पर कुछ और 0 रखना चाहिए।
— BrainSteel
3

गणितज्ञ hem० ६hem

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

चल रहा है:

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

दरार करने के लिए शायद बहुत आसान है, कई समाधान भी हो सकते हैं।

अपडेट: मार्टिन ब्यूटनर ने जो सुझाव दिया था, उसे करके गोल्फ को बेहतर बनाया। फ़ंक्शन की कार्यक्षमता और कुंजी परिवर्तित नहीं हुई है।

— Tyilo
स्रोत
@ मार्टिनबटनर जब आप उन्हें क्रैक करते हैं तो उच्च स्कोर प्राप्त करने के लिए उत्तर सुधारते हैं। स्मार्ट; पी
— 18
हुह, पता चला कि मैंने काउंटर चुनौती के लिए स्कोरिंग के बारे में पैराग्राफ को छोड़ दिया। मैंने सोचा कि यह बिना किसी स्कोर के केवल मज़े के लिए था। हालांकि मुझे नहीं लगता कि यह मेरे लिए समाधानों को छोटा करेगा क्योंकि मैं दरार डालना चाहता हूं क्योंकि इससे मेरा स्कोर कम हो जाएगा।
— मार्टिन एंडर
4
{58871,5592,-47687,-100966,-154245}
— freddieknets
इसे बनाते समय @freddieknets का उपयोग नहीं किया। नहीं पता था कि NextPrimeनकारात्मक मूल्यों को वापस कर सकता है। तुम्हें यह कैसे मिला?
— टायिलो
तब आपकी कुंजी अद्वितीय नहीं है: पी। मैंने अभी कुछ परीक्षण किए हैं - वास्तव में ऐसी बहुत सी संख्याएँ नहीं हैं जहाँ NextPrime [#] - # 31 का मूल्यांकन करता है, इसलिए इसे क्रैक करने का एक आसान तरीका है।
— freddieknets
2

पायथन 27, 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]

संपादित करें: आगे की गोल्फिंग के लिए धन्यवाद। मैंने संपादन के दौरान महसूस किया कि मेरे एल्गोरिथ्म में एक बग के साथ-साथ एक दोष भी था, शायद अगली बार मुझे बेहतर भाग्य मिलेगा।

— stokastic
स्रोत
5
यह तर्कों की पुनरावृत्ति के तहत अपरिवर्तनीय है, इसलिए यह एक वैध लॉकर नहीं है।
— पीटर टेलर
इसके अलावा, मुझे संदेह है कि पोस्ट किया गया कोड छोटी गाड़ी है: कुंजी 121174841 121174871 121174901 121174931 121174961काम करती है, लेकिन केवल अगर [1,3,5,7]लाइन 7 की सूची को बदल दिया जाए [1,3,5,7,11]।
— इल्मरी करोनन
डार, हाँ मैं बस अपने टाइपो को ठीक कर रहा था, जिसके दौरान मैंने अपने एल्गोरिथ्म में एक महत्वपूर्ण गलती की, जिससे यह दरार करना बहुत आसान हो गया: |
— स्टोकैस्टिक
दरअसल, बग को खोजना और उसे ठीक करना मुश्किल हिस्सा था; अपने एल्गोरिथ्म दिया, निरंतर फैक्टरिंग कोशिश करने के लिए एक स्पष्ट बात की तरह था।
— इल्मरी करोनन
2

गणितज्ञ 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 *)
— freddieknets
स्रोत
1
प्रारंभिक शब्द 256208, डेल्टा -5।
— पीटर टेलर
डांग, फिर भी यह अद्वितीय नहीं है, क्योंकि यह मेरी मूल कुंजी नहीं है। क्या तुमने क्रूरता की?
— freddieknets
इसका परीक्षण करें, मुझसे गलती हो सकती है क्योंकि मेरे पास परीक्षण करने के लिए गणितज्ञ की पहुंच नहीं है। प्रत्येक चरण जानवर बल का उपयोग कर रहा है, लेकिन यह कंप्यूटर का अधिक समय नहीं है। IntegerDigitsप्रारंभिक अवधि और डेल्टा के लिए उम्मीदवारों को प्राप्त करने के लिए और फिर कारक के उत्पादन के लिए दृष्टिकोण पीछे काम करना है ।
— पीटर टेलर
लेकिन इस तरह से कोई भी तरीका अनूठा नहीं हो सकता है। पाँच इनपुटों में से दूसरे का उपयोग केवल एक राशि में किया जाता है जिसे पास किया जाता है NextPrime; यदि हम इसे प्लस या माइनस एक से बदलते हैं, तो उनमें से कम से कम एक ही अगले प्राइम देगा।
— पीटर टेलर
हां, लेकिन अंकगणितीय अनुक्रम के लिए -as आवश्यक इनपुट है- यह अद्वितीय होना चाहिए था।
— freddieknets 20
1

2 घंटे में @ डेनिस द्वारा क्रैक किया गया

चीजों को शुरू करने के लिए बस एक सरल - मुझे पूरी उम्मीद है कि यह जल्दी से टूट जाएगा।

अजगर , १३

h_^ZqU5m-CGdQ

STDIN पर कॉमा को अलग इनपुट देता है।

इसे इस तरह से चलाएँ (-c का अर्थ है कमांड लाइन तर्क के रूप में कार्यक्रम लें):

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

कार्यक्रम तय किया - मैं कल्पना को समझ नहीं पाया था।

यह भाषा इस प्रतियोगिता के लिए बहुत गूढ़ हो सकती है - अगर ओपी ऐसा सोचता है, तो मैं इसे हटा दूंगा।

— isaacg
स्रोत
7
क्या आपने अभी दिया है कि 1,2,3,4,5कुंजी है?
— पीटर टेलर
1
मेरे द्वारा कोशिश की गई प्रत्येक इनपुट 1, क्या आपने आउटपुट के रूप में 1 और 0 को स्विच किया?
— टायिलो
क्षमा करें, मुझे आउटपुट बनाम रिटर्न डिस्टिंक्शन की समझ नहीं थी - प्रोग्राम को अब काम करना चाहिए। एक ही अंतर्निहित एल्गोरिथ्म।
— isaacg
3
97,96,95,94,93(मैंने सिर्फ अपना क्रैकिंग स्कोर मार दिया।)
— डेनिस
@ डेनिस अच्छा किया। क्रैकिंग स्कोर सिस्टम को बदलने की आवश्यकता है - यह वास्तव में कुछ अजीब प्रोत्साहन पैदा कर रहा है।
— isaacg
1

लुआ 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

(रिक्त स्थान स्पष्टता के लिए जोड़े गए, लेकिन गणना का हिस्सा नहीं हैं)

— काइल कानोस
स्रोत
3, 7, 11, 15, 19या6, 14, 22, 30, 38
— डेनिस
@ डेनिस: दुख की बात यह है कि दोनों में से कोई भी नहीं है। गैर-विशिष्टता सुनिश्चित करने के लिए मुझे थोड़ा बाद में इस पर काम करना होगा।
— काइल कानोस
t1==0जब Sभी बढ़ रहा है। इसके अलावा, दोनों स्थितियां सजातीय हैं; अगर Sएक समाधान है, तो है kS।
— डेनिस
1

पर्ल - 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);
— hmatt1
स्रोत
1

रूबी - 130

रैखिक प्रतिक्रिया पारी रजिस्टर के आधार पर। कमांड लाइन तर्कों द्वारा इनपुट।
LFSRs की प्रकृति के आधार पर अद्वितीय होना चाहिए। सुराग: आरोही और सभी सकारात्मक।

अगर कोई जल्द ही इसका हल निकाल लेता है तो और सुराग देगा। 

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
— vectorized
स्रोत
3
प्रारंभिक मूल्य 781783, वेतन वृद्धि 17982811
— पीटर टेलर
@PeterTaylor अर्घ ... =)
— वेक्टर
1

रूबी, 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

मजेदार होना चाहिए। गणित की जरूरत किसे है?

— histocrat
स्रोत
2
309, 77347, 154385, 231423, 308461लेकिन मुझे नहीं लगता कि यह अद्वितीय है।
— मार्टिन एंडर
हाँ, यह नहीं है। उसी रेगेक्स (यानी पहले दो नंबरों का उत्पाद) के लिए, मैं भी ढूंढता हूं 103, 232041, 463979, 695917, 927855और 3, 7966741, 15933479, 23900217, 31866955। और मुझे पूरा यकीन है कि अतिरिक्त +s का उपयोग करके अन्य मान्य rexxes हैं ।
— मार्टिन एंडर
क्षमा करें, मुझे लगता है कि मैंने परीक्षण स्ट्रिंग को गड़बड़ कर दिया है। एक अद्वितीय कारक के साथ केवल एक regexp होना चाहिए था।
— histocrat
यदि आप इसे ठीक करने का प्रयास करना चाहते हैं, तो सुनिश्चित करें कि आपके पास मात्रात्मक मात्रा को ध्यान में रखना चाहिए। मैं सम्मिलित ()या समान करके एक बड़ा, समतुल्य रेगीक्स भी बना सकता हूं ।
— मार्टिन एंडर
1

सीजेम, 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
— डेनिस
स्रोत
मैंने 24 घंटे से अधिक समय तक इसे चलाने के लिए msieve किया है, लेकिन चूंकि इसकी स्व-लागू समय सीमा 276.51 CPU-घंटे है और मैंने इसे केवल एक CPU दिया है जो मैं आशावादी नहीं हूं।
— पीटर टेलर
0

जावास्क्रिप्ट 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;
}
— rdans
स्रोत
5
ब्रूट मजबूर:320689, 444121, 567553, 690985, 814417
— टिलो
@ टायिलो यदि आप अभी रुकते हैं, तो मुझे लगता है कि कोई भी पटाखा आपके स्कोर को नहीं हरा सकता है। ;)
— मार्टिन एंडर
2
@ मार्टिनबटनर जब तक यह ओपी प्रति 512 से कम नहीं हो सकता, मुझे नहीं लगता कि यह मायने रखता है।
— जियोबिट्स 25'14
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);}
— या द्वारा
स्रोत
1
तो 0 0 0 0 0,?
— डेनिस
आहें कि एक बग था, लेकिन हाँ जो काम करता है।
— ओर्बी
मैंने एक सही संस्करण के साथ अद्यतन किया है जो थोड़ा अधिक दिलचस्प होना चाहिए;)
— ऑर्बी
यहाँ सही संस्करण देखें ।
— Örby
0

सी, 212 ओरबी द्वारा - फटा

https://codegolf.stackexchange.com/a/36810/31064 Orby के पास कम से कम दो चाबियां हैं:

13 103 193 283 373
113 173 233 293 353

ऑर्बी ने मुझे इसे क्रैक करने के लिए इस्तेमाल किया विधि के लिए कहा। फ़ंक्शन p जाँचता है कि क्या x x%i==02 और x के बीच सभी के लिए जाँच करके प्रधान है (हालांकि (x/i)*i==xइसके बजाय का उपयोग कर रहा हैx%i==0 ) के , और यदि x एक अभाज्य संख्या है तो सही है। फंक्शन f जाँचता है कि a, b, c, d और e सभी प्रमुख हैं। यह भी जाँचता है कि क्या नंबर m, e, d, c, b और a (उस क्रम में) के दशमलव अभ्यावेदन का एक संघटन है, जो प्रमुख है। कुंजी ऐसी है कि ए, बी, सी, डी, ई और एम सभी प्रमुख हैं।

ग्रीन और ताओ (2004) बताते हैं कि किसी भी लम्बाई k के लिए primes के अनंत रूप से कई अंकगणितीय अनुक्रम मौजूद हैं, इसलिए हमें बस इन दृश्यों की तलाश करने की आवश्यकता है जो मी प्राइम को संतुष्ट करते हैं। लंबे समय तक बंधे रहने के कारण -9.223372037e + 18 और 9.223372037e + 18, हम जानते हैं कि समवर्ती स्ट्रिंग को लंबे समय तक फिट रहने के लिए, संख्याओं की ऊपरी सीमा 9999 है। इसलिए सभी को उत्पन्न करने के लिए एक पायथन स्क्रिप्ट का उपयोग करें। सभी अपराधों के भीतर अंकगणितीय अनुक्रम <10000 और फिर यह जाँचना कि क्या उनका उलटा संयोजन एक प्रमुख है, हम कई संभावित समाधान पा सकते हैं।

किसी कारण से मैं झूठी सकारात्मकता के साथ आया था, लेकिन उपरोक्त दोनों कार्यक्रम के अनुसार मान्य हैं। इसके अलावा ऐसे समाधान हो सकते हैं जहां ई नकारात्मक है और बाकी सकारात्मक हैं (पी एक्स के मापांक का उपयोग करता है), लेकिन मैंने उन लोगों की तलाश नहीं की।

मैंने जो चाबियां दीं, वे सभी अंकगणितीय क्रम हैं, लेकिन ऑर्बी की स्क्रिप्ट में वास्तव में इनपुट के लिए अंकगणितीय अनुक्रम होने की आवश्यकता नहीं है, इसलिए अमान्य चाबियाँ भी हो सकती हैं।

— नाइट्रोजनवाला
स्रोत
0

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

यह अभी भी त्रुटि कर सकता है, लेकिन यह एक समस्या नहीं होनी चाहिए।

— डेनिस जहरुद्दीन
स्रोत
1
यह दृष्टिकोण टिप्पणियों में निषिद्ध है। यदि यह प्रश्न में उल्लिखित नहीं है, तो एक संपादन का प्रस्ताव करें। माफ़ कीजिये।
— पीटर टेलर
@PeterTaylor मुझे लगता है कि मैं तब बाहर हूं, मैं इसे बिना स्कोर के यहां छोड़ दूंगा क्योंकि मैं उत्सुक हूं कि क्या कोई कमजोरी पा सकता है।
— डेनिस जहरुद्दीन
0

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

प्रतीकात्मक टूलबॉक्स केवल बड़े पूर्णांकों के घटाव को संभालने के लिए आवश्यक है।

जानवर मजबूर होना चाहिए यह एक कुत्ता होना चाहिए, लेकिन यदि आप इसमें शामिल श्रृंखला से परिचित हैं, तो समाधान तुच्छ है।

— COTO
स्रोत
0

पायथन 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 गुना बड़ी है, इसलिए शायद? हालांकि हो सकता है कि संभावित आउटपुट का केवल एक छोटा सा हिस्सा ही प्राप्त हो। मैं हमेशा पात्रों की कीमत पर अंकों की संख्या बढ़ा सकता था। मैं यह तय करने के लिए इसे छोड़ दूंगा कि क्या उचित है।

खुश खुर!

— XNOR
स्रोत
0

गणितज्ञ - 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 *)
— Tyilo
स्रोत
यह मानते हुए कि मैंने ठीक से समझा है कि आपका कोड क्या करता है, मुझे कई समाधान मिलते हैं जिनमें से सबसे छोटा प्रारंभिक शब्द है 9244115, डेल्टा 25।
— पीटर टेलर
@PeterTaylor मैं पुष्टि कर सकता हूं कि वह वैध है।
— मार्टिन एंडर
@PeterTaylor सही है, एक और कुंजी है1073743739, 1073886396, 1074029053, 1074171710, 1074314367
— टायरो
0

पायथन, 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
— नाश्ता
स्रोत
यह एक मान्य सबमिशन नहीं है; यह इनपुट स्वीकार करता है 1,0,1,63021563418517255630720,0।
— डेनिस
@ डेनिस निश्चित। मुझे उम्मीद है कि अब यह मान्य है।
— स्नैक
1
19960211, 31167202, 42374193, 53581184, 64788175
— डेनिस
@ डेनिस सही और कमाल। मुझे लगता है कि मैं गणित में बहुत गरीब हूं।
— स्नैक
2
@ डेनिस, 6302156341851725563072032-बिट संख्या नहीं है।
— पीटर टेलर
0

पायथन, 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]

— ElectricWarr
स्रोत
1
बहुत आसान:[-481890276, -594823292, -728999970, -887503650, -1073741792]
— टायिलो
ऐसा सोचा, अच्छी तरह से किया :)
— ElectricWarr
0

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
— डेनिस
स्रोत
1
737262825 208413108 3974530688 3445680972 2916831257काम करता है, लेकिन एक अंकगणितीय प्रगति नहीं है। 3 घंटे 20 मिनट में फैक्टर। दो साल पहले ईसी 2 पर $ 75 के लिए 512-बिट संख्या स्पष्ट रूप से 72 घंटों में संभव थी, इसलिए मुझे लगता है कि यह सुरक्षित था।
— पीटर टेलर
@PeterTaylor: यह 1 रिटर्न देता है, लेकिन अंतिम तीन पूर्णांक MAX_INT से अधिक हैं, इसलिए यह एक वैध कुंजी नहीं है। कहा जा रहा है, 3 एच 20 मीटर बहुत प्रभावशाली है। एल्गोरिथ्म मैं उपयोग कर रहा था एक 256-बिट सेमिप्रेम के लिए 16 घंटे लगे ...
— डेनिस
मैंने सोचा कि वहाँ कुछ नकारात्मक संख्याएँ होनी चाहिए क्योंकि डेल्टास लगभग सही थे लेकिन काफी नहीं थे। मैं उस पर चलूँगा।
— पीटर टेलर
1
737262825 208413109 -320436607 -849286323 -1378136039
— पीटर टेलर
@PeterTaylor: यह एक है। मुझे उम्मीद है कि 512 बिट संस्करण लंबे समय तक रहता है।
— डेनिस
-2

C, 212 (क्रैक किया गया)

यह मेरे पिछले सबमिशन के समान विचार है , और अधिक अच्छी तरह से गोल्फ, बग को ठीक करने के साथ जो 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);}
— या द्वारा
स्रोत
नकारात्मक अपराधों का कोई भी क्रम (अंकगणित या नहीं) काम करेगा। दो उदाहरण: -7 -37 -67 -97 -127,-157 -127 -97 -67 -37
— डेनिस
हाँ, मेरा कोड सिर्फ बग से भरा हुआ है। जवाब नाइट्रस दिया मैं के लिए क्या देख रहा था की तर्ज पर है। लेकिन अच्छा काम और अधिक स्पष्ट जवाब बताते हैं।
— ऑर्बी
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.