# 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:4

5

LCM(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: 3

4

LCM = 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: 5

6

LCM = 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.