တွက်ချက်ပြီး Python တွင် အကြီးဆုံး ဘုံကိန်းခွဲနှင့် အနည်းဆုံး အများကိန်းကို ရယူပါ။

အောက်ဖော်ပြပါသည် Python တွင် အကြီးမားဆုံးဘုံကိန်းကိန်းနှင့် ဘုံကိန်းအနည်းဆုံးကို တွက်ချက်နည်းနှင့် ရယူနည်း၏ ဖော်ပြချက်ဖြစ်သည်။

• ကိန်းပြည့် နှစ်ခု၏ အကြီးမားဆုံး ဘုံကိန်း နှင့် အနည်းဆုံး ဘုံကိန်း
• သုံးလုံး သို့မဟုတ် ထို့ထက်ပိုသော ကိန်းပြည့်များ၏ အကြီးမြတ်ဆုံး ဘုံကိန်းနှင့် အနည်းဆုံး ဘုံကိန်း

စံဒစ်ဂျစ်တိုက်တွင် ပေးထားသည့် လုပ်ဆောင်ချက်များ၏ သတ်မှတ်ချက်များသည် Python ဗားရှင်းပေါ်မူတည်၍ ကွဲပြားသည်ကို သတိပြုပါ။ စံဒစ်ဂျစ်တိုက်တွင်မရှိသော လုပ်ဆောင်ချက်တစ်ခုကို နမူနာအကောင်အထည်ဖော်မှုကိုလည်း ဤဆောင်းပါးတွင် ပြထားသည်။

• Python 3.4 နှင့်အထက်
  • GCD:fractions.gcd()(အငြင်းအခုံနှစ်ခုသာ)
• Python 3.5 နှင့်အထက်
  • GCD:math.gcd()(အငြင်းအခုံနှစ်ခုသာ)
• Python 3.9 နှင့်အထက်
  • GCD:math.gcd()(အငြင်းအခုံ ၃ ခုထက်ပို၍ ထောက်ခံသည်)
  • ဘုံပိုင်းခြေအနည်းဆုံး:math.lcm()(အငြင်းအခုံ ၃ ခုထက်ပို၍ ထောက်ခံသည်)

ဤတွင် ကျွန်ုပ်တို့သည် ပုံမှန် Python စာကြည့်တိုက်ကို အသုံးပြုသည့် နည်းလမ်းကို ရှင်းပြပါသည်။ NumPy သည် များစွာသော arrays တစ်ခုစီ၏ ဒြပ်စင်တစ်ခုစီအတွက် အကြီးမားဆုံး ဘုံကိန်းကိန်းနှင့် အနည်းဆုံး ဘုံကိန်းများကို တွက်ချက်ရန် အလွယ်တကူ အသုံးပြုနိုင်သည်။

ကိန်းပြည့် နှစ်ခု၏ အကြီးမားဆုံး ဘုံကိန်း နှင့် အနည်းဆုံး ဘုံကိန်း

GCD

Python 3.5 မှစတင်၍ math module တွင် gcd() function တစ်ခုရှိသည်။ gcd() သည် အတိုကောက်ဖြစ်သည်။

• greatest common divisor

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

အငြင်းအခုံတွင် သတ်မှတ်ထားသည့် ကိန်းပြည့်၏ အကြီးဆုံးဘုံပိုင်းခြားမှုကို ပြန်ပေးသည်။

import math

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

Python 3.4 နှင့် အစောပိုင်းတွင်၊ gcd() လုပ်ဆောင်ချက်သည် သင်္ချာ module မဟုတ်ဘဲ အပိုင်းကိန်းများ module တွင် ရှိနေကြောင်း သတိပြုပါ။ အပိုင်းများကို တင်သွင်းပြီး fractions.gcd() ရပါမည်။

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

ဘုံပိုင်းခြေအနည်းဆုံး

အနည်း ဆုံး အများကိန်းကို ပြန်ပေးသည့် lcm() လုပ်ဆောင်ချက်ကို Python 3.9 ရှိ သင်္ချာ module တွင် ထည့်သွင်းခဲ့သည်။ 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

/၎င်းသည် ဒဿမမျှောတ်တစ်ခုအဖြစ် ရလဒ်ထွက်လာသောကြောင့်၊ ဒဿမအမှတ်ကို ဖြတ်တောက်ပြီး ကိန်းပြည့်ခွဲခြင်းရလဒ်ကို ပြန်ပေးရန်အတွက် backslash နှစ်ခုကို အသုံးပြုသည်။ အငြင်းအခုံသည် ကိန်းပြည့်ဟုတ်မဟုတ် ဆုံးဖြတ်ရန် စီမံဆောင်ရွက်ခြင်းကို မလုပ်ဆောင်ကြောင်း သတိပြုပါ။

သုံးလုံး သို့မဟုတ် ထို့ထက်ပိုသော ကိန်းပြည့်များ၏ အကြီးမြတ်ဆုံး ဘုံကိန်းနှင့် အနည်းဆုံး ဘုံကိန်း

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 နှင့်အထက်

Python 3.8 မတိုင်မီ၊ gcd() လုပ်ဆောင်ချက်သည် အကြောင်းပြချက်နှစ်ခုသာ ပံ့ပိုးပေးထားသည်။

ကိန်းပြည့်သုံးလုံး သို့မဟုတ် ထို့ထက်ပိုသော ဘုံကိန်းတန်း သို့မဟုတ် အနည်းဆုံး ဘုံကိန်းကို ရှာဖွေရန်၊ အထူးရှုပ်ထွေးသော အယ်လဂိုရီသမ် မလိုအပ်ပါ။ များပြားသောတန်ဖိုးတစ်ခုစီအတွက် အကြီးမြတ်ဆုံးဘုံခွဲဝေမှု သို့မဟုတ် ဘုံကိန်းဂဏန်းများကိုသာ တွက်ချက်ပြီး ပိုမိုမြင့်မားသောအမှာစာလုပ်ဆောင်ချက်ကို reduce() ကို အသုံးပြု၍ တွက်ချက်ပါ။

• 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

တစ်ဖန်၊ Python 3.4 မတိုင်မီတွင်၊ gcd() လုပ်ဆောင်ချက်သည် သင်္ချာ module မဟုတ်ဘဲ အပိုင်းပိုင်း module တွင် ရှိနေကြောင်း သတိပြုပါ။

ဘုံပိုင်းခြေအနည်းဆုံး

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