પાયથોનમાં સૌથી મોટા સામાન્ય વિભાજક અને ઓછામાં ઓછા સામાન્ય ગુણાંકની ગણતરી કરો અને મેળવો

પાયથોનમાં સૌથી મોટા સામાન્ય વિભાજક અને ઓછામાં ઓછા સામાન્ય ગુણાંકની ગણતરી કેવી રીતે કરવી અને કેવી રીતે મેળવવી તેનું વર્ણન નીચે આપેલ છે.

• બે પૂર્ણાંકોનો સૌથી મોટો સામાન્ય વિભાજક અને લઘુત્તમ સામાન્ય ગુણાંક
• ત્રણ અથવા વધુ પૂર્ણાંકોનો સૌથી મોટો સામાન્ય વિભાજક અને લઘુત્તમ સામાન્ય ગુણાંક

નોંધ કરો કે સ્ટાન્ડર્ડ લાઇબ્રેરીમાં પૂરા પાડવામાં આવેલ કાર્યોની વિશિષ્ટતાઓ Python સંસ્કરણના આધારે અલગ પડે છે. પ્રમાણભૂત પુસ્તકાલયમાં ન હોય તેવા ફંક્શનનું ઉદાહરણ અમલીકરણ પણ આ લેખમાં બતાવવામાં આવ્યું છે.

• Python 3.4 અથવા તે પહેલાંનું
  • જીસીડી:fractions.gcd()(માત્ર બે દલીલો)
• Python 3.5 અથવા પછીનું
  • જીસીડી:math.gcd()(માત્ર બે દલીલો)
• Python 3.9 અથવા પછીનું
  • જીસીડી:math.gcd()(ત્રણથી વધુ દલીલોને સમર્થન આપે છે)
  • ઓછામાં ઓછું સામાન્ય છેદ:math.lcm()(ત્રણથી વધુ દલીલોને સમર્થન આપે છે)

અહીં અમે પ્રમાણભૂત પાયથોન લાઇબ્રેરીનો ઉપયોગ કરીને પદ્ધતિ સમજાવીએ છીએ; NumPy નો ઉપયોગ બહુવિધ એરેના દરેક ઘટક માટે સૌથી મોટા સામાન્ય વિભાજક અને ઓછામાં ઓછા સામાન્ય ગુણાંકની ગણતરી કરવા માટે સરળતાથી થઈ શકે છે.

બે પૂર્ણાંકોનો સૌથી મોટો સામાન્ય વિભાજક અને લઘુત્તમ સામાન્ય ગુણાંક

જીસીડી

Python 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() ફંક્શન અપૂર્ણાંક મોડ્યુલમાં છે, ગણિત મોડ્યુલમાં નહીં. અપૂર્ણાંક આયાત કરવા જોઈએ અને fractions.gcd().

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

ઓછામાં ઓછું સામાન્ય છેદ

lcm() ફંક્શન, જે ઓછામાં ઓછું સામાન્ય બહુવિધ પરત કરે છે, તે Python 3.9 માં ગણિત મોડ્યુલમાં ઉમેરવામાં આવ્યું હતું. lcm માટે ટૂંકાક્ષર છે

• least common multiple

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

દલીલમાં ઉલ્લેખિત પૂર્ણાંકનો લઘુત્તમ સામાન્ય ગુણાંક પરત કરે છે.

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

Python 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

/કારણ કે આ દશાંશ ફ્લોટમાં પરિણમે છે, બે બેકસ્લેશનો ઉપયોગ દશાંશ બિંદુને કાપવા અને પૂર્ણાંક ભાગાકાર પરિણામ પરત કરવા માટે થાય છે. નોંધ કરો કે દલીલ પૂર્ણાંક છે કે નહીં તે નિર્ધારિત કરવા માટે કોઈ પ્રક્રિયા કરવામાં આવતી નથી.

ત્રણ અથવા વધુ પૂર્ણાંકોનો સૌથી મોટો સામાન્ય વિભાજક અને લઘુત્તમ સામાન્ય ગુણાંક

Python 3.9 અથવા પછીનું

Python 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

Python 3.8 અથવા તે પહેલાંનું

પાયથોન 3.8 પહેલા, gcd() ફંક્શન માત્ર બે દલીલોને સપોર્ટ કરતું હતું.

ત્રણ કે તેથી વધુ પૂર્ણાંકોનો સૌથી મોટો સામાન્ય વિભાજક અથવા ઓછામાં ઓછો સામાન્ય ગુણાંક શોધવા માટે, કોઈ ખાસ જટિલ અલ્ગોરિધમની જરૂર નથી; ઉચ્ચ-ઓર્ડર ફંક્શન રિડ્યુ() નો ઉપયોગ કરીને દરેક બહુવિધ મૂલ્યો માટે ફક્ત સૌથી મોટા સામાન્ય ભાજક અથવા ઓછામાં ઓછા સામાન્ય ગુણાંકની ગણતરી કરો.

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

જીસીડી

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

ફરીથી, નોંધ કરો કે Python 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