Как найти минимальное кратное питон

В этой статье о Python мы рассмотрим, как получить наименьшее общее кратное (НОК) двух чисел. Для этого мы применим математическую формулу, опираясь также на наибольший общий делитель.

Если вдруг вы не знаете, наименьшее общее кратное двух чисел – это наименьшее натуральное число, отличное от нуля, которое делится на каждое из них без остатка.

Давайте рассмотрим пример. Для чисел 20 и 6 есть кратные 60, 120 и другие.

Хотя существует несколько кратных чисел, нас интересует наименьшее из них, которым в данном случае является 60. Нет меньшего числа, которое было бы кратно обоим.

Формула

Чтобы получить наименьшее общее кратное в Python, мы должны применить формулу.

НОК(a, b) = (a * b) / НОД(a, b)

Здесь мы умножим a на b, а затем разделим результат на наибольший общий делитель (НОД) этих двух чисел.

Давайте перейдем к делу.

def min_common_divisor(a, b):
    return (a * b) / max_common_divisor(a, b)
Code language: JavaScript (javascript)

Как видите, это всего лишь вопрос написания формулы.

Собираем все вместе

Полный код вместе с функцией НОД выглядит следующим образом:

def max_common_divisor(a, b):
    temp = 0
    while b != 0:
        temp = b
        b = a % b
        a = temp
    return a
def min_common_divisor(a, b):
    return (a * b) / max_common_divisor(a, b)
a = 20
b = 6
nok = min_common_diviso
print(f"Наименьшее общее кратное {a} и {b} равно {nok}.")
Code language: PHP (php)

Функции относящиеся к теории чисел.

В этом разделе представлены функции относящиеся к теории чисел.

Содержание:

• Факториал числа,
• Наибольший общий делитель целых чисел,
• Функция math.frexp(),
• Функция math.ldexp(),
• Абсолютное значение числа,
• Остаток от деления,
• Получить дробную и целую часть числа,
• Получить точную сумму элементов списка,
• Получить число x со знаком числа y,
• Сравнение в пределах указанной точности,
• Наименьшее общее кратное целых чисел,
• Следующее значение float после x по направлению к y,
• Наименьший значащий бит числа float.

math.factorial(x):

Функция math.factorial() возвращает факториал указанного числа x.

>>> import math
>>> math.factorial(5)
120

Данная функция всегда возвращает число типа int и поддерживает длинную арифметику, т.е. величина обрабатываемого числа x и возвращаемого результата ограничивается только возможностями компьютера.

Если x не является целым числом или если x является отрицательным, то будет вызвано исключение ValueError.

Изменено в Python 3.9. Не рекомендуется передавать числа с плавающей запятой с целыми значениями (например, 5.0).

math.gcd(*integers):

Функция math.gcd() возвращает наибольший общий делитель указанных целочисленных аргументов *integers.

>>> import math
>>> math.gcd(3886, 9048)
# 58

# проверяем
>>> 3886/58, 9048/58
# (67.0, 156.0)

• Если какой-либо из аргументов не равен нулю, то возвращаемое значение является наибольшим положительным целым числом, которое является делителем всех аргументов:
• Если все аргументы равны нулю, то возвращаемое значение равно 0.
• функция math.gcd() вызванная без аргументов возвращает 0.

Указанные числа должны быть целыми типа int, но могут быть как положительными, так и отрицательными:

>>> import math
>>> math.gcd(-4, -8)
# 4
>>> math.gcd(-4, -8.8)
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# TypeError: 'float' object cannot be interpreted as an integer

Изменено в Python 3.9: Добавлена ​​поддержка произвольного количества аргументов. Раньше поддерживалось только два аргумента.

math.frexp(x):

Функция math.frexp() возвращает кортеж из двух чисел (m, e) таких что x == m*2**e.

>>> import math
>>> math.frexp(123)
# (0.9609375, 7)
>>> 0.9609375*2**7
# 123.0

Число m принадлежит к типу float и всегда является таким, что 0.5 <= abs(m) < 1, даже для тех случаев, когда значением x является произвольная степень двойки. Число e всегда целое число int:

>>> math.frexp(0.25)
# (0.5, -1)
>>> math.frexp(64)
# (0.5, 7)

Если x равен 0, то будет возвращено (0.0, 0).

Данная функция используется тогда, когда представление чисел типа float не должно зависеть от архитектуры машины.

math.ldexp(x, i):

Функция math.ldexp() возвращает значение равное x*2**i, т.е. является обратной к функции math.frexp().

>>> import math
>>> math.ldexp(3, 4)
# 48.0
>>> math.ldexp(0.125, 8)
# 32.0

math.fabs(x):

Функция math.fabs() возвращает абсолютное значение, модуль числа x. Результат всегда тип float.

>>> import math
>>> math.fabs(-3)
3.0

Данная функция в отличии от встроенной функции abs() не обрабатывает комплексные числа.

math.fmod(x):

Функция math.fmod() возвращает остаток от деления числа x на число y, вычисленный так, как это определено в библиотеке math языка C.

>>> import math
>>> math.fmod(2.23, 0.2)
0.02999999999999986

Данная функция направлена на то, что бы результат был максимально приближен к значению x - n*y для некоторого целого числа n, что бы этот результат имел тот же знак, что и x, что бы разность x - n*y == abs(y).

Для чисел типа float данная функция является предпочтительнее чем команда x%y, которая в свою очередь является предпочтительной для чисел типа int. Так как для некоторых случаев, например при x = -1e-100 и x = 1e100, команда x%y может вообще выдать неправильный результат.

math.modf(x):

Функция math.modf() возвращает кортеж из двух чисел (f, w) где f это дробная, а w – целая часть числа x. Результат всегда имеет тип float.

>>> import math
>>> math.modf(3)
# (0.0, 3.0)
>>> math.modf(3.14)
# (0.14000000000000012, 3.0)

math.fsum(iterable):

Функция math.fsum() возвращает точную сумму значений в итерируемой последовательности iterable. Возвращаемый результат всегда типа float.

>>> import math
>>> sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
# 0.9999999999999999
>>> math.fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
# 1.0

Может показаться, что эта сумма будет точной всегда, но на самом деле это не так:

>>> math.fsum([0.3, 0.3, 0.3])
0.8999999999999999

Многое зависит от сборки компилятора языка C, который используется на данной платформе. Если вам нужны точные арифметические операции с десятичными дробями, то воспользуйтесь модулем decimal.

math.copysign(x, y):

Функция math.copysign() возвращает число c абсолютным значением x, но со знаком числа y. Возвращаемый результат всегда типа float

>>> import math
>>> math.copysign(14, -12)
# -14.0
>>> math.copysign(-14, 12)
# 14.0

На платформах, которые поддерживают нули со знаком функция math.copysign(1.0, -0.0) возвращает -1.0.

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0):

Функция math.isclose() возвращает True если в пределах указанной точности, числа a и b близки настолько, что их можно считать равными.

>>> import math
>>> x = 7
>>> y = 7.000000000000001
>>> x==y
# False
>>> math.isclose(x, y)
# True

Считать числа близкими или нет, определяют два аргумента rel_tol и abs_tol.

Аргумент rel_tol это относительный допуск, определяемый как максимально допустимая разница между числами a и b относительно большего из них по модулю. По умолчанию rel_tol=1e-09, что гарантирует, что числа a и b будут одинаковы, в пределах 9 десятичных цифр. Чтобы числа считались равными, если они, допустим, отличаются меньше чем на 0.1%, то достаточно установить rel_tol=0.001, но в любом случае данный параметр, должен быть больше нуля:

>>> y = 7.000001
>>> math.isclose(y, 6.999, rel_tol=0.001)
# True

Аргумент abs_tol это минимальный абсолютный допуск. полезен для сравнений, близких к нулю. Значение abs_tol должно быть не меньше нуля.

Данная функция эквивалентна команде abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol). Значения inf, -inf считаются близкими только сами к себе, а NaN не является близким ни к одному значению, включая само NaN.

math.lcm(*integers):

Функция math.lcm() возвращает наименьшее общее кратное указанных целочисленных аргументов *integers.

• Если все аргументы отличны от нуля, то возвращаемое значение является наименьшим положительным целым числом, кратным всем аргументам.
• Если какой-либо из аргументов равен нулю, то возвращается значение 0.
• Функция math.lcm(), вызванная без аргументов возвращает 1.

Новое в Python 3.9.

math.nextafter(x, y):

Функция math.nextafter() возвращает следующее значение float после x по направлению к y.

Если x равно y, то функция возвращает y.

Примеры:

• math.nextafter(x, math.inf) идет вверх: в сторону положительной бесконечности.
• math.nextafter(x, -math.inf) идет вниз: в сторону минус бесконечности.
• math.nextafter(x, 0.0) стремится к нулю.
• math.nextafter(x, math.copysign(math.inf, x)) уходит от нуля.

Новое в Python 3.9.

Смотрите также математическую функцию math.ulp().

math.ulp(x):

Функция math.isclose() возвращает значение наименьшего значащего бита числа float x.

• Если x – NaN (не число), то вернет x.
• Если x отрицательный, то вернет ulp(-x).
• Если x – положительная бесконечность, то вернет x.
• Если x равен нулю, то вернет наименьшее положительное денормализованное представимое число float (меньше минимального положительного нормализованного числа float, sys.float_info.min).
• Если x равен наибольшему положительному представимому числу float, то вернет значение младшего значащего бита x, так что первое число float меньше x будет x - ulp(x).
• В противном случае (x – положительное конечное число) вернет значение младшего значащего бита x, так что первое число float больше x равно x + ulp(x).

ULP означает “Единица на последнем месте”.

Новое в Python 3.9.

Смотрите также математическую функцию math.nextafter().