Skip to content
Related Articles
Finding LCM of more than two (or array) numbers without using GCD
• Difficulty Level : Medium
• Last Updated : 22 Apr, 2021

Given an array of positive integers, find LCM of the elements present in array.
Examples:

```Input : arr[] = {1, 2, 3, 4, 28}
Output : 84

Input  : arr[] = {4, 6, 12, 24, 30}
Output : 120```

We have discussed LCM of array using GCD.
In this post a different approach is discussed that doesn’t require computation of GCD. Below are steps.

1. Initialize result = 1
2. Find a common factors of two or more array elements.
3. Multiply the result by common factor and divide all the array elements by this common factor.
4. Repeat steps 2 and 3 while there is a common factor of two or more elements.
5. Multiply the result by reduced (or divided) array elements.

Illustration :

```Let we have to find the LCM of
arr[] = {1, 2, 3, 4, 28}

We initialize result = 1.

2 is a common factor that appears in
two or more elements. We divide all
multiples by two and multiply result
with 2.
arr[] = {1, 1, 3, 2, 14}
result = 2

2 is again a common factor that appears
in two or more elements. We divide all
multiples by two and multiply result
with 2.
arr[] = {1, 1, 3, 1, 7}
result = 4

Now there is no common factor that appears
in two or more array elements. We multiply
all modified array elements with result, we
get.
result = 4 * 1 * 1 * 3 * 1 * 7
= 84```

Below is the implementation of above algorithm.

## C++

 `// C++ program to find LCM of array without``// using GCD.``#include``using` `namespace` `std;` `// Returns LCM of arr[0..n-1]``unsigned ``long` `long` `int` `LCM(``int` `arr[], ``int` `n)``{``    ``// Find the maximum value in arr[]``    ``int` `max_num = 0;``    ``for` `(``int` `i=0; i indexes;``        ``for` `(``int` `j=0; j= 2)``        ``{``            ``// Reduce all array elements divisible``            ``// by x.``            ``for` `(``int` `j=0; j

## Java

 `import` `java.util.Vector;` `// Java program to find LCM of array without``// using GCD.``class` `GFG {` `// Returns LCM of arr[0..n-1]``    ``static` `long` `LCM(``int` `arr[], ``int` `n) {``        ``// Find the maximum value in arr[]``        ``int` `max_num = ``0``;``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``if` `(max_num < arr[i]) {``                ``max_num = arr[i];``            ``}``        ``}` `        ``// Initialize result``        ``long` `res = ``1``;` `        ``// Find all factors that are present in``        ``// two or more array elements.``        ``int` `x = ``2``; ``// Current factor.``        ``while` `(x <= max_num) {``            ``// To store indexes of all array``            ``// elements that are divisible by x.``            ``Vector indexes = ``new` `Vector<>();``            ``for` `(``int` `j = ``0``; j < n; j++) {``                ``if` `(arr[j] % x == ``0``) {``                    ``indexes.add(indexes.size(), j);``                ``}``            ``}` `            ``// If there are 2 or more array elements``            ``// that are divisible by x.``            ``if` `(indexes.size() >= ``2``) {``                ``// Reduce all array elements divisible``                ``// by x.``                ``for` `(``int` `j = ``0``; j < indexes.size(); j++) {``                    ``arr[indexes.get(j)] = arr[indexes.get(j)] / x;``                ``}` `                ``res = res * x;``            ``} ``else` `{``                ``x++;``            ``}``        ``}` `        ``// Then multiply all reduced array elements``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``res = res * arr[i];``        ``}` `        ``return` `res;``    ``}` `// Driver code``    ``public` `static` `void` `main(String[] args) {``        ``int` `arr[] = {``1``, ``2``, ``3``, ``4``, ``5``, ``10``, ``20``, ``35``};``        ``int` `n = arr.length;``        ``System.out.println(LCM(arr, n));``    ``}``}`

## Python3

 `# Python3 program to find LCM of array``# without using GCD.` `# Returns LCM of arr[0..n-1]``def` `LCM(arr, n):``    ` `    ``# Find the maximum value in arr[]``    ``max_num ``=` `0``;``    ``for` `i ``in` `range``(n):``        ``if` `(max_num < arr[i]):``            ``max_num ``=` `arr[i];` `    ``# Initialize result``    ``res ``=` `1``;` `    ``# Find all factors that are present``    ``# in two or more array elements.``    ``x ``=` `2``; ``# Current factor.``    ``while` `(x <``=` `max_num):``        ` `        ``# To store indexes of all array``        ``# elements that are divisible by x.``        ``indexes ``=` `[];``        ``for` `j ``in` `range``(n):``            ``if` `(arr[j] ``%` `x ``=``=` `0``):``                ``indexes.append(j);` `        ``# If there are 2 or more array``        ``# elements that are divisible by x.``        ``if` `(``len``(indexes) >``=` `2``):``            ` `            ``# Reduce all array elements``            ``# divisible by x.``            ``for` `j ``in` `range``(``len``(indexes)):``                ``arr[indexes[j]] ``=` `int``(arr[indexes[j]] ``/` `x);` `            ``res ``=` `res ``*` `x;``        ``else``:``            ``x ``+``=` `1``;` `    ``# Then multiply all reduced``    ``# array elements``    ``for` `i ``in` `range``(n):``        ``res ``=` `res ``*` `arr[i];` `    ``return` `res;` `# Driver code``arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``10``, ``20``, ``35``];``n ``=` `len``(arr);``print``(LCM(arr, n));` `# This code is contributed by chandan_jnu`

## C#

 `// C# program to find LCM of array``// without using GCD.``using` `System;``using` `System.Collections;``class` `GFG``{` `// Returns LCM of arr[0..n-1]``static` `long` `LCM(``int` `[]arr, ``int` `n)``{``    ``// Find the maximum value in arr[]``    ``int` `max_num = 0;``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``if` `(max_num < arr[i])``        ``{``            ``max_num = arr[i];``        ``}``    ``}` `    ``// Initialize result``    ``long` `res = 1;` `    ``// Find all factors that are present``    ``// in two or more array elements.``    ``int` `x = 2; ``// Current factor.``    ``while` `(x <= max_num)``    ``{``        ``// To store indexes of all array``        ``// elements that are divisible by x.``        ``ArrayList indexes = ``new` `ArrayList();``        ``for` `(``int` `j = 0; j < n; j++)``        ``{``            ``if` `(arr[j] % x == 0)``            ``{``                ``indexes.Add(j);``            ``}``        ``}` `        ``// If there are 2 or more array elements``        ``// that are divisible by x.``        ``if` `(indexes.Count >= 2)``        ``{``            ``// Reduce all array elements divisible``            ``// by x.``            ``for` `(``int` `j = 0; j < indexes.Count; j++)``            ``{``                ``arr[(``int``)indexes[j]] = arr[(``int``)indexes[j]] / x;``            ``}` `            ``res = res * x;``        ``} ``else``        ``{``            ``x++;``        ``}``    ``}` `    ``// Then multiply all reduced``    ``// array elements``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``res = res * arr[i];``    ``}` `    ``return` `res;``}` `// Driver code``public` `static` `void` `Main()``{``    ``int` `[]arr = {1, 2, 3, 4, 5, 10, 20, 35};``    ``int` `n = arr.Length;``    ``Console.WriteLine(LCM(arr, n));``}``}` `// This code is contributed by mits`

## PHP

 `= 2)``        ``{``            ``// Reduce all array elements``            ``// divisible by x.``            ``for` `(``\$j` `= 0; ``\$j` `< ``count``(``\$indexes``); ``\$j``++)``                ``\$arr``[``\$indexes``[``\$j``]] = (int)(``\$arr``[``\$indexes``[``\$j``]] / ``\$x``);` `            ``\$res` `= ``\$res` `* ``\$x``;``        ``}``        ``else``            ``\$x``++;``    ``}` `    ``// Then multiply all reduced``    ``// array elements``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)``        ``\$res` `= ``\$res` `* ``\$arr``[``\$i``];` `    ``return` `\$res``;``}` `// Driver code``\$arr` `= ``array``(1, 2, 3, 4, 5, 10, 20, 35);``\$n` `= ``count``(``\$arr``);``echo` `LCM(``\$arr``, ``\$n``) . ``"\n"``;` `// This code is contributed by chandan_jnu``?>`

## Javascript

 ``

Output:

`420`

This article is contributed by Aditya Kumar. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up