## LCM of two numbers

lcm of two numbers in c++
lcm of 3 and 6
lcm formula
lcm of 3 and 5
lcm examples
algorithm to find lcm of two numbers
lcm and hcf
how to find lcm of 3 numbers using prime factorization

I am getting wrong result for my LCM program.

Ifirst find gcd of the numbers and then divide the product with gcd.

```int gcd(int x, int y)
{
while(y != 0)
{
int save = y;
y = x % y;
x = save;
}
return y;
}

int lcm(int x, int y)
{
int prod = x * y;
int Gcd = gcd(x,y);
int lcm = prod / Gcd;

return lcm;
}
```

Any help much appreciated.

Your `gcd` function will always return `0`. Change

```return y;
```

to

```return x;
```

Understand the Euclid's algorithm:

```RULE 1: gcd(x,0) = x
RULE 2: gcd(x,y) = gcd(y,x % y)
```

consider `x = 12` and `y = 18`

```  gcd (12, 18)
= gcd (18, 12)  Using rule 2
= gcd (12,6)    Using rule 2
= gcd (6, 0)    Using rule 1
= 6
```

As you can see when `y` becomes zero `x` will be the `gcd` so you need to return `x` and not `y`.

Also while calculating lcm you are multiplying the numbers first which can cause overflow. Instead you can do:

```lcm = x * (y / gcd(x,y))
```

but if `lcm` cannot fit in an `int` you'll have to make it `long long`

LCM Calculator - Least Common Multiple, (40, 45) = 5, we get lcm(40, 45) = 40 × 45 / 5 = 360. Problem 1. For two integers a and b, denoted LCM (a,b), the LCM is the smallest positive integer that is evenly divisible by both a and b. For example, LCM (2,3) = 6 and LCM (6,10) = 30. The LCM of two or more numbers is the smallest number that is evenly divisible by all numbers in the set.

Problem 1) `int gcd = gcd(x,y);`

`gcd` is already defined to be a function. You cannot define a variable with the same name.

Problem 2) Change `return y` to `return x` in `gcd()` otherwise 0 will be returned everytime.

Problem 3) `x * y` may overflow if `x` and `y` are large.

Factoring - Least Common Multiple (LCM) - In Depth, What is the LCM of 2 numbers if one number is a multiple of the other? The LCM of two integers n1 and n2 is the smallest positive integer that is perfectly divisible by both n1 and n2 (without a remainder). For example: the LCM of 72 and 120 is 360. Example #1: LCM using while Loop and if Statement. Enter two positive integers: 72 120 The LCM of 72 and 120 is 360.

Also, are you sure the product x*y will always fit into an `int`? Might be a good idea to use a `long long` for that as well.

Least Common Multiples, Sal finds the LCM (least common multiple) of 12 and 36, and of 12 and 18. The least common Duration: 4:16 Posted: Nov 7, 2014 C Program to find LCM of Two Numbers using GCD. This LCM program in C allows the user to enter two positive integer values and we are going to calculate the Least Common Multiple of those two values using the While Loop. TIP: The basic formula behind the Least Common Multiple or LCM in C is: LCM(a, b) = (a * b) / GCD.

```#include <iostream>

using namespace std;

long long gcd(long long int a, long long int b){
if(b==0)
return a;
return gcd(b,a%b);
}

long long lcm(long long a,long long b){
if(a>b)
return (a/gcd(a,b))*b;
else
return (b/gcd(a,b))*a;
}

int main(){
long long int a ,b ;
cin>>a>>b;
cout<<lcm(a,b)<<endl;
return 0;
}
```

Ask Dr. Math Archives: LCM, GCF, The least common multiple, or LCM, is another number that's useful in solving many One way to find the least common multiple of two numbers is to first list the  Write a Python program to find LCM of two numbers using While Loop, Functions, and Recursion. In Mathematics, the Least Common Multiple (LCM) of two or more integers is the smallest positive integer that is perfectly divisible by the given integer values without the remainder.

This C program is different approach towards finding LCM

``` #include<stdio.h>
int main()
{
int a,b,lcm=1,i=2;
printf("Enter two numbers to find LCM\n" );
scanf("%d %d",&a ,&b);
while(i <= a*b)
{
if(a%i==0 & b%i==0)
{
lcm=lcm*i;
a=a/i;
b=b/i;
i=i-1;
}
if( a%i==0 & b%i!=0)
{
lcm=lcm*i;
a=a/i;
i=i-1;
}
if( b%i==0 & a%i!=0)
{
lcm=lcm*i;
b=b/i;
i=i-1;
}
i++;
}
printf("The LCM of numbers is %d\n", lcm);
}
```

Find LCM of 2 and 4, Find the LCM of two numbers using double division. Category. Education. Show more. Show Duration: 2:37 Posted: Oct 19, 2011 Free Least Common Multiplier (LCM) calculator - Find the lcm of two or more numbers step-by-step This website uses cookies to ensure you get the best experience. By using this website, you agree to our Cookie Policy.

Least common multiple (video), Find the LCM using the prime factors method. Find the prime factorization of each number Duration: 2:54 Posted: Jun 10, 2017 The least common multiple (LCM) of a group of numbers is the smallest number that is a multiple of all the numbers. To find the least common multiple you need to be able to identify the factors of the numbers you are working with. You can use a few different methods to find the least common multiple.

Find LCM of Two Numbers, In this example, you will learn to calculate the LCM (Lowest common multiple) of two numbers entered by the user using C programming. The least common multiple, or LCM, is another number that's useful in solving many math problems. Let's find the LCM of 30 and 45. One way to find the least common multiple of two numbers is to first list the prime factors of each number. 30 = 2 × 3 × 5. 45 = 3 × 3 × 5.

Finding the Least Common Multiple of Two Numbers, In arithmetic and number theory, the least common multiple, lowest common multiple, or smallest common multiple of two integers a and b, usually denoted by LCM(a,  In mathematics, the least common multiple, also known as the lowest common multiple of two (or more) integers a and b, is the smallest positive integer that is divisible by both. It is commonly denoted as LCM(a, b).

• If `x * y` can overflow then so can the result of `lcm`; it's the size of the type of the `lcm` function that is the determining factor. This should be written as `itype lcm(int x, int y) { return (itype)x / gcd(x, y) * y; }` where `itype` is an integer type large enough to hold any expected result.
• @user642371: It think you already understand why you have to return x and not y. About overflow, suppose both x and y are 2,000,000,000. This fits nicely in an `int` and their LCM is also 2,000,000,000 which is again no problem. But in the intermediate step you compute `x*y` and store it in an `int`. Now, `x*y` is 2,000,000,000*2,000,000,000 which is 4*10^18. This is too big for an `int` and will cause an overflow. You will het an erroneous value in `prod` and dividing it by the gcd will again give you a meaningless value since the original value has been list due to overflow.