 Open in App
Not now

# LCM of First n Natural Numbers

• Difficulty Level : Medium
• Last Updated : 23 Jun, 2022

Given a number n such that 1 <= N <= 10^6, the Task is to Find the LCM of First n Natural Numbers.

Examples:

```Input : n = 5
Output : 60

Input : n = 6
Output : 60

Input : n = 7
Output : 420 ```

## We strongly recommend that you click here and practice it, before moving on to the solution.

We have discussed a simple solution in below article.
Smallest number divisible by first n numbers
The above solution works fine for single input. But if we have multiple inputs, it is a good idea to use Sieve of Eratosthenes to store all prime factors. As we know if LCM(a, b) = X so any prime factor of a or b will also be the prime factor of ‘X’.

1. Initialize lcm variable with 1
2. Generate a Sieve of Eratosthenes (bool vector isPrime) of length 10^6 (ideally must be equal to no. of digits in factorial)
3. Now, for each number in bool vector isPrime, if the number is prime (isPrime[i] is true), find the maximum number which is less than the given number and equal to power of the prime.
4. Then multiply this number with lcm variable.
5. Repeat step 3 and 4 until prime is less than the given number.

Illustration:

```For example, if n = 10
8 will be the first number which is equal to 2^3
then 9 which is equal to 3^2
then 5 which is equal to 5^1
then 7 which is equal to 7^1
Finally, we multiply those numbers 8*9*5*7 = 2520```

Below is the implementation of the above idea.

## C++

 `// C++ program to find LCM of First N Natural Numbers.``#include ``#define MAX 100000``using` `namespace` `std;` `vector<``bool``> isPrime (MAX, ``true``);``// utility function for sieve of sieve of Eratosthenes` `void` `sieve()``{``    ` `    ``for` `(``int` `i = 2; i * i <= MAX; i++)``    ``{``        ``if` `(isPrime[i] == ``true``)``            ``for` `(``int` `j = i*i; j<= MAX; j+=i)``                ``isPrime[j] = ``false``;``    ``}``}` `// Function to find LCM of first n Natural Numbers``long` `long` `LCM(``int` `n)``{``    ``long` `long` `lcm = 1;``    ``int` `i=2;   ``    ``while``(i<=n)    {``        ``if``(isPrime[i]){``            ``int` `pp = i;``            ``while` `(pp * i <= n)``                ``pp = pp * i;``            ``lcm *= pp;``        ``}``        ``i++;``    ``}``    ``return` `lcm;``}` `// Driver code``int` `main()``{``    ``// build sieve``    ``sieve();``    ``int` `N = 7;``    ``// Function call``    ``cout << LCM(N);``    ``return` `0;``}`

## Java

 `// Java program to find LCM of First N Natural Numbers.``import` `java.util.*;` `class` `GFG``{``    ``static` `int` `MAX = ``100000``;` `    ``// array to store all prime less than and equal to 10^6``    ``static` `ArrayList primes``        ``= ``new` `ArrayList();``    ``// utility function for sieve of sieve of Eratosthenes``    ``static` `void` `sieve()``    ``{``        ``boolean``[] isComposite = ``new` `boolean``[MAX + ``1``];``        ``for` `(``int` `i = ``2``; i * i <= MAX; i++)``        ``{``            ``if` `(isComposite[i] == ``false``)``                ``for` `(``int` `j = ``2``; j * i <= MAX; j++)``                    ``isComposite[i * j] = ``true``;``        ``}` `        ``// Store all prime numbers in vector primes[]``        ``for` `(``int` `i = ``2``; i <= MAX; i++)``            ``if` `(isComposite[i] == ``false``)``                ``primes.add(i);``    ``}` `    ``// Function to find LCM of first n Natural Numbers``    ``static` `long` `LCM(``int` `n)``    ``{``        ``long` `lcm = ``1``;``        ``for` `(``int` `i = ``0``;``             ``i < primes.size() && primes.get(i) <= n;``             ``i++)``        ``{``            ``// Find the highest power of prime, primes[i]``            ``// that is less than or equal to n``            ``int` `pp = primes.get(i);``            ``while` `(pp * primes.get(i) <= n)``                ``pp = pp * primes.get(i);` `            ``// multiply lcm with highest power of prime[i]``            ``lcm *= pp;``            ``lcm %= ``1000000007``;``        ``}``        ``return` `lcm;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``sieve();``        ``int` `N = ``7``;``      ` `        ``// Function call``        ``System.out.println(LCM(N));``    ``}``}``// This code is contributed by mits`

## Python3

 `# Python3 program to find LCM of``# First N Natural Numbers.``MAX` `=` `100000` `# array to store all prime less``# than and equal to 10^6``primes ``=` `[]` `# utility function for``# sieve of Eratosthenes`  `def` `sieve():` `    ``isComposite ``=` `[``False``]``*``(``MAX``+``1``)``    ``i ``=` `2``    ``while` `(i ``*` `i <``=` `MAX``):``        ``if` `(isComposite[i] ``=``=` `False``):``            ``j ``=` `2``            ``while` `(j ``*` `i <``=` `MAX``):``                ``isComposite[i ``*` `j] ``=` `True``                ``j ``+``=` `1``        ``i ``+``=` `1` `    ``# Store all prime numbers in``    ``# vector primes[]``    ``for` `i ``in` `range``(``2``, ``MAX``+``1``):``        ``if` `(isComposite[i] ``=``=` `False``):``            ``primes.append(i)` `# Function to find LCM of``# first n Natural Numbers`  `def` `LCM(n):` `    ``lcm ``=` `1``    ``i ``=` `0``    ``while` `(i < ``len``(primes) ``and` `primes[i] <``=` `n):``        ``# Find the highest power of prime,``        ``# primes[i] that is less than or``        ``# equal to n``        ``pp ``=` `primes[i]``        ``while` `(pp ``*` `primes[i] <``=` `n):``            ``pp ``=` `pp ``*` `primes[i]` `        ``# multiply lcm with highest``        ``# power of prime[i]``        ``lcm ``*``=` `pp``        ``lcm ``%``=` `1000000007``        ``i ``+``=` `1``    ``return` `lcm`  `# Driver code``sieve()``N ``=` `7` `# Function call``print``(LCM(N))` `# This code is contributed by mits`

## C#

 `// C# program to find LCM of First N``// Natural Numbers.``using` `System.Collections;``using` `System;` `class` `GFG {``    ``static` `int` `MAX = 100000;` `    ``// array to store all prime less than``    ``// and equal to 10^6``    ``static` `ArrayList primes = ``new` `ArrayList();` `    ``// utility function for sieve of``    ``// sieve of Eratosthenes``    ``static` `void` `sieve()``    ``{``        ``bool``[] isComposite = ``new` `bool``[MAX + 1];``        ``for` `(``int` `i = 2; i * i <= MAX; i++)``        ``{``            ``if` `(isComposite[i] == ``false``)``                ``for` `(``int` `j = 2; j * i <= MAX; j++)``                    ``isComposite[i * j] = ``true``;``        ``}` `        ``// Store all prime numbers in vector primes[]``        ``for` `(``int` `i = 2; i <= MAX; i++)``            ``if` `(isComposite[i] == ``false``)``                ``primes.Add(i);``    ``}` `    ``// Function to find LCM of first``    ``// n Natural Numbers``    ``static` `long` `LCM(``int` `n)``    ``{``        ``long` `lcm = 1;``        ``for` `(``int` `i = 0;``             ``i < primes.Count && (``int``)primes[i] <= n;``             ``i++)``        ``{``            ``// Find the highest power of prime, primes[i]``            ``// that is less than or equal to n``            ``int` `pp = (``int``)primes[i];``            ``while` `(pp * (``int``)primes[i] <= n)``                ``pp = pp * (``int``)primes[i];` `            ``// multiply lcm with highest power of prime[i]``            ``lcm *= pp;``            ``lcm %= 1000000007;``        ``}``        ``return` `lcm;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``sieve();``        ``int` `N = 7;``      ` `        ``// Function call``        ``Console.WriteLine(LCM(N));``    ``}``}` `// This code is contributed by mits`

## Javascript

 ``

## PHP

 ``

Output

`420`

Time Complexity: O(n2
Auxiliary Space: O(n)

Another Approach:

The idea is that if the number is less than 3 then return number. If the number is greater than 2 then find LCM of n,n-1

• Lets say x=LCM(n,n-1)
• again x=LCM(x,n-2)
• again x=LCM(x,n-3) …
• .
• .
• again x=LCM(x,1) …

now the result is x.

For finding LCM(a,b) we use a function hcf(a,b) whichwill return HCF of (a,b)

We know that LCM(a,b)= (a*b)/HCF(a,b)

Illustration:

```For example, if n = 7
function call lcm(7,6)
now lets say a=7 , b=6

Now , b!= 1 Hence
a=lcm(7,6) = 42 and b=6-1=5

function call lcm(42,5)
a=lcm(42,5) = 210 and b=5-1=4

function call lcm(210,4)
a=lcm(210,4) = 420 and b=4-1=3

function call lcm(420,3)
a=lcm(420,3) = 420 and b=3-1=2

function call lcm(420,2)
a=lcm(420,2) = 420 and b=2-1=1

Now b=1
Hence return a=420```

Below is the implementation of the above approach

## C++

 `// C++ program to find LCM of First N Natural Numbers.``#include ``using` `namespace` `std;` `// to calculate hcf``int` `hcf(``int` `a, ``int` `b)``{``    ``if` `(b == 0)``        ``return` `a;``    ``return` `hcf(b, a % b);``}`  `int` `findlcm(``int` `a,``int` `b)``{``    ``if` `(b == 1)``      ` `        ``// lcm(a,b)=(a*b)/hcf(a,b)``        ``return` `a;``  ` `    ``// assign a=lcm of n,n-1``    ``a = (a * b) / hcf(a, b);``  ` `    ``// b=b-1``    ``b -= 1;``    ``return` `findlcm(a, b);``}` `// Driver code``int` `main()``{``    ``int` `n = 7;``    ``if` `(n < 3)``        ``cout << n; ``// base case``    ``else``       ` `        ``// Function call``        ``// pass n,n-1 in function to find LCM of first n natural``        ``// number``        ``cout << findlcm(n, n - 1);``    ` `    ``return` `0;``}` `// contributed by ajaykr00kj`

## Java

 `// Java program to find LCM of First N Natural Numbers``public` `class` `Main``{``  ``// to calculate hcf``  ``static` `int` `hcf(``int` `a, ``int` `b)``  ``{``    ``if` `(b == ``0``)``      ``return` `a;``    ``return` `hcf(b, a % b);``  ``}`  `  ``static` `int` `findlcm(``int` `a,``int` `b)``  ``{``    ``if` `(b == ``1``)` `      ``// lcm(a,b)=(a*b)/hcf(a,b)``      ``return` `a;` `    ``// assign a=lcm of n,n-1``    ``a = (a * b) / hcf(a, b);` `    ``// b=b-1``    ``b -= ``1``;``    ``return` `findlcm(a, b);``  ``}` `  ``// Driver code.``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `n = ``7``;``    ``if` `(n < ``3``)``      ``System.out.print(n); ``// base case``    ``else` `      ``// Function call``      ``// pass n,n-1 in function to find LCM of first n natural``      ``// number``      ``System.out.print(findlcm(n, n - ``1``));``  ``}``}` `// This code is contributed by divyeshrabadiya07.`

## Python3

 `# Python3 program to find LCM``# of First N Natural Numbers.` `# To calculate hcf``def` `hcf(a, b):``    ` `    ``if` `(b ``=``=` `0``):``        ``return` `a``        ` `    ``return` `hcf(b, a ``%` `b)``    ` `def` `findlcm(a, b):``    ` `    ``if` `(b ``=``=` `1``):``        ` `        ``# lcm(a,b)=(a*b)//hcf(a,b)``        ``return` `a``    ` `    ``# Assign a=lcm of n,n-1``    ``a ``=` `(a ``*` `b) ``/``/` `hcf(a, b)``    ` `    ``# b=b-1``    ``b ``-``=` `1``    ` `    ``return` `findlcm(a, b)` `# Driver code``n ``=` `7` `if` `(n < ``3``):``    ``print``(n)``else``:``    ` `    ``# Function call``    ``# pass n,n-1 in function``    ``# to find LCM of first n``    ``# natural number``    ``print``(findlcm(n, n ``-` `1``))` `# This code is contributed by Shubham_Singh`

## C#

 `// C# program to find LCM of First N Natural Numbers.``using` `System;``class` `GFG {` `  ``// to calculate hcf``  ``static` `int` `hcf(``int` `a, ``int` `b)``  ``{``    ``if` `(b == 0)``      ``return` `a;``    ``return` `hcf(b, a % b);``  ``}` `  ``static` `int` `findlcm(``int` `a,``int` `b)``  ``{``    ``if` `(b == 1)` `      ``// lcm(a,b)=(a*b)/hcf(a,b)``      ``return` `a;` `    ``// assign a=lcm of n,n-1``    ``a = (a * b) / hcf(a, b);` `    ``// b=b-1``    ``b -= 1;``    ``return` `findlcm(a, b);``  ``}` `  ``// Driver code``  ``static` `void` `Main() {``    ``int` `n = 7;``    ``if` `(n < 3)``      ``Console.Write(n); ``// base case``    ``else` `      ``// Function call``      ``// pass n,n-1 in function to find LCM of first n natural``      ``// number``      ``Console.Write(findlcm(n, n - 1));``  ``}``}` `// This code is contributed by divyesh072019.`

## Javascript

 ``

Output

`420`

Time complexity : O(nlog n)
Auxiliary Space: O(1)

This article is contributed by Aarti_Rathi and Kuldeep Singh (kulli_d_coder). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.