ਗਣਨਾ ਕਰੋ ਅਤੇ ਪਾਈਥਨ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਡਾ ਸਾਂਝਾ ਭਾਜਕ ਅਤੇ ਘੱਟ ਤੋਂ ਘੱਟ ਆਮ ਮਲਟੀਪਲ ਪ੍ਰਾਪਤ ਕਰੋ

ਹੇਠਾਂ ਪਾਈਥਨ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਡੇ ਸਾਂਝੇ ਭਾਜਕ ਅਤੇ ਘੱਟੋ-ਘੱਟ ਸਾਂਝੇ ਮਲਟੀਪਲ ਦੀ ਗਣਨਾ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਵਰਣਨ ਹੈ।

• ਦੋ ਪੂਰਨ ਅੰਕਾਂ ਦਾ ਸਭ ਤੋਂ ਵੱਡਾ ਸਾਂਝਾ ਭਾਜਕ ਅਤੇ ਸਭ ਤੋਂ ਘੱਟ ਸਾਂਝਾ ਗੁਣਜ
• ਤਿੰਨ ਜਾਂ ਵੱਧ ਪੂਰਨ ਅੰਕਾਂ ਦਾ ਸਭ ਤੋਂ ਵੱਡਾ ਸਾਂਝਾ ਭਾਜਕ ਅਤੇ ਘੱਟ ਤੋਂ ਘੱਟ ਸਾਂਝਾ ਗੁਣਜ

ਨੋਟ ਕਰੋ ਕਿ ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਫੰਕਸ਼ਨਾਂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪਾਈਥਨ ਸੰਸਕਰਣ ਦੇ ਅਧਾਰ ਤੇ ਵੱਖਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ। ਇੱਕ ਫੰਕਸ਼ਨ ਦਾ ਇੱਕ ਉਦਾਹਰਨ ਲਾਗੂ ਕਰਨਾ ਜੋ ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਨਹੀਂ ਹੈ ਇਸ ਲੇਖ ਵਿੱਚ ਵੀ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।

• ਪਾਈਥਨ 3.4 ਜਾਂ ਇਸ ਤੋਂ ਪਹਿਲਾਂ
  • ਜੀ.ਸੀ.ਡੀ:fractions.gcd()(ਸਿਰਫ਼ ਦੋ ਦਲੀਲਾਂ)
• ਪਾਈਥਨ 3.5 ਜਾਂ ਇਸਤੋਂ ਬਾਅਦ ਦਾ
  • ਜੀ.ਸੀ.ਡੀ:math.gcd()(ਸਿਰਫ਼ ਦੋ ਦਲੀਲਾਂ)
• ਪਾਈਥਨ 3.9 ਜਾਂ ਬਾਅਦ ਦਾ
  • ਜੀ.ਸੀ.ਡੀ:math.gcd()(ਤਿੰਨ ਤੋਂ ਵੱਧ ਆਰਗੂਮੈਂਟਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ)
  • ਘੱਟੋ-ਘੱਟ ਆਮ ਭਾਅ:math.lcm()(ਤਿੰਨ ਤੋਂ ਵੱਧ ਆਰਗੂਮੈਂਟਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ)

ਇੱਥੇ ਅਸੀਂ ਮਿਆਰੀ ਪਾਈਥਨ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਵਿਧੀ ਦੀ ਵਿਆਖਿਆ ਕਰਦੇ ਹਾਂ; NumPy ਦੀ ਵਰਤੋਂ ਮਲਟੀਪਲ ਐਰੇ ਦੇ ਹਰੇਕ ਐਲੀਮੈਂਟ ਲਈ ਸਭ ਤੋਂ ਵੱਡੇ ਸਾਂਝੇ ਭਾਜਕ ਅਤੇ ਘੱਟੋ-ਘੱਟ ਸਾਂਝੇ ਮਲਟੀਪਲ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਦੋ ਪੂਰਨ ਅੰਕਾਂ ਦਾ ਸਭ ਤੋਂ ਵੱਡਾ ਸਾਂਝਾ ਭਾਜਕ ਅਤੇ ਸਭ ਤੋਂ ਘੱਟ ਸਾਂਝਾ ਗੁਣਜ

ਜੀ.ਸੀ.ਡੀ

ਪਾਈਥਨ 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

ਪਾਈਥਨ 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() ਫੰਕਸ਼ਨ ਸਿਰਫ਼ ਦੋ ਆਰਗੂਮੈਂਟਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਸੀ।

ਤਿੰਨ ਜਾਂ ਵੱਧ ਪੂਰਨ ਅੰਕਾਂ ਦੇ ਸਭ ਤੋਂ ਵੱਡੇ ਸਾਂਝੇ ਭਾਜਕ ਜਾਂ ਘੱਟ ਤੋਂ ਘੱਟ ਸਾਂਝੇ ਗੁਣਜ ਨੂੰ ਲੱਭਣ ਲਈ, ਕਿਸੇ ਖਾਸ ਤੌਰ ‘ਤੇ ਗੁੰਝਲਦਾਰ ਐਲਗੋਰਿਦਮ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ; ਉੱਚ-ਆਰਡਰ ਫੰਕਸ਼ਨ reduce() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹਰ ਇੱਕ ਬਹੁ ਮੁੱਲ ਲਈ ਸਭ ਤੋਂ ਵੱਡੇ ਸਾਂਝੇ ਭਾਜਕ ਜਾਂ ਘੱਟੋ-ਘੱਟ ਸਾਂਝੇ ਮਲਟੀਪਲ ਦੀ ਗਣਨਾ ਕਰੋ।

• 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

ਦੁਬਾਰਾ, ਨੋਟ ਕਰੋ ਕਿ ਪਾਈਥਨ 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