# 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```

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.

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`