Finding LCM of more than two (or array) numbers without using GCD
Last Updated :
26 May, 2022
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.
- Initialize result = 1
- Find a common factors of two or more array elements.
- Multiply the result by common factor and divide all the array elements by this common factor.
- Repeat steps 2 and 3 while there is a common factor of two or more elements.
- 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<bits/stdc++.h>
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<n; i++)
if (max_num < arr[i])
max_num = arr[i];
// Initialize result
unsigned long long int 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<int> indexes;
for (int j=0; j<n; j++)
if (arr[j]%x == 0)
indexes.push_back(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[j]] = arr[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
int main()
{
int arr[] = {1, 2, 3, 4, 5, 10, 20, 35};
int n = sizeof(arr)/sizeof(arr[0]);
cout << LCM(arr, n) << "\n";
return 0;
}
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<Integer> 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 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# 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
// PHP program to find LCM of array
// without using GCD.
// Returns LCM of arr[0..n-1]
function LCM($arr, $n)
{
// Find the maximum value in arr[]
$max_num = 0;
for ($i = 0; $i < $n; $i++)
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 = array();
for ($j = 0; $j < $n; $j++)
if ($arr[$j] % $x == 0)
array_push($indexes, $j);
// If there are 2 or more array
// elements that are divisible by x.
if (count($indexes) >= 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
?>
<script>
// Javascript program to find LCM of array without
// using GCD.
// Returns LCM of arr[0..n-1]
function LCM(arr, n)
{
// Find the maximum value in arr[]
var max_num = 0;
for (var i = 0; i < n; i++)
if (max_num < arr[i])
max_num = arr[i];
// Initialize result
var res = 1;
// Find all factors that are present in
// two or more array elements.
var x = 2; // Current factor.
while (x <= max_num)
{
// To store indexes of all array
// elements that are divisible by x.
var indexes = [];
for (var j = 0; j < n; j++)
if (arr[j] % x == 0)
indexes.push(j);
// If there are 2 or more array elements
// that are divisible by x.
if (indexes.length >= 2)
{
// Reduce all array elements divisible
// by x.
for (var j = 0; j < indexes.length; j++)
arr[indexes[j]] = arr[indexes[j]]/x;
res = res * x;
}
else
x++;
}
// Then multiply all reduced array elements
for (var i = 0; i < n; i++)
res = res*arr[i];
return res;
}
// Driver code
var arr = [1, 2, 3, 4, 5, 10, 20, 35];
var n = arr.length;
document.write( LCM(arr, n) + "<br>");
// This code is contributed by rrrtnx.
</script>
Output:
420
Time Complexity: O(max * n), where n represents the size of the given array and m represents the maximum element present in the array.
Auxiliary Space: O(n), where n represents the size of the given array.
Similar Reads
Program to find LCM of 2 numbers without using GCD Finding LCM using GCD is explained here but here the task is to find LCM without first calculating GCD.Examples: Input: 7, 5 Output: 35 Input: 2, 6 Output: 6 The approach is to start with the largest of the 2 numbers and keep incrementing the larger number by itself till smaller number perfectly div
4 min read
GCD of more than two (or array) numbers Given an array arr[] of non-negative numbers, the task is to find GCD of all the array elements. In a previous post we find GCD of two number.Examples:Input: arr[] = [1, 2, 3]Output: 1Input: arr[] = [2, 4, 6, 8]Output: 2Using Recursive GCDThe GCD of three or more numbers equals the product of the pr
11 min read
How to find GCD of more than 2 numbers Greatest Common Divisor (GCD) of two or more integers is the largest positive integer that divides each of the integers without leaving a remainder. It can also be referred to as the Greatest Common Factor (GCF) or Highest Common Factor (HCF). Example, the GCD of 12 and 18 is 6, as 6 is the largest
5 min read
Program to find LCM of two numbers Given two positive integers a and b. Find the Least Common Multiple (LCM) of a and b.LCM of two numbers is the smallest number which can be divided by both numbers. Input : a = 10, b = 5Output : 10Explanation : 10 is the smallest number divisible by both 10 and 5Input : a = 5, b = 11Output : 55Expla
5 min read
Find the GCD of LCM of all unique pairs in an Array Given an integer array arr[] of size N, the task is to find the GCD of LCM of all unique pair (i, j) of the array, such that i < j.Examples: Input: arr[] = {10, 24, 40, 80} Output: 40 Explanation: LCM of all unique pairs following given conditions are: LCM(10, 24) = 120 LCM(10, 40) = 40 LCM(10, 8
9 min read