पायथ, 92 बाइट्स
I!%vzhK%2u?sm,ed-hd*ed/F<G2cG2@G1G+~Q,hQ_eQj9 2)J*L/vzhKtKeoSNm-VJ/RhK_*LdQsm+LdtM3/V*LhK_JQ
यह काफी राक्षस है।
इसे ऑनलाइन आज़माएँ: प्रदर्शन । इनपुट प्रारूप है c\n[a,b]और आउटपुट प्रारूप है [x,y]।
इस मामले में कि कोई पूर्णांक समाधान मौजूद नहीं है, मैं कुछ भी नहीं छापूंगा, और इस मामले में कि कोई प्राकृतिक पूर्णांक समाधान मौजूद नहीं है, मैं बस एक यादृच्छिक पूर्णांक समाधान मुद्रित करूंगा।
स्पष्टीकरण (किसी न किसी अवलोकन)
पहले मैं ax + by = gcd(a,b)विस्तारित यूक्लिडियन एल्गोरिथ्म का उपयोग करके समीकरण को पूर्णांक समाधान प्राप्त करूंगा ।
फिर मैं पूर्णांक समाधान प्राप्त करने के लिए समाधान (मेरे गुणा aऔर उसके bसाथ c/gcd(a,b)) को संशोधित करूंगा ax + by = c। यह काम करता है, अगर c/gcd(a,b)एक पूर्णांक है। अन्यथा कोई समाधान मौजूद नहीं है।
अन्य सभी पूर्णांक समाधान फार्म का a(x+n*b/d) + b(y-n*a/d) = c साथ d = gcd(a,b)पूर्णांक के लिए n। दो असमानताओं का उपयोग करना x+n*b/d >= 0और y-n*a/d >= 0मैं 6 संभावित मूल्यों को निर्धारित कर सकता हूं n। मैं उनमें से सभी 6 का प्रयास करूंगा और सबसे कम गुणांक वाले समाधान को प्रिंट करूंगा।
स्पष्टीकरण (विस्तृत)
पहला कदम समीकरण का पूर्णांक समाधान खोजना है ax' + by' = gcd(a,b)। यह विस्तारित यूक्लिडियन एल्गोरिथ्म का उपयोग करके किया जा सकता है। आप अंदाजा लगा सकते हैं कि यह विकिपीडिया पर कैसे काम करता है । एकमात्र अंतर यह है, कि 3 कॉलम ( r_i s_i t_i) का उपयोग करने के बजाय मैं 6 कॉलम ( r_i-1 r_i s_i-1 s_i t_i-1 t_i) का उपयोग करूँगा । इस तरह मुझे अंतिम दो पंक्तियों को स्मृति में नहीं रखना है, केवल अंतिम एक है।
K%2u?sm,ed-hd*ed/F<G2cG2@G1G+~Q,hQ_eQj9 2) implicit: Q = [a,b] (from input)
j9 2 convert 9 to base 2: [1,0,0,1]
+ Q add to Q => [a,b,1,0,0,1]
this is the initial row
u ) start with G = ^ and update G repeatedly
by the following expression, until
the value of G doesn't change anymore
? @G1 if G[1] != 0:
cG2 split G into parts of 2
m map the parts d to:
, the pair
ed d[1]
-hd*ed/F<G2 d[0]-d[1]*G[0]/G[1]
s unfold
else:
G G (don't change it, stop criterion for u)
%2 take every second element
we get the list [gcd(a,b),x',y']
K store this list in K
~Q,hQ_eQ afterwards change Q to [Q[0],-Q[1]] = [a,-b]
This will be important for the other parts.
अब मैं इसका हल खोजना चाहता हूं ax + by = c। यह तभी संभव है, जब c mod gcd(a,b) == 0। यदि यह समीकरण संतुष्ट है, तो मैं बस के x',y'साथ गुणा कर रहा हूं c/gcd(a,b)।
I!%vzhK...J*L/vzhKtK implicit: z = c in string format (from input)
%vzhK evaluated(z) mod K[0] (=gcd(a,b))
I! if not ^ than:
/vzhK c/K[0]
*L tK multipy ^ to each element in K[1:] (=[x',y'])
J and store the result in J, this is now [x,y]
हमारे पास पूर्णांक समाधान है ax + by = c। सूचना, वह x, yया दोनों नकारात्मक हो सकती है। इसलिए हमारा लक्ष्य इन्हें गैर-नकारात्मक में बदलना है।
डायोफैंटाइन समीकरणों के बारे में अच्छी बात यह है कि हम केवल एक प्रारंभिक समाधान का उपयोग करके सभी समाधान का वर्णन कर सकते हैं। यदि (x,y)एक समाधान है, कि अन्य सभी समाधान पूर्णांक के (x-n*b/gcd(a,b),y+n*a/gcd(a,b))लिए फॉर्म के हैं n।
इसलिए हम एक n, कहाँ x-n*b/gcd(a,b) >= 0और कहाँ करना चाहते हैं y+n*a/gcd(a,b >= 0। कुछ परिवर्तन के बाद हम दो असमानताओं के साथ समाप्त होते हैं n >= -x*gcd(a,b)/bऔर n >= y*gcd(a,b)/a। सूचना है कि असमानता प्रतीक एक संभावित नकारात्मक के साथ विभाजन की वजह से दूसरी दिशा में लग सकता है aया b। मैं इसके बारे में ज्यादा परवाह नहीं करता, मैं बस कहता हूं कि -x*gcd(a,b)/b - 1, -x*gcd(a,b)/b, -x*gcd(a,b)/b + 1निश्चित रूप से एक संख्या 1 असमानता को संतुष्ट करती है, और एक संख्या को y*gcd(a,b)/a - 1, y*gcd(a,b)/a, y*gcd(a,b)/a + 1असमानता 2। यह एक है n, जो दोनों असमानताओं को संतुष्ट करता है, 6 संख्याओं में से एक भी करता है।
फिर मैं (x-n*b/gcd(a,b),y+n*a/gcd(a,b))सभी 6 संभावित मूल्यों के लिए नए समाधानों की गणना करता हूं n। और मैं समाधान को उच्चतम निम्नतम मूल्य के साथ प्रिंट करता हूं।
eoSNm-VJ/RhK_*LdQsm+LdtM3/V*LhK_JQ
_J reverse J => [y,x]
*LhK multiply each value with K[0] => [y*gcd,x*gcd]
/V Q vectorized division => [y*gcd/a,-x*gcd/b]
m map each d of ^ to:
tM3 [-1,0,1]
+Ld add d to each ^
s unfold
these are the possible values for n
m map each d (actually n) of ^ to:
*LdQ multiply d to Q => [a*n,-b*n]
_ reverse => [-b*n,a*n]
/RhK divide by K[0] => [-b*n/gcd,a*n/gcd]
-VJ vectorized subtraction with J
=> [x+b*n/gcd,y-a*n/gcd]
oSN order the solutions by their sorted order
e print the last one
उनके द्वारा क्रमबद्ध क्रम वस्तु द्वारा क्रमबद्ध तरीके निम्न प्रकार से काम करते हैं। मैं उदाहरण का उपयोग कर रहा हूँ2x + 3y = 11
मैं 6 समाधानों में से प्रत्येक को छांटता हूं (इसे कुंजी कहा जाता है), और मूल समाधानों को उनकी कुंजियों के आधार पर क्रमबद्ध करते हैं:
solutions: [1, 3], [4, 1], [7, -1], [-5, 7], [-2, 5], [1, 3]
keys: [1, 3], [1, 4], [-1, 7], [-5, 7], [-2, 5], [1, 3]
sort by key:
solutions: [-5, 7], [-2, 5], [7, -1], [1, 3], [1, 3], [4, 1]
keys: [-5, 7], [-2, 5], [-1, 7], [1, 3], [1, 3], [1, 4]
यह अंत तक एक पूर्ण गैर-नकारात्मक समाधान बनाता है (यदि कोई है)।