Как найти наименьшее общее кратное программирование

Наименьшее общее кратное

 

Наименьшее общее кратное (НОК) двух целых чисел m и n есть наименьшее натуральное число, которое делится на m и n без остатка.
Зная наибольший общий делитель (НОД) двух целых чисел m и n, их наименьшее общее кратное можно вычислить по такой формуле:

НОК = m * n / НОД (m, n)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <iostream>
using namespace std;
// Наибольший общий делитель
int NOD(int n1, int n2)
{
  int div;
  if (n1 == n2)  return n1;
  int d = n1 — n2;
  if (d < 0) {
    d = -d;  div = NOD(n1, d);
  } else
    div = NOD(n2, d); 
  return div;
}
// Наименьшее общее кратное
int NOK(int n1, int n2) 

  return n1*n2 / NOD(n1, n2); 
}
int main() 
{
  int n1, n2;
  cout << «n1=»;
  cin >> n1;
  cout << «n2=»;
  cin >> n2;
  cout << NOK(n1, n2);
  cin.get(); cin.get();
  return 0;
}

Результат выполнения
Наименьшее общее кратное: результат выполнения

Назад: Алгоритмизация

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

Но прежде чем мы начнем, давайте разберем, что обозначает Least Common Multiple (LCM) — наименьшее общее кратное.

НОК: наименьшее общее кратное

Это понятие арифметики и системы счисления. НОК двух целых чисел a и b обозначается НОК(a,b). Это наименьшее натуральное число, которое делится и на «а», и на «b».

Например: у нас есть два целых числа 4 и 6. Найдем НОК:

  • Кратные 4:
 
4, 8, 12, 16, 20, 24, 28, 32, 36,... and so on... 
  • Кратные 6:
 
6, 12, 18, 24, 30, 36, 42,... and so on.... 

Общие кратные 4 и 6 — это просто числа, которые есть в обоих списках:

 
12, 24, 36, 48, 60, 72,.... and so on.... 

НОК — это наименьший общий множитель, поэтому он равен 12.

Поскольку мы поняли основную концепцию НОК, давайте рассмотрим следующую программу для нахождения НОК заданных целых чисел.

Пример:

 
# defining a function to calculate LCM 
def calculate_lcm(x, y): 
    # selecting the greater number 
    if x > y: 
        greater = x 
    else: 
        greater = y 
    while(True): 
        if((greater % x == 0) and(greater % y == 0)): 
            lcm = greater 
            break 
        greater += 1 
    return lcm   
 
# taking input from users 
num1 = int(input("Enter first number: ")) 
num2 = int(input("Enter second number: ")) 
# printing the result for the users 
print("The L.C.M. of", num1,"and", num2,"is", calculate_lcm(num1, num2)) 

Выход:

Enter first number: 3 
Enter second number: 4 
The L.C.M. of 3 and 4 is 12 

Объяснение:

Эта программа сохраняет два числа в num1 и num2 соответственно. Эти числа передаются в функцию calculate_lcm(). Функция возвращает НОК двух чисел.

Внутри функции мы сначала определили большее из двух чисел, поскольку наименьшее общее кратное может быть больше или равно наибольшему числу. Затем мы используем бесконечный цикл while, чтобы перейти от этого числа и дальше.

На каждой итерации мы проверяли, идеально ли делят оба числа число. Если это так, мы сохранили число как НОК и вышли из цикла. В противном случае число увеличивается на 1, и цикл продолжается.

НОД: наибольший общий делитель

В этом разделе мы разберем, как найти Highest Common Factor (HCF) — наибольший общий делитель (НОД) в языке программирования Python.

Наибольший общий делитель двух или более целых чисел, когда хотя бы одно из них не равно нулю, является наибольшим положительным целым числом, которое без остатка делит целые числа. Например, НОД 8 и 12 равен 4.

Например:

У нас есть два целых числа 8 и 12. Найдем наибольший общий делитель.

  • Делители числа 8:
 
1, 2, 4, 8 
  • Делители числа 12:
 
1, 2, 3, 4, 6, 12 

НОД 8 и 12 равны 4.

Теперь давайте рассмотрим пример, основанный на нахождении НОД двух заданных чисел.

Пример:

 
# defining a function to calculate HCF 
def calculate_hcf(x, y): 
    # selecting the smaller number 
    if x > y: 
        smaller = y 
    else: 
        smaller = x 
    for i in range(1,smaller + 1): 
        if((x % i == 0) and(y % i == 0)): 
            hcf = i 
    return hcf 
 
# taking input from users 
num1 = int(input("Enter first number: ")) 
num2 = int(input("Enter second number: ")) 
# printing the result for the users 
print("The H.C.F. of", num1,"and", num2,"is", calculate_hcf(num1, num2)) 

Выход:

Enter first number: 8 
Enter second number: 12 
The H.C.F. of 8 and 12 is 4 

Объяснение:

В приведенном выше фрагменте кода два целых числа, хранящиеся в переменных num1 и num2, передаются в функцию calculate_hcf(). Функция вычисляет НОД для этих двух чисел и возвращает его.

Внутри функции мы должны определить меньшее число, поскольку НОД может быть меньше или равен наименьшему числу. Затем мы использовали цикл for, чтобы перейти от 1 к этому числу.

На каждой итерации мы должны проверять, точно ли число делит оба входных числа. Если это так, мы должны сохранить число как НОД. По завершении цикла мы получаем наибольшее число, которое идеально делит оба числа.

1196-1017cookie-checkНахождение НОК и НОД в Python — примеры

Материалы этой главы ещё в разработке.

Подпишитесь на обновления, и мы сообщим, когда они будут доступны, — или расскажем о других новостях.

Наименьшее общее кратное

Написать функцию, которая вычисляет наименьшее общее кратное (НОК) пары чисел по формуле

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

где a и b — это натуральные числа, НОД — наибольший общий делитель.

Решение задачи на языке программирования Python

Из условия задачи ясно, чтобы найти НОК, надо сначала найти НОД. Последний можно вычислить, постепенно находя остаток от деления большего числа из пары на меньшее и присваивая остаток переменной, связанной с большим числом (см. алгоритм Евклида). В какой-то момент значение одной из переменных станет равным 0. Когда это произойдет, другая будет содержать НОД. Если неизвестно, какая именно переменная содержит НОД, то можно просто сложить значения обоих переменных.

В коде ниже используется функция для нахождения НОК, которая принимает два числа и возвращает найденное наименьшее общее кратное.

В основной ветке программы функция вызывается в цикле, который завершается, если то, что было введено, нельзя преобразовать к целому. В этом случае генерируется исключение и поток выполнения переходит к ветке except.

def lcm(a, b):
    m = a * b
    while a != 0 and b != 0:
        if a > b:
            a %= b
        else:
            b %= a
    return m // (a + b)
 
 
while 1:
    try:
        x = int(input('a = '))
        y = int(input('b = '))
        print('НОК:', lcm(x, y))
    except ValueError:
        break

Пример выполнения:

a = 14
b = 18
НОК: 126
a = 105
b = 305
НОК: 6405
a = stop

В модуле math языка программирования Python есть функция для нахождения наибольшего общего делителя (gcd — greatest common devisor). При ее использовании наша функция вычисления наименьшего общего кратного lcm (least common multiple) упрощается.

def lcm(a, b):
    import math
    return (a * b) // math.gcd(a, b)

Больше задач в PDF

Однострочники на С++

Время на прочтение
2 мин

Количество просмотров 58K

image
На хабе появилось несколько топиков об «однострочниках» на разных языках, которые решали простые задачи. Я решил опубликовать несколько алгоритмов на языке C/С++.
Итак, поехали!

1. Алгоритм Евклида

Рекурсивный алгоритм нахождения наибольшего общего делителя.

int GCD(int a,int b) {
  return b?GCD(b,a%b):a;
}

2. Нахождение НОК

Рекурсивный алгоритм нахождения наименьшего общего кратного.

int LCM(int a,int b) {
  return a/GCD(a,b) * b;
}

3. Проверка числа 2^n

Алгоритм проверки числа на степень 2.

int isPow2(int a) {
  return !(a&(a-1));
}

4. Функция обмена двух переменных

Этот алгоритм работает при помощи свойства симметричного различия, которым обладает XOR и не требует наличия третей переменой.

void swap(int *a, int *b) {
    *a ^= (*b ^= (*a ^= *b));
}

5. Алгоритм возведения в степень

Степень числа за линейное время.
Условие окончания рекурсии: если степень числа равно 0, то a^0=1.

int pow(int a,int n) {
  return (!n)?1:a*pow(a,n-1);
}

6. Индийский алгоритм возведения в степень

Степень числа за логарифмическое время.

int powInd(int a,int n) {
  return (!n)?1:((n&1)?a:1)*powInd(a*a,n/2);
}

7. Факториал числа

Факториал целого неотрицательного числа n.
Условие продолжения рекурсии: факториал ето произведение всех натуральных чисел до n включительно.
Условие окончания рекурсии: если число равно 0, то 0!=1.

int fac(int n) {
  return n?n*fac(n-1):1;
}

8. Сумма цифр числа

Условие продолжения рекурсии: сума цифр числа равна последней цифре плюс сума цифр числа без последней цифры.
Условие окончания рекурсии: если число равно 0, то и сума цифр равна 0.

int count(int a) {
  return (!a)?0:(a%10+count(a/10));
}

9. Числа Фибоначчи

Числа Фибоначчи — элементы числовой последовательности в которой каждое последующее число равно сумме двух предыдущих чисел.

int fib(int n) {
  return (n<=2)?1:(fib(n-1)+fib(n-2));
}

10. Следующее число Фибоначчи

Функция нахождения чисел Фибоначчи.

int fibNext(int &f1,int &f2) {
  return f1=(f2+=f1)-f1;
}

11. Числа Мерсенна

Числа Мерсе́нна — числа вида image

int Mersen(int n) {
	return !(n&(n+1));
}

12. Min & Max


int max(int a,int b) {
  return (a>b)?a:b;
}

int min(int a,int b) {
  return (a>b)?b:a;
}

13. Сравнение двух чисел

Функция возвращает значение разницы между двумя числами, поэтому если разница больше 0, то число a больше b, если равна 0, то числа одинаковы, иначе число a меньше b.


template <typename TYPE>
int compare (const TYPE a, const TYPE b){
   return ( a - b );
}

14. Возведение числа 2 в степень n

C помощью сдвига единицы на n битов ми вычислим двойку в степени n.


int pow2(int n) {
  return 1<<n;
}

Однострочники из коментов

Нахождение НОК от Lertmind


int lcm(int a, int b) {
    return (b < 1 ? (b ? lcm(b, a % b) : a) : (a / -lcm(-b, -a % b) * b));
}
Число ненулевых битов в числе от Mrrl


int NBit(unsigned int x){
  return x==0 ? 0 : (x&1)+NBit(x>>1);
}
Максимальная степень двойки, на которую делится n от Mrrl


int MaxDivPow2(int n){
  return n&-n;
}
Сравнение двух чисел от Lertmind


int cmp(int a, int b) {
    return (a < b ? -1 : (a > b ? 1 : 0));
}

или шаблон


template<typename T>
int cmp(const T &a, const T &b) {
    return (a < b ? -1 : a > b);
}
Найти k-й бит в массиве int * (считая, что sizeof(int)==4) от Mrrl


int GetBit(int *a,int k){
  return (a[k>>5]>>(k&31))&1;
}

Жду ещё алгоритмов в коментах…

Понравилась статья? Поделить с друзьями:
  • Как исправить брови нитки
  • Как составить сообщение в интернете
  • Как найти шаг зубьев зубчатого колеса
  • Как составить декоративный натюрморт
  • Пропалил куртку сигаретой как исправить