పైథాన్‌లో గొప్ప సాధారణ విభజన మరియు అతి తక్కువ సాధారణ గుణకాన్ని లెక్కించండి మరియు పొందండి

పైథాన్‌లో గొప్ప సాధారణ విభజన మరియు అతి తక్కువ సాధారణ గుణకాన్ని ఎలా లెక్కించాలి మరియు పొందాలి అనే వివరణ క్రిందిది.

• రెండు పూర్ణాంకాల యొక్క గొప్ప సాధారణ భాగహారం మరియు అతి తక్కువ సాధారణ గుణకం
• మూడు లేదా అంతకంటే ఎక్కువ పూర్ణాంకాల యొక్క గొప్ప సాధారణ భాగహారం మరియు అతి తక్కువ సాధారణ గుణకం

స్టాండర్డ్ లైబ్రరీలో అందించిన ఫంక్షన్‌ల స్పెసిఫికేషన్‌లు పైథాన్ వెర్షన్‌పై ఆధారపడి విభిన్నంగా ఉన్నాయని గమనించండి. ప్రామాణిక లైబ్రరీలో లేని ఫంక్షన్ యొక్క ఉదాహరణ అమలు కూడా ఈ కథనంలో చూపబడింది.

• పైథాన్ 3.4 లేదా అంతకంటే ముందు
  • GCD:fractions.gcd()(రెండు వాదనలు మాత్రమే)
• పైథాన్ 3.5 లేదా తదుపరిది
  • GCD:math.gcd()(రెండు వాదనలు మాత్రమే)
• పైథాన్ 3.9 లేదా తదుపరిది
  • GCD:math.gcd()(మూడు కంటే ఎక్కువ వాదనలకు మద్దతు ఇస్తుంది)
  • కనీసం సాధారణ హారం:math.lcm()(మూడు కంటే ఎక్కువ వాదనలకు మద్దతు ఇస్తుంది)

ఇక్కడ మేము ప్రామాణిక పైథాన్ లైబ్రరీని ఉపయోగించి పద్ధతిని వివరిస్తాము; బహుళ శ్రేణుల యొక్క ప్రతి మూలకం కోసం గొప్ప సాధారణ విభజన మరియు తక్కువ సాధారణ గుణకాన్ని లెక్కించడానికి NumPy సులభంగా ఉపయోగించబడుతుంది.

రెండు పూర్ణాంకాల యొక్క గొప్ప సాధారణ భాగహారం మరియు అతి తక్కువ సాధారణ గుణకం

GCD

పైథాన్ 3.5 నుండి, గణిత మాడ్యూల్‌లో gcd() ఫంక్షన్ ఉంది. gcd() అనేది సంక్షిప్త రూపం

• greatest common divisor

• math.gcd() — Mathematical functions — Python 3.10.2 Documentation

ఆర్గ్యుమెంట్‌లో పేర్కొన్న పూర్ణాంకం యొక్క గొప్ప సాధారణ భాగహారాన్ని అందిస్తుంది.

import math

print(math.gcd(6, 4))
# 2

పైథాన్ 3.4 మరియు అంతకుముందు, gcd() ఫంక్షన్ గణిత మాడ్యూల్‌లో కాకుండా భిన్నాల మాడ్యూల్‌లో ఉందని గమనించండి. భిన్నాలు తప్పనిసరిగా దిగుమతి చేయబడాలి మరియు భిన్నాలు.gcd().

• fractions.gcd() — Rational numbers — Python 3.10.2 Documentation

కనీసం సాధారణ హారం

అతి తక్కువ సాధారణ గుణకాన్ని అందించే lcm() ఫంక్షన్ పైథాన్ 3.9లోని గణిత మాడ్యూల్‌కు జోడించబడింది. lcm అనేది సంక్షిప్త రూపం

• least common multiple

• math.lcm() — Mathematical functions — Python 3.10.2 Documentation

ఆర్గ్యుమెంట్‌లో పేర్కొన్న పూర్ణాంకం యొక్క అతి తక్కువ సాధారణ గుణకాన్ని అందిస్తుంది.

print(math.lcm(6, 4))
# 12

పైథాన్ 3.8కి ముందు, lcm() అందించబడలేదు, కానీ gcd()ని ఉపయోగించి సులభంగా లెక్కించవచ్చు.

lcm(a, b) = a * b / gcd(a, b)

అమలు ఉదాహరణ.

def my_lcm(x, y):
    return (x * y) // math.gcd(x, y)

print(my_lcm(6, 4))
# 12

/ఇది దశాంశ ఫ్లోట్‌కు దారితీసినందున, దశాంశ బిందువును కత్తిరించడానికి మరియు పూర్ణాంక విభజన ఫలితాన్ని అందించడానికి రెండు బ్యాక్‌స్లాష్‌లు ఉపయోగించబడతాయి. ఆర్గ్యుమెంట్ పూర్ణాంకం కాదా అని నిర్ధారించడానికి ఎటువంటి ప్రాసెసింగ్ జరగలేదని గమనించండి.

మూడు లేదా అంతకంటే ఎక్కువ పూర్ణాంకాల యొక్క గొప్ప సాధారణ భాగహారం మరియు అతి తక్కువ సాధారణ గుణకం

పైథాన్ 3.9 లేదా తదుపరిది

పైథాన్ 3.9తో ప్రారంభించి, కింది అన్ని ఫంక్షన్‌లు మూడు కంటే ఎక్కువ ఆర్గ్యుమెంట్‌లకు మద్దతు ఇస్తాయి.

• math.gcd()
• math.lcm()

print(math.gcd(27, 18, 9))
# 9

print(math.gcd(27, 18, 9, 3))
# 3

print(math.lcm(27, 9, 3))
# 27

print(math.lcm(27, 18, 9, 3))
# 54

*మీరు జాబితా యొక్క మూలకాల యొక్క గొప్ప సాధారణ భాగహారాన్ని లేదా తక్కువ సాధారణ గుణకారాన్ని లెక్కించాలనుకుంటే, దీనితో ఆర్గ్యుమెంట్‌ను పేర్కొనండి.

l = [27, 18, 9, 3]
print(math.gcd(*l))
# 3

print(math.lcm(*l))
# 54

పైథాన్ 3.8 లేదా అంతకంటే ముందు

పైథాన్ 3.8కి ముందు, gcd() ఫంక్షన్ కేవలం రెండు ఆర్గ్యుమెంట్‌లకు మాత్రమే మద్దతు ఇచ్చింది.

మూడు లేదా అంతకంటే ఎక్కువ పూర్ణాంకాల యొక్క గొప్ప సాధారణ భాజకం లేదా అతి తక్కువ సాధారణ గుణకాన్ని కనుగొనడానికి, ప్రత్యేకంగా సంక్లిష్టమైన అల్గారిథం అవసరం లేదు; హై-ఆర్డర్ ఫంక్షన్ రిడ్యూస్()ని ఉపయోగించి ప్రతి బహుళ విలువలకు గొప్ప సాధారణ భాగహారం లేదా అతి తక్కువ సాధారణ గుణకాన్ని లెక్కించండి.

• functools — Higher-order functions and operations on callable objects — Python 3.10.2 Documentation

GCD

from functools import reduce

def my_gcd(*numbers):
    return reduce(math.gcd, numbers)

print(my_gcd(27, 18, 9))
# 9

print(my_gcd(27, 18, 9, 3))
# 3

l = [27, 18, 9, 3]
print(my_gcd(*l))
# 3

మళ్ళీ, పైథాన్ 3.4కి ముందు, gcd() ఫంక్షన్ భిన్నం మాడ్యూల్‌లో ఉంది, గణిత మాడ్యూల్ కాదు.

కనీసం సాధారణ హారం

def my_lcm_base(x, y):
    return (x * y) // math.gcd(x, y)

def my_lcm(*numbers):
    return reduce(my_lcm_base, numbers, 1)

print(my_lcm(27, 9, 3))
# 27

print(my_lcm(27, 18, 9, 3))
# 54

l = [27, 18, 9, 3]
print(my_lcm(*l))
# 54