Bézout की पहचान का परिचय

दो पूर्णांक A, B का GCD सबसे बड़ा धनात्मक पूर्णांक है जो दोनों को विभाजित करता है और शेष नहीं रहता है। अब यूक्लिड की संपत्ति के कारण प्रत्येक पूर्णांक N को एक पूर्णांक M द्वारा विभाजित किया जा सकता है:

ऐसे जोड़े मौजूद हैं, जैसे कि हम लिख सकते हैं:

चूंकि उन जोड़ियों की एक अनंत राशि है, इसलिए हम विशेष खोजना चाहेंगे। वास्तव में वास्तव में (ए, बी शून्य नहीं है) दो ऐसे जोड़े हैं जो संतृप्त करते हैं

जैसे

चुनौती

इस चुनौती का लक्ष्य गुणांक (यू, वी) की जोड़ी को ढूंढना है (यू, वी) जो उपरोक्त बाधाओं को दूर करता है और जहां यू सकारात्मक होना चाहिए। यह आउटपुट को एक अद्वितीय जोड़ी तक ले जाता है।

इनपुट

हम मान सकते हैं कि इनपुट सकारात्मक है, ए भी हमेशा बी (ए> बी) से बड़ा होगा।

उत्पादन

चुनौती में निर्दिष्ट हमारे (आदेशित) जोड़ी का कार्यक्रम होना चाहिए।

नियम

किसी को अंतर्निहित विस्तारित यूक्लिडियन एल्गोरिदम का उपयोग नहीं करना चाहिए (जैसे कि गणितज्ञ को एक का उपयोग करने की अनुमति है GCDलेकिन वह नहीं है ExtendedGCD- जो 5,3 वैसे भी विफल हो जाएगा)।

उत्तर एक पूर्ण कार्यक्रम हो सकता है (एसटीडीआईएन या इसी तरह के इनपुट और एसटीडीयूएसटी के माध्यम से आउटपुट) या एक फ़ंक्शन (जोड़ी को वापस करके)।

जोड़ी (यू, वी) के अलावा कोई आउटपुट नहीं होगा, अनुगामी न्यूलाइन्स या स्पेस की अनुमति है। (कोष्ठक या अल्पविराम ठीक हैं)

यह कोड गोल्फ है, सभी मानक कमियां निषिद्ध हैं और सबसे कम बाइट गिनती जीत के साथ कार्यक्रम।

उदाहरण

(A, B) -> (u, v)
(42, 12) -> (1, -3)
(4096, 84) -> (4, -195)
(5, 3) -> (2, -3)
(1155, 405) -> (20, -57)
(37377, 5204) -> (4365, -31351)
(7792, 7743) -> (7585, -7633)
(38884, 2737) -> (1707, -24251)
(6839, 746) -> (561, -5143)
(41908, 7228) -> (1104, -6401)
(27998, 6461) -> (3, -13)
(23780, 177) -> (20, -2687)
(11235813, 112358) -> (8643, -864301)

code-golf number-theory

— ბიმო
स्रोत

सम्बंधित।

— मार्टिन एंडर

1

MATL , 37 40 बाइट्स

ZdXK2Gw/:1G*1GK/t_w2$:XI2G*!+K=2#fIb)

रिलीज (9.3.1) का उपयोग करता है , जो इस चुनौती से पहले है।

यह एक क्रूर बल दृष्टिकोण है, इसलिए यह बड़े इनपुट के लिए काम नहीं कर सकता है।

इसे ऑनलाइन आज़माएं! ऑनलाइन संकलक एक नए रिलीज पर आधारित है, लेकिन वही परिणाम पैदा करता है।

व्याख्या

Zd            % implicitly input A and B. Compute their GCD. Call that C
XK            % copy C to clipboard K
2Gw/:         % vector [1, 2, ..., B/C]
1G*           % multiply that vector by A
1GK/t_w2$:    % vector [-A/C, -A/C+1 ..., A/C]
XI            % copy to clipboard I
2G*           % multiply that vector by B
!+            % all pairwise sums of elements from those vectors
K=2#f         % find row and column indices of sum that equals C
Ib)           % index second vector with column (indexing first vector with
              % row is not needed, because that vector is of the form [1, 2, ...])

— लुइस मेंडो
स्रोत

7

हास्केल, 51 बाइट्स

a#b=[(u,-v)|v<-[1..],u<-[1..v],gcd a b==u*a-v*b]!!0

प्रयोग उदाहरण: 27998 # 6461-> (3,-13)।

यह एक ब्रूट फोर्स अप्रोच है जो सभी संयोजनों का पता लगाती है uऔर vजो uपहले के द्वारा चुने गए वैध समाधान हैं । बड़े के लिए चलने में कुछ समय लगता है |v|।

— nimi
स्रोत

मुझे यह []!!0विचार बहुत पसंद है ))

— दोषपूर्ण

3

पायथन 3, 101 106 बाइट्स

संपादित करें: ब्रूस_फोर्ट द्वारा सुझाए गए कुछ सुधार और सुधार जोड़े गए ।

एक उत्तर जो विस्तारित यूक्लिडियन एल्गोरिथ्म का उपयोग करता है। यह स्थानों में थोड़ा सा स्पष्ट है, और मुझे उम्मीद है कि यह कुछ और होगा। मैं पूर्णांक डिवीजन पर बाइट को बचाने के लिए पायथन 2 में परिवर्तित कर सकता था ( //) लेकिन मुझे यकीन नहीं है कि पायथन 2 का %मापांक ऑपरेटर नकारात्मक दूसरे तर्क के साथ कैसे काम करता है, क्योंकि यह आउटपुट सही होने के लिए महत्वपूर्ण है।

def e(a,b):
 r=b;x=a;s=z=0;t=y=1
 while r:q=x/r;x,r=r,x%r;y,s=s,y-q*s;z,t=t,z-q*t
 return y%(b/x),z%(-a/x)

Ungolfed:

def e(a, b):
    r = b
    x = a    # becomes gcd(a, b)
    s = 0
    y = 1    # the coefficient of a
    t = 1
    z = 0    # the coefficient of b
    while r:
        q = x / r
        x, r = r, x % r
        y, s = s, y - q * s
        z, t = t, z - q * t
    return y % (b / x), z % (-a / x) # modulus in this way so that y is positive and z is negative

— Sherlock9
स्रोत

एक अनाम उपयोगकर्ता ने बताया कि kआपके ungolfed संस्करण की अंतिम पंक्ति में चर अपरिभाषित है।

— जोनाथन फ्रीच

@JonathanFrech आह, धन्यवाद!

— शर्लक

1

मैथेमेटिका, 80 बाइट्स

f@l_:=Mod@@NestWhile[{Last@#,{1,-Quotient@@(#.l)}.#}&,{{1,0},{0,1}},Last@#.l>0&]

स्पष्टीकरण :

विस्तारित यूक्लिडियन एल्गोरिथ्म का उपयोग यहां, एक Nestशैली में किया गया है। विधि जो गुणांक सरणियों में संग्रहीत होती है, इसका उपयोग करना संभव बनाता है Dot।

एक और संभावित प्रतिनिधित्व केवल प्रतीकात्मक अभिव्यक्ति का उपयोग कर रहा है, जैसे u a - v bकि {a->19, b->17}। ऐसा प्रतिनिधित्व मैथेमेटिका की विशेषता का उपयोग करता है और दिलचस्प है, लेकिन यह बाइट्स में बहुत लंबा है।

परीक्षण के मामले :

f[{5, 3}]              (* {2, -3} *)
f[{42, 12}]            (* {1, -3} *)
f[{11235813, 112358}]  (* {8643, -864301} *)

— njpipeorgan
स्रोत

1

रूबी, 83 बाइट्स

मुझे लगता है कि इस समाधान को ठीक करने और गोल्फ के लिए कुछ तरीके हैं, लेकिन मुझे यह अभी तक पसंद है। शायद मैं अगले विस्तारित यूक्लिडियन एल्गोरिथ्म समाधान की कोशिश करूँगा।

->x,y{a=b=0;y.downto(0).map{|u|(-x..0).map{|v|a,b=u,v if u*x+v*y==x.gcd(y)}};p a,b}

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

यह कोड 0 uसे yनीचे के लूप से शुरू होता है , जिसमें vसे -x0 से आंतरिक लूप होता है , जिसके अंदर हम हर uऔर vअगर चेक करते हैं u*x+v*y == gcd(x, y)। के बाद से वहाँ रास्ते में कई मैचों (इस का उपयोग करता है एक बहुत ही संपूर्ण खोज) हो सकता है, हम 0 से दूर प्रारंभ करें ताकि जब हम कई मैचों के अंतिम मिलता है, यह एक जहाँ है |u|और |v|0 के सबसे करीब हैं।

def bezout(x,y)
  a=b=0
  y.downto(0).each do |u|
    (-x..0).each do |v|
      if u*x + v*y == x.gcd(y)
        a,b=u,v
      end
    end
  end
  p a,b
end

— Sherlock9
स्रोत

@ ब्रूस_फोर्ट डन। आईआरबी उस परीक्षण मामले के लिए स्मृति से बाहर भाग गया। मैं जितनी जल्दी हो सके एक विस्तारित यूक्लिडियन एल्गोरिथ्म समाधान लिखूंगा।

— शर्लक