# LCM Program in C++

## What is LCM?

LCM is an acronym for "least common multiple". It is used to discover the lowest positive integer divisible by all integers (whose LCM is calculated). For instance, the LCM of 3 and 4 is 12, as shown by:

``LCM(3,4) = 12``

As you can see, the numbers 3 and 4 are divisors of 12.

LCM stands for "Least Common Multiple" and Least Common Divisor (LCD), both have the same meaning, which is to discover a number that is divisible by the provided integers (whose LCM is to be calculated).

## Finding LCM of two numbers in C++:

In C++ language, you must ask the user to provide the two integers to determine the LCF. Then, as illustrated in the software below, locate and print its LCM on output.

LCM stands for Lowest Common Multiple, often known as Least Common Divisor. Consider the case of two numbers, say 4 and 5. Then 20 is the Least Common Divisor. That is, the numbers 4 and 5 divide 20 evenly without any residue (or leaving the remainder 0).

### Algorithm for the LCM of two numbers in C++:

Step 1: Take num1 and num2 as inputs from the user.

Step 2: In the max variable, keep the lowest common multiple of num1 and num2.

Step 3: Check if the max variable is divisible by num1 and num2, then output the max as the LCM of two values.

Step 4: If not, the max value is incremented by 1 with each iteration, and the max variable's divisibility is checked in step 3.

Step 5: Close the application.

### Finding LCM of two numbers:

In the following program, we will use if and else statements and while loop to find the LCM of two numbers.

Example:

``````#include<iostream>
using namespace std;
int main()
{
Int num1, num2, n;
cout<<"Enter the Two Numbers: ";
cin>>num1>>num2;
if(num1>num2)
n = num1;
else
n = num2;
while(1)
{
if((n%num1 == 0) && (n%num2 == 0))
break;
else
n++;
}
cout<<"\nCM ("<<num1<<", "<<num2<<") = "<<n;
cout<<endl;
return 0;
}
``````

Output:

`Enter the Two Numbers:45LCM(4,5)=20`

Explanation:

The following is the main rationale behind the program:

N is initialized with the bigger number. When 1 is used as a condition in a while loop, it always returns true. As a result, this loop will continue to execute until the break keyword is used. When both the if (within while loop) condition and the break keyword evaluate to true, the break keyword is performed. When entering the body of the while loop, an if condition is performed, which checks if the value in n is divisible by both numbers. If the number is divisible, use the break keyword to terminate the loop. Otherwise, increase its value and check again with next.

## Finding LCM of two numbers using the HCF:

In C++, we may use HCF(highest Common Factor) or GCD(Greatest Common Divisor) to calculate the LCM of two numbers. To do so, we must apply the formula below: HCF(x,y) and LCM are equivalent when two numbers x and y are added together (x,y).

``````HCF(x,y) * LCM = x*y (x,y)
or
LCM(x,y) = (x*y) / HCF(x,y)
``````

To find the LCM of two integers in C++, use the program below. We determine the HCF first, then compute the LCM using the technique above.

Example:

``````#include<iostream>
using namespace std;
int main()
{
// declaring variables
int numOne, numTwo, hcf, tmp, lcm;

// taking the input
cout << "Enter the two Integers: ";
cin >> numOne >> numTwo;

// assigning the values
hcf = numOne;
tmp = numTwo;

// calculating the value of HCF
while (hcf != tmp)
{
( hcf > tmp ) ? (hcf -= tmp) : (tmp -= hcf);
}

// calculate the value of LCM
lcm = (numOne * numTwo) / hcf;

// displaying the result
cout << "LCM = " << lcm << endl;

return 0;
}
``````

Output:

`Enter the two Integers: 34LCM = 12`

Explanation:

In the above example, in the main() function we first declared the int variables numOne, numTwo, tmp , hcf and lcm. The input values of the two numbers numOne and numTwo were taken and the values were assigned to the variables hcf and tmp. Then using a formula, the value of hcf was found and then value of lcm was found too. Hence, the required output was printed.

## Finding LCM of the two numbers using Recursion:

The recursion approach may also be used to get the lcm of two integers. Recursion is a means of defining a method or function that includes a call to itself.

The recursive function/method helps us to break down a big problem into readily manageable single basic situations. Divide and conquer is a very well know computer programming strategy.

Example:

``````#include<iostream>
using namespace std;

// defining a global variable
static int cmmn;

//declaring the function
long lcm(int, int);

// calling main function
int main()
{
// declaring the variables
int numOne, numTwo;

// taking the input
cout << "Enter the two Integers: ";
cin >> numOne >> numTwo;

// displaying the result
cout << "LCM = " << lcm(numOne, numTwo) << endl;

return 0;
}

// function for finding the value of LCM
long lcm(int nOne, int nTwo)
{
// increased cmmn
cmmn += nTwo;
if(cmmn % nOne == 0)
return cmmn; // base-case
else
return lcm(nOne, nTwo); //general-case
}
``````

Output:

`Enter the two Integers: 56LCM = 30`

Explanation:

In the above example, we used the recursion aSpproach to find the LCM of two numbers. A global variable cmmn of int datatype was defined. Then we declared a function lcm() with two int values and called the main() function. The Two variables numOne and numTwo were declared and were used to receive values from the user. When the function lcm() was called, an if-else loop was run with respective conditions for calculating the LCM. Hence, the required output was printed.