पायथन में महानतम आम भाजक के लिए कोड [बंद]

Question

A और b का सबसे बड़ा सामान्य भाजक (GCD) सबसे बड़ी संख्या है जो दोनों को शेष नहीं के साथ विभाजित करता है।

दो संख्याओं के जीसीडी को खोजने का एक तरीका यूक्लिड का एल्गोरिथ्म है, जो इस अवलोकन पर आधारित है कि यदि rशेष तब aविभाजित होता है b, तब gcd(a, b) = gcd(b, r)। आधार मामले के रूप में, हम उपयोग कर सकते हैं gcd(a, 0) = a।

एक फ़ंक्शन लिखें जिसे gcd कहा जाता है, जो पैरामीटर लेता है aऔर bअपने सबसे बड़े सामान्य भाजक को लौटाता है।

Comments

numpy.org/devdocs/reference/generated/numpy.gcd.html

— P i

`np.gcd.reduce 'की कोशिश यहाँ

— uhoh

Answer 1

यह मानक पुस्तकालय में है ।

>>> from fractions import gcd
>>> gcd(20,8)
4

inspectपायथन 2.7 में मॉड्यूल से स्रोत कोड :

>>> print inspect.getsource(gcd)
def gcd(a, b):
    """Calculate the Greatest Common Divisor of a and b.

    Unless b==0, the result will have the same sign as b (so that when
    b is divided by it, the result comes out positive).
    """
    while b:
        a, b = b, a%b
    return a

पायथन 3.5 के रूप gcd में, mathमॉड्यूल में है ; एक fractionsको हटा दिया गया है। इसके अलावा, inspect.getsourceअब विधि के लिए व्याख्यात्मक स्रोत कोड नहीं देता है।

Comments

यह वापस नहीं करता है "_largest_ संख्या है कि कोई शेष के साथ दोनों उनमें से विभाजित" जैसे, fractions.gcd(1, -1)है -1लेकिन 1 > -1यानी, 1विभाजित दोनों 1और -1कोई शेष के साथ और यह तुलना में बड़ा है -1, को देखने के bugs.python.org/issue22477

— JFS

@JFSebastian मैं इसे एक मुद्दे के रूप में नहीं देखता ... बस स्रोत कोड में टिप्पणी को देखें: "जब तक b == 0 नहीं होगा, परिणाम b के रूप में एक ही संकेत होगा" , इसलिए gcd(1, -1) == -1मेरे लिए पूरी तरह से कानूनी लगता है।

— मार्को बोनेली

@MarcoBonelli: हाँ। यह प्रलेखित के रूप में व्यवहार करता है लेकिन यह पाठ्यपुस्तक की परिभाषा नहीं है जिससे अधिकांश लोग परिचित हैं। उस चर्चा को पढ़ें जिसे मैंने ऊपर लिंक किया है । व्यक्तिगत fractions.gcd()रूप से , मुझे पसंद है (यह यूक्लिडियन रिंग तत्वों पर काम करता है)।

— jfs

@JFSebastian FWIW, पायथन 3.5 के रूप में, math.gcd(1, -1)रिटर्न 1।

— एक्यूमेनस

@ABB math.gcd () और भिन्न। Gcd () उत्तर और टिप्पणियों के अनुसार अलग-अलग हैं।

— jfs

Answer 2

एमएन के साथ एल्गोरिदम भयानक रूप से लंबे समय तक चल सकते हैं।

यह बेहतर प्रदर्शन करता है:

def gcd(x, y):
    while y != 0:
        (x, y) = (y, x % y)
    return x

Comments

यह मानक पुस्तकालय में भी एक है।

— सायंतनकाल

वह एल्गोरिथ्म भी कैसे काम करता है? यह जादू की तरह है।

— डूडरसन

@netom: नहीं, असाइनमेंट को उस तरह नहीं लिखा जा सकता है; xअसाइन किए जाने से पहले टपल असाइनमेंट का उपयोग करता है। आपने पहले असाइन yकिया है , इसलिए अब सेट किया जा रहा है (जैसा कि हमेशा 0 होता है)। x y0y % y

— मार्टिन पीटर्स

@MartijnPieters हाँ, आप सही हैं, मुझे एक अस्थायी चर का उपयोग करना चाहिए। इस तरह: x_ = y; y = x% y; x =

— x_

@netom: जो इस उत्तर में किए गए कार्य का उपयोग करते समय बिल्कुल भी आवश्यक नहीं है।

— मार्टिन पीटर्स

Answer 3

कोड का यह संस्करण GCD खोजने के लिए यूक्लिड के एल्गोरिथ्म का उपयोग करता है।

def gcd_recursive(a, b):
    if b == 0:
        return a
    else:
        return gcd_recursive(b, a % b)

Comments

आपने नाम में iter का उपयोग किया है लेकिन इसका वास्तव में एक पुनरावर्ती संस्करण है।

— शिप्लू मोकादिम

लूप संस्करणों की तुलना में पुनरावृत्ति खराब रूप से कुशल है, + आपको इसे b> a

— डॉ। गोलू के साथ

def gcd(a, b): if b == 0: return a return gcd(b, a % b)

— एंड्रियास के।

Answer 4

gcd = lambda m,n: m if not n else gcd(n,m%n)

Answer 5

def gcd(m,n):
    return gcd(abs(m-n), min(m, n)) if (m-n) else n

Comments

जब आप समानता के लिए तुलना करना चाहते हैं तो कभी भी 'का उपयोग न करें'। छोटे पूर्णांक कैश एक CPython कार्यान्वयन विवरण है।

— मारियस गेदमिनस

Answer 6

पुनरावृत्ति का उपयोग करते हुए बहुत संक्षिप्त समाधान:

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a%b)

Answer 7

पुनरावर्तन का उपयोग करते हुए ,

def gcd(a,b):
    return a if not b else gcd(b, a%b)

का उपयोग करते हुए ,

def gcd(a,b):
  while b:
    a,b = b, a%b
  return a

लैम्ब्डा का उपयोग करना,

gcd = lambda a,b : a if not b else gcd(b, a%b)

>>> gcd(10,20)
>>> 10

Comments

लैम्ब्डा संस्करण काम नहीं कर सकता क्योंकि इसमें पुनरावृत्ति को रोकने के लिए कोई शर्त नहीं है। मुझे लगता है कि यह सिर्फ आपके पहले से परिभाषित फ़ंक्शन को बुला रहा है।

— रेम

Answer 8

a=int(raw_input('1st no \n'))
b=int(raw_input('2nd no \n'))

def gcd(m,n):
    z=abs(m-n)
    if (m-n)==0:
        return n
    else:
        return gcd(z,min(m,n))


print gcd(a,b)

यूक्लिड के एल्गोरिथ्म पर आधारित एक अलग दृष्टिकोण।

Answer 9

def gcdRecur(a, b):
    '''
    a, b: positive integers

    returns: a positive integer, the greatest common divisor of a & b.
    '''
    # Base case is when b = 0
    if b == 0:
        return a

    # Recursive case
    return gcdRecur(b, a % b)

Answer 10

मुझे लगता है कि पुनरावृत्ति का उपयोग करने का एक और तरीका है। यहाँ मेरा कोड है:

def gcd(a, b):
    if a > b:
        c = a - b
        gcd(b, c)
    elif a < b:
        c = b - a
        gcd(a, c)
    else:
        return a

Comments

आप पुनरावर्ती कॉल के बाद वापस नहीं लौट रहे हैं gcd(10,5)... दौड़ने का प्रयास करें ...

— टॉमेरिकू

Answer 11

पुनरावृत्ति के साथ अजगर में:

def gcd(a, b):
    if a%b == 0:
        return b
    return gcd(b, a%b)

Answer 12

def gcd(a,b):
    if b > a:
        return gcd(b,a)
    r = a%b
    if r == 0:
        return b
    return gcd(r,b)

Answer 13

के लिए a>b:

def gcd(a, b):

    if(a<b):
        a,b=b,a
        
    while(b!=0):
        r,b=b,a%r
        a=r
    return a

---

के लिए या तो a>bया a<b:

def gcd(a, b):

    t = min(a, b)

    # Keep looping until t divides both a & b evenly
    while a % t != 0 or b % t != 0:
        t -= 1

    return t

Comments

अजगर में स्वैप संस्करण है बच्चे खेलते हैं b, a = a, b:। भाषा के बारे में अधिक पढ़ने की कोशिश करें

— जेसन हू

आप जो कहते हैं, मैं उसे पसंद करता हूं, लेकिन आप इसे कहने के तरीके को पसंद नहीं करते

— जैक्ज़हु

Answer 14

छोरों का उपयोग करते हुए मुझे होमवर्क असाइनमेंट के लिए कुछ ऐसा करना था। सबसे कुशल तरीका नहीं है, लेकिन यदि आप एक फ़ंक्शन का उपयोग नहीं करना चाहते हैं तो यह काम करता है:

num1 = 20
num1_list = []
num2 = 40
num2_list = []
x = 1
y = 1
while x <= num1:
    if num1 % x == 0:
        num1_list.append(x)
    x += 1
while y <= num2:
    if num2 % y == 0:
        num2_list.append(y)
    y += 1
xy = list(set(num1_list).intersection(num2_list))
print(xy[-1])

Answer 15

def _grateest_common_devisor_euclid(p, q):
    if q==0 :
        return p
    else:
        reminder = p%q
        return _grateest_common_devisor_euclid(q, reminder)

print(_grateest_common_devisor_euclid(8,3))

Answer 16

यह कोड # उपयोगकर्ता द्वारा दी गई पसंद के आधार पर दो से अधिक संख्याओं के gcd की गणना करता है, यहाँ उपयोगकर्ता नंबर देता है

numbers = [];
count = input ("HOW MANY NUMBERS YOU WANT TO CALCULATE GCD?\n")
for i in range(0, count):
  number = input("ENTER THE NUMBER : \n")
  numbers.append(number)
numbers_sorted = sorted(numbers)
print  'NUMBERS SORTED IN INCREASING ORDER\n',numbers_sorted
gcd = numbers_sorted[0]

for i in range(1, count):
  divisor = gcd
  dividend = numbers_sorted[i]
  remainder = dividend % divisor
  if remainder == 0 :
  gcd = divisor
  else :
    while not remainder == 0 :
      dividend_one = divisor
      divisor_one = remainder
      remainder = dividend_one % divisor_one
      gcd = divisor_one

print 'GCD OF ' ,count,'NUMBERS IS \n', gcd

Comments

ढेर अतिप्रवाह में आपका स्वागत है! क्या आप यह बताने के लिए कुछ आख्यान जोड़ने पर विचार करेंगे कि यह कोड क्यों काम करता है, और यह प्रश्न का उत्तर क्या देता है? यह सवाल पूछने वाले व्यक्ति और किसी अन्य व्यक्ति के लिए बहुत मददगार होगा।

— एंड्रयू बार्बर

Answer 17

मूल्य गमागमन मेरे लिए अच्छी तरह से काम नहीं किया। इसलिए मैंने बस संख्याओं के लिए एक दर्पण जैसी स्थिति निर्धारित की है जो <b या a> b में दर्ज की गई है:

def gcd(a, b):
    if a > b:
        r = a % b
        if r == 0:
            return b
        else:
            return gcd(b, r)
    if a < b:
        r = b % a
        if r == 0:
            return a
        else:
            return gcd(a, r)

print gcd(18, 2)

Comments

यह मान्य पायथन सिंटैक्स भी नहीं है। इंडेंटेशन महत्वपूर्ण है।

— मारियस गेदमिनस

क्या बारे में जब = बी इसे पकड़ने के लिए आपके पास एक प्रारंभिक IF शर्त होनी चाहिए।

— josh.thomson

Answer 18

#This program will find the hcf of a given list of numbers.

A = [65, 20, 100, 85, 125]     #creates and initializes the list of numbers

def greatest_common_divisor(_A):
  iterator = 1
  factor = 1
  a_length = len(_A)
  smallest = 99999

#get the smallest number
for number in _A: #iterate through array
  if number < smallest: #if current not the smallest number
    smallest = number #set to highest

while iterator <= smallest: #iterate from 1 ... smallest number
for index in range(0, a_length): #loop through array
  if _A[index] % iterator != 0: #if the element is not equally divisible by 0
    break #stop and go to next element
  if index == (a_length - 1): #if we reach the last element of array
    factor = iterator #it means that all of them are divisibe by 0
iterator += 1 #let's increment to check if array divisible by next iterator
#print the factor
print factor

print "The highest common factor of: ",
for element in A:
  print element,
print " is: ",

greatest_common_devisor (ए)

Answer 19

def gcdIter(a, b):
gcd= min (a,b)
for i in range(0,min(a,b)):
    if (a%gcd==0 and b%gcd==0):
        return gcd
        break
    gcd-=1

Comments

यह सबसे आसान तरीका है ... इसे कठिन मत बनाओ!

— पार बेस

कोड प्रदान करने के लिए धन्यवाद जो समस्या को हल करने में मदद कर सकता है, लेकिन आम तौर पर, उत्तर बहुत अधिक सहायक होते हैं यदि वे एक स्पष्टीकरण शामिल करते हैं कि कोड क्या करना है, और क्यों समस्या हल करता है।

— न्यूरॉन

यह कोड अधूरा है (कोई अंतिम विवरण नहीं) और अनुचित रूप से प्रारूपित (कोई अनिष्ट नहीं)। मुझे यह भी पता नहीं है कि यह breakकथन क्या हासिल करने की कोशिश कर रहा है।

— kdopen

Answer 20

यहाँ समाधान को लागू करने की अवधारणा है Iteration:

def gcdIter(a, b):
    '''
    a, b: positive integers

    returns: a positive integer, the greatest common divisor of a & b.
    '''
    if a > b:
        result = b
    result = a

    if result == 1:
        return 1

    while result > 0:
        if a % result == 0 and b % result == 0:
            return result
        result -= 1