पायथ, 83 82 बाइट्स
=eAQM.^GHQKf%=/H=2;1=gftgT/Q;1HJg~gGHh/H2WtG=*J=gT^2t-K=Kfq1gG^2T1=%*G=^T2Q;hS%_BJ
परीक्षण सूट
यह कार्यक्रम टोनेली-शैंक एल्गोरिथ्म को लागू करता है । मैंने इसे विकिपीडिया पृष्ठ के निकट से लिखा है। यह इनपुट के रूप में लेता है (n, p)
।
एक वर्गमूल की अनुपस्थिति को निम्नलिखित त्रुटि से सूचित किया जाता है:
TypeError: pow() 3rd argument not allowed unless all arguments are integers
यह बहुत ही जटिल गोल्फ कोड है, जिसे अनिवार्य शैली में लिखा गया है, क्योंकि यह पाइथ की अधिक सामान्य कार्यात्मक शैली के विपरीत है।
पायथ का एक सूक्ष्म पहलू =
जो मैं उपयोग कर रहा हूं , जो कि यदि एक चर द्वारा अनुसरण नहीं किया जाता है, तो अगले चर के लिए कार्यक्रम में आगे की खोज करता है, फिर उस चर के लिए निम्नलिखित अभिव्यक्ति का परिणाम बताता है, फिर उस परिणाम को लौटाता है। मैं विकिपीडिया पृष्ठ के लिए स्पष्टीकरण में उल्लेख करूंगा: टोनेली-शैंक एल्गोरिथ्म , जैसा कि मैं जिस एल्गोरिथ्म को लागू कर रहा हूं वह है।
स्पष्टीकरण:
=eAQ
A
इनपुट के रूप में एक 2-ट्यूपल लेता है, G
और H
क्रमशः और उसके मानों को निर्दिष्ट करता है, और उसका इनपुट लौटाता है। Q
प्रारंभिक इनपुट है। e
किसी अनुक्रम का अंतिम तत्व देता है। इसके बाद स्निपेट, G
है n
, H
और Q
हैं p
।
M.^GHQ
M
एक 2 इनपुट फ़ंक्शन को परिभाषित करता है g
, जहां इनपुट होते हैं G
और H
। .^
पाइथ का तेज मॉड्यूलर एक्सपेंनेशन फंक्शन है। इस स्निपेट g
का अर्थ है प्रतिपादक मॉड Q
।
Kf%=/H=2;1
f
झूठे लूप तक एक दोहराने को परिभाषित करता है, और 1
इसके इनपुट के रूप में दिए गए पुनरावृत्तियों की संख्या देता है । लूप के प्रत्येक पुनरावृत्ति के दौरान, हम H
2 से विभाजित करते हैं , H
उस मान पर सेट करते हैं, और जांचते हैं कि परिणाम विषम है या नहीं। एक बार यह हो जाए तो हम रुक जाते हैं। K
स्टोर किए गए पुनरावृत्तियों की संख्या।
एक बहुत मुश्किल बात है =2;
बिट। =
अगले चर के लिए आगे की खोज, जो है T
, इसलिए T
2 पर सेट है। हालांकि, T
एक f
लूप के अंदर पुनरावृत्ति काउंटर है, इसलिए हम वैश्विक वातावरण से ;
मूल्य प्राप्त करने के लिए उपयोग करते हैं T
। यह व्हाट्सएप के कुछ बाइट्स को बचाने के लिए किया जाता है जिन्हें अन्यथा संख्याओं को अलग करने की आवश्यकता होगी।
इस स्निपेट के बाद, K
है S
विकिपीडिया लेख (विकी) से, और H
है Q
विकी है, और T
है 2
।
=gftgT/Q;1H
अब, हमें एक द्विघात गैर-मापक मॉड खोजने की आवश्यकता है p
। हम यूलर मानदंड का उपयोग करके इसे बाध्य करेंगे। /Q2
है (p-1)/2
के बाद से, /
फर्श विभाजन है, इसलिए ftgT/Q;1
पहले पूर्णांक पाता है T
जहां T ^ ((p-1)/2) != 1
, के रूप में वांछित। याद है कि ;
फिर T
से वैश्विक वातावरण से खींचता है, जो अभी भी 2 है। यह परिणाम z
विकि से है।
अगला, c
विकी से बनाने के लिए, हमें आवश्यकता है z^Q
, इसलिए हम उपरोक्त को लपेटते g ... H
हैं और परिणाम को असाइन करते हैं T
। अब T
है c
विकी है।
Jg~gGHh/H2
आइए इसे अलग करें ~gGH
:। ~
जैसा है =
, लेकिन वैरिएबल का मूल मान लौटाता है, इसका नया मूल्य नहीं। इस प्रकार, यह लौटता है G
, जो n
विकि से है।
यह J
मान प्रदान करता है n^((Q+1)/2)
, जो R
विकि से है।
अब, निम्नलिखित प्रभावी होता है:
~gGH
यह G
मान असाइन करता है n^Q
, जो t
विकि से है।
अब, हमारे पास हमारे लूप चर सेट अप हैं। M, c, t, R
विकी से हैं K, T, G, J
।
लूप का शरीर जटिल है, इसलिए मैं इसे व्हाट्सएप के साथ प्रस्तुत करने जा रहा हूं, जिस तरह से मैंने इसे लिखा है:
WtG
=*J
=
gT^2
t-
K
=Kfq1gG^2T1
=%*G=^T2Q;
सबसे पहले, हम जांचते हैं कि क्या G
1. यदि ऐसा है, तो हम लूप से बाहर निकलते हैं।
अगला कोड जो चलता है वह है:
=Kfq1gG^2T1
यहां, हम i
इस तरह के पहले मूल्य की खोज करते हैं G^(2^i) mod Q = 1
, जो कि 1 से शुरू होता है। परिणाम में सहेजा गया है K
।
=gT^2t-K=Kfq1gG^2T1
यहां, हम पुराने मान को लेते हैं K
, के नए मान को K
घटाते हैं, 1 को घटाते हैं, उस शक्ति को 2 बढ़ाते हैं, और फिर T
उस पावर मॉड को बढ़ाते हैं Q
और फिर परिणाम को असाइन करते हैं T
। यह विकी से T
समान बनाता है b
।
यह वह रेखा भी है जो लूप को समाप्त कर देती है और यदि कोई समाधान नहीं है तो विफल हो जाता है, क्योंकि उस स्थिति में नए मूल्य का K
मान पुराने मूल्य के बराबर होगा K
, 2 को उठाया जाएगा -1
, और मॉड्यूलर घातांक एक त्रुटि उठाएगा।
=*J
अगला, हम J
उपरोक्त परिणाम से गुणा करते हैं और इसे अपडेट करते J
हुए वापस स्टोर करते हैं R
।
=^T2
फिर हम T
परिणाम को वापस स्क्वायर में स्टोर करते हैं T
, विकी से T
वापस सेट c
करते हैं।
=%*G=^T2Q
फिर हम G
उस परिणाम से गुणा करते हैं , इसे मॉड लेते हैं Q
और परिणाम को वापस स्टोर करते हैं G
।
;
और हम लूप को समाप्त करते हैं।
लूप के खत्म होने के बाद, मॉड J
का एक वर्गमूल है । सबसे छोटा खोजने के लिए, हम निम्नलिखित कोड का उपयोग करते हैं:n
p
hS%_BJ
_BJ
की सूची बनाता है J
और इसकी उपेक्षा, %
स्पष्ट Q
रूप से इसके दूसरे तर्क के रूप में लेता है, और % ... Q
अनुक्रम के प्रत्येक सदस्य पर लागू करने के लिए पायथ के डिफ़ॉल्ट व्यवहार का उपयोग करता है । फिर S
सूची को क्रमबद्ध करता है और h
इसके पहले सदस्य को न्यूनतम लेता है।