Skip to content
Related Articles
Prime factors of LCM of array elements
• Difficulty Level : Medium
• Last Updated : 18 Jun, 2021

Given an array arr[] such that 1 <= arr[i] <= 10^12, the task is to find prime factors of LCM of array elements.
Examples:

```Input  : arr[] = {1, 2, 3, 4, 5, 6, 7, 8}
Output : 2 3 5 7
// LCM of n elements is 840 and 840 = 2*2*2*3*5*7
// so prime factors would be 2, 3, 5, 7

Input  : arr[] = {20, 10, 15, 60}
Output : 2 3 5
// LCM of n elements is 60 and 60 = 2*2*3*5,
// so prime factors would be 2,3,5```

A simple solution for this problem is to find LCM of n elements in array. First initialize lcm = 1, then iterate for each element in array and find the lcm of previous result with new element using formula LCM(a, b) = (a * b) / gcd(a, b) i.e., lcm = (lcm * arr[i]) / gcd(lcm, arr[i]). After finding LCM of all n elements we can calculate all prime factors of LCM.
Since here constraints are large, we can not implement above method to solve this problem because while calculating LCM(a, b) we need to calculate a*b and if a,b both are of value 10^12 so it will exceed the limit of integer size. We proceed for this problem in another way using sieve of sundaram and prime factorization of a number. As we know if LCM(a,b) = k so any prime factor of a or b will also be the prime factor of ‘k’.

• Take an array factor[] of size 10^6 and initialize it with 0 because prime factor of any number are always less than and equal to its square root and in our constraint arr[i] <= 10^12.
• Generate all primes less than and equal to 10^6 and store them in another array.
• Now one by one calculate all prime factors of each number in array and mark them as 1 in factor[] array.
• Now traverse factor[] array and print all indexes which are marked as 1 because these will be prime factors of lcm of n numbers in given array.

Below is the implementation of above idea.

## C++

 `// C++ program to find prime factors of LCM of array elements``#include ``using` `namespace` `std;` `const` `int` `MAX  = 1000000;``typedef` `long` `long` `int` `ll;` `// array to store all prime less than and equal to 10^6``vector <``int``> primes;` `// utility function for sieve of sundaram``void` `sieve()``{``    ``int` `n = MAX;` `    ``// In general Sieve of Sundaram, produces primes smaller``    ``// than (2*x + 2) for a number given number x. Since``    ``// we want primes smaller than n, we reduce n to half``    ``int` `nNew = (n)/2;` `    ``// This array is used to separate numbers of the form``    ``// i+j+2ij from others where 1 <= i <= j``    ``bool` `marked[nNew + 100];` `    ``// Initalize all elements as not marked``    ``memset``(marked, ``false``, ``sizeof``(marked));` `    ``// Main logic of Sundaram. Mark all numbers which do not``    ``// generate prime number by doing 2*i+1``    ``int` `tmp=``sqrt``(n);``    ``for` `(``int` `i=1; i<=(tmp-1)/2; i++)``        ``for` `(``int` `j=(i*(i+1))<<1; j<=nNew; j=j+2*i+1)``            ``marked[j] = ``true``;` `    ``// Since 2 is a prime number``    ``primes.push_back(2);` `    ``// Print other primes. Remaining primes are of the form``    ``// 2*i + 1 such that marked[i] is false.``    ``for` `(``int` `i=1; i<=nNew; i++)``        ``if` `(marked[i] == ``false``)``            ``primes.push_back(2*i + 1);``}` `// Function to find prime factors of n elements of``// given array``void` `primeLcm(ll arr[], ``int` `n )``{``    ``// factors[] --> array to mark all prime factors of``    ``// lcm of array elements``    ``int` `factors[MAX] = {0};` `    ``// One by one calculate prime factors of number``    ``// and mark them in factors[] array``    ``for` `(``int` `i=0; i duplicate of original element to``        ``//          perform operation``        ``ll copy = arr[i];` `        ``// sqr --> square root of current number 'copy'``        ``// because all prime factors are always less``        ``// than and equal to square root of given number``        ``int` `sqr = ``sqrt``(copy);` `        ``// check divisibility with prime factor``        ``for` `(``int` `j=0; primes[j]<=sqr; j++)``        ``{``            ``// if current prime number is factor of 'copy'``            ``if` `(copy%primes[j] == 0)``            ``{``                ``// divide with current prime factor until``                ``// it can divide the number``                ``while` `(copy%primes[j] == 0)``                    ``copy = copy/primes[j];` `                ``// mark current prime factor as 1 in``                ``// factors[] array``                ``factors[primes[j]] = 1;``            ``}``        ``}` `        ``// After calculating exponents of all prime factors``        ``// either value of 'copy' will be 1 because of``        ``// complete divisibility or remaining value of``        ``// 'copy' will be surely a prime , so we will``        ``// also mark this prime as a factor``        ``if` `(copy > 1)``            ``factors[copy] = 1;``    ``}` `    ``// if 2 is prime factor of lcm of all elements``    ``// in given array``    ``if` `(factors == 1)``        ``cout << 2 << ``" "``;` `    ``// traverse to print all prime factors of lcm of``    ``// all elements in given array``    ``for` `(``int` `i=3; i<=MAX; i=i+2)``        ``if` `(factors[i] == 1)``            ``cout << i << ``" "``;``}` `// Driver program to run the case``int` `main()``{``    ``sieve();``    ``ll arr[] = {20, 10, 15, 60};``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);``    ``primeLcm(arr, n);``    ``return` `0;``}`

## Java

 `// Java program to find prime``// factors of LCM of array elements``import` `java.util.*;` `class` `GFG``{` `static` `int` `MAX = ``1000000``;` `// array to store all prime less``// than and equal to 10^6``static` `ArrayList primes = ``new` `ArrayList();` `// utility function for sieve of sundaram``static` `void` `sieve()``{``    ``int` `n = MAX;` `    ``// In general Sieve of Sundaram,``    ``// produces primes smaller than``    ``// (2*x + 2) for a number given``    ``// number x. Since we want primes``    ``// smaller than n, we reduce n to half``    ``int` `nNew = (n) / ``2``;` `    ``// This array is used to separate``    ``// numbers of the form i+j+2ij``    ``// from others where 1 <= i <= j``    ``boolean``[] marked = ``new` `boolean``[nNew + ``100``];`  `    ``// Main logic of Sundaram. Mark all``    ``// numbers which do not generate``    ``// prime number by doing 2*i+1``    ``int` `tmp = (``int``)Math.sqrt(n);``    ``for` `(``int` `i = ``1``; i <= (tmp - ``1``) / ``2``; i++)``        ``for` `(``int` `j = (i * (i + ``1``)) << ``1``;``                ``j <= nNew; j = j + ``2` `* i + ``1``)``            ``marked[j] = ``true``;` `    ``// Since 2 is a prime number``    ``primes.add(``2``);` `    ``// Print other primes. Remaining``    ``// primes are of the form 2*i + 1``    ``// such that marked[i] is false.``    ``for` `(``int` `i = ``1``; i <= nNew; i++)``        ``if` `(marked[i] == ``false``)``            ``primes.add(``2` `* i + ``1``);``}` `// Function to find prime factors``// of n elements of given array``static` `void` `primeLcm(``int``[] arr, ``int` `n )``{``    ``// factors[] --> array to mark all prime``    ``// factors of lcm of array elements``    ``int``[] factors = ``new` `int``[MAX];` `    ``// One by one calculate prime factors of number``    ``// and mark them in factors[] array``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``// copy --> duplicate of original element to``        ``//  perform operation``        ``int` `copy = arr[i];` `        ``// sqr --> square root of current number 'copy'``        ``// because all prime factors are always less``        ``// than and equal to square root of given number``        ``int` `sqr = (``int``)Math.sqrt(copy);` `        ``// check divisibility with prime factor``        ``for` `(``int` `j = ``0``; primes.get(j) <= sqr; j++)``        ``{``            ``// if current prime number is factor of 'copy'``            ``if` `(copy % primes.get(j) == ``0``)``            ``{``                ``// divide with current prime factor until``                ``// it can divide the number``                ``while` `(copy % primes.get(j) == ``0``)``                    ``copy = copy / primes.get(j);` `                ``// mark current prime factor as 1 in``                ``// factors[] array``                ``factors[primes.get(j)] = ``1``;``            ``}``        ``}` `        ``// After calculating exponents of all prime factors``        ``// either value of 'copy' will be 1 because of``        ``// complete divisibility or remaining value of``        ``// 'copy' will be surely a prime , so we will``        ``// also mark this prime as a factor``        ``if` `(copy > ``1``)``            ``factors[copy] = ``1``;``    ``}` `    ``// if 2 is prime factor of lcm of all elements``    ``// in given array``    ``if` `(factors[``2``] == ``1``)``        ``System.out.print(``"2 "``);` `    ``// traverse to print all prime factors of lcm of``    ``// all elements in given array``    ``for` `(``int` `i = ``3``; i <= MAX; i = i + ``2``)``        ``if` `(factors[i] == ``1``)``            ``System.out.print(i+``" "``);``}` `// Driver code``public` `static` `void` `main (String[] args)``{``    ``sieve();``    ``int``[] arr = {``20``, ``10``, ``15``, ``60``};``    ``int` `n = arr.length;``    ``primeLcm(arr, n);``}``}` `// This code is contributed by chandan_jnu`

## Python3

 `# Python3 program to find prime factors``# of LCM of array elements``import` `math;``MAX` `=` `10000``;` `# array to store all prime less than``# and equal to 10^6``primes ``=` `[];` `# utility function for sieve of sundaram``def` `sieve():` `    ``n ``=` `MAX``;` `    ``# In general Sieve of Sundaram, produces``    ``# primes smaller than (2*x + 2) for a``    ``# number given number x. Since we want``    ``# primes smaller than n, we reduce n to half``    ``nNew ``=` `int``(n ``/` `2``);` `    ``# This array is used to separate numbers of``    ``# the form i+j+2ij from others where 1 <= i <= j``    ``marked ``=` `[``False``] ``*` `(nNew ``+` `100``);`  `    ``# Main logic of Sundaram. Mark all numbers``    ``# which do not generate prime number by``    ``# doing 2*i+1``    ``tmp ``=` `int``(math.sqrt(n));``    ``for` `i ``in` `range``(``1``, ``int``((tmp ``-` `1``) ``/` `2``) ``+` `1``):``        ``for` `j ``in` `range``((i ``*` `(i ``+` `1``)) << ``1``,``                        ``nNew ``+` `1``, ``2` `*` `i ``+` `1``):``            ``marked[j] ``=` `True``;` `    ``# Since 2 is a prime number``    ``primes.append(``2``);` `    ``# Print other primes. Remaining primes``    ``# are of the form 2*i + 1 such that``    ``# marked[i] is false.``    ``for` `i ``in` `range``(``1``, nNew ``+` `1``):``        ``if` `(marked[i] ``=``=` `False``):``            ``primes.append(``2` `*` `i ``+` `1``);` `# Function to find prime factors of``# n elements of given array``def` `primeLcm(arr, n ):` `    ``# factors[] --> array to mark all prime``    ``# factors of lcm of array elements``    ``factors ``=` `[``0``] ``*` `(``MAX``);` `    ``# One by one calculate prime factors of``    ``# number and mark them in factors[] array``    ``for` `i ``in` `range``(n):``        ` `        ``# copy --> duplicate of original``        ``# element to perform operation``        ``copy ``=` `arr[i];` `        ``# sqr --> square root of current number``        ``# 'copy' because all prime factors are``        ``# always less than and equal to square``        ``# root of given number``        ``sqr ``=` `int``(math.sqrt(copy));` `        ``# check divisibility with prime factor``        ``j ``=` `0``;``        ``while` `(primes[j] <``=` `sqr):``        ` `            ``# if current prime number is``            ``# factor of 'copy'``            ``if` `(copy ``%` `primes[j] ``=``=` `0``):``                ` `                ``# divide with current prime factor``                ``# until it can divide the number``                ``while` `(copy ``%` `primes[j] ``=``=` `0``):``                    ``copy ``=` `int``(copy ``/` `primes[j]);` `                ``# mark current prime factor as 1``                ``# in factors[] array``                ``factors[primes[j]] ``=` `1``;``            ``j ``+``=` `1``;` `        ``# After calculating exponents of all prime``        ``# factors either value of 'copy' will be 1``        ``# because of complete divisibility or``        ``# remaining value of 'copy' will be surely``        ``# a prime, so we will also mark this prime``        ``# as a factor``        ``if` `(copy > ``1``):``            ``factors[copy] ``=` `1``;` `    ``# if 2 is prime factor of lcm of``    ``# all elements in given array``    ``if` `(factors[``2``] ``=``=` `1``):``        ``print``(``"2 "``, end ``=` `"");` `    ``# traverse to print all prime factors of``    ``# lcm of all elements in given array``    ``for` `i ``in` `range``(``3``, ``MAX` `+` `1``, ``2``):``        ``if` `(factors[i] ``=``=` `1``):``            ``print``(i, end ``=` `" "``);` `# Driver Code``sieve();``arr ``=` `[``20``, ``10``, ``15``, ``60``];``n ``=` `len``(arr);``primeLcm(arr, n);` `# This code is contributed by chandan_jnu`

## C#

 `// C# program to find prime``// factors of LCM of array elements``using` `System;``using` `System.Collections;` `class` `GFG``{` `static` `int` `MAX = 1000000;` `// array to store all prime less``// than and equal to 10^6``static` `ArrayList primes = ``new` `ArrayList();` `// utility function for sieve of sundaram``static` `void` `sieve()``{``    ``int` `n = MAX;` `    ``// In general Sieve of Sundaram,``    ``// produces primes smaller than``    ``// (2*x + 2) for a number given``    ``// number x. Since we want primes``    ``// smaller than n, we reduce n to half``    ``int` `nNew = (n) / 2;` `    ``// This array is used to separate``    ``// numbers of the form i+j+2ij``    ``// from others where 1 <= i <= j``    ``bool``[] marked = ``new` `bool``[nNew + 100];`  `    ``// Main logic of Sundaram. Mark all``    ``// numbers which do not generate``    ``// prime number by doing 2*i+1``    ``int` `tmp = (``int``)Math.Sqrt(n);``    ``for` `(``int` `i = 1; i <= (tmp - 1) / 2; i++)``        ``for` `(``int` `j = (i * (i + 1)) << 1;``                ``j <= nNew; j = j + 2 * i + 1)``            ``marked[j] = ``true``;` `    ``// Since 2 is a prime number``    ``primes.Add(2);` `    ``// Print other primes. Remaining``    ``// primes are of the form 2*i + 1``    ``// such that marked[i] is false.``    ``for` `(``int` `i = 1; i <= nNew; i++)``        ``if` `(marked[i] == ``false``)``            ``primes.Add(2 * i + 1);``}` `// Function to find prime factors``// of n elements of given array``static` `void` `primeLcm(``int``[] arr, ``int` `n )``{``    ``// factors[] --> array to``    ``// mark all prime factors``    ``// of lcm of array elements``    ``int``[] factors = ``new` `int``[MAX];` `    ``// One by one calculate prime``    ``// factors of number and mark``    ``// them in factors[] array``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``// copy --> duplicate of original``        ``// element to perform operation``        ``int` `copy = arr[i];` `        ``// sqr --> square root of current``        ``// number 'copy' because all prime``        ``// factors are always less than and``        ``// equal to square root of given number``        ``int` `sqr = (``int``)Math.Sqrt(copy);` `        ``// check divisibility with prime factor``        ``for` `(``int` `j = 0; (``int``)primes[j] <= sqr; j++)``        ``{``            ``// if current prime number is factor of 'copy'``            ``if` `(copy % (``int``)primes[j] == 0)``            ``{``                ``// divide with current prime factor until``                ``// it can divide the number``                ``while` `(copy % (``int``)primes[j] == 0)``                    ``copy = copy / (``int``)primes[j];` `                ``// mark current prime factor as 1 in``                ``// factors[] array``                ``factors[(``int``)primes[j]] = 1;``            ``}``        ``}` `        ``// After calculating exponents of all prime factors``        ``// either value of 'copy' will be 1 because of``        ``// complete divisibility or remaining value of``        ``// 'copy' will be surely a prime , so we will``        ``// also mark this prime as a factor``        ``if` `(copy > 1)``            ``factors[copy] = 1;``    ``}` `    ``// if 2 is prime factor of lcm of all elements``    ``// in given array``    ``if` `(factors == 1)``        ``Console.Write(``"2 "``);` `    ``// traverse to print all prime factors of lcm of``    ``// all elements in given array``    ``for` `(``int` `i = 3; i <= MAX; i = i + 2)``        ``if` `(factors[i] == 1)``            ``Console.Write(i+``" "``);``}` `// Driver code``static` `void` `Main()``{``    ``sieve();``    ``int``[] arr = {20, 10, 15, 60};``    ``int` `n = arr.Length;``    ``primeLcm(arr, n);``}``}` `// This code is contributed by chandan_jnu`

## PHP

 ` array to mark all prime``    ``// factors of lcm of array elements``    ``\$factors` `= ``array_fill``(0, ``\$MAX``, 0);` `    ``// One by one calculate prime factors of``    ``// number and mark them in factors[] array``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)``    ``{``        ``// copy --> duplicate of original``        ``// element to perform operation``        ``\$copy` `= ``\$arr``[``\$i``];` `        ``// sqr --> square root of current number``        ``// 'copy' because all prime factors are``        ``// always less than and equal to square``        ``// root of given number``        ``\$sqr` `= (int)sqrt(``\$copy``);` `        ``// check divisibility with prime factor``        ``for` `(``\$j` `= 0; ``\$primes``[``\$j``] <= ``\$sqr``; ``\$j``++)``        ``{``            ``// if current prime number is factor``            ``// of 'copy'``            ``if` `(``\$copy` `% ``\$primes``[``\$j``] == 0)``            ``{``                ``// divide with current prime factor``                ``// until it can divide the number``                ``while` `(``\$copy` `% ``\$primes``[``\$j``] == 0)``                    ``\$copy` `= (int)(``\$copy` `/ ``\$primes``[``\$j``]);` `                ``// mark current prime factor as 1``                ``// in factors[] array``                ``\$factors``[``\$primes``[``\$j``]] = 1;``            ``}``        ``}` `        ``// After calculating exponents of all prime``        ``// factors either value of 'copy' will be 1``        ``// because of complete divisibility or remaining``        ``// value of 'copy' will be surely a prime , so``        ``// we will also mark this prime as a factor``        ``if` `(``\$copy` `> 1)``            ``\$factors``[``\$copy``] = 1;``    ``}` `    ``// if 2 is prime factor of lcm of all``    ``// elements in given array``    ``if` `(``\$factors`` == 1)``        ``echo` `"2 "``;` `    ``// traverse to print all prime factors of``    ``// lcm of all elements in given array``    ``for` `(``\$i` `= 3; ``\$i` `<= ``\$MAX``; ``\$i` `= ``\$i` `+ 2)``        ``if` `(``\$factors``[``\$i``] == 1)``            ``echo` `\$i` `. ``" "``;``}` `// Driver Code``sieve();``\$arr` `= ``array``(20, 10, 15, 60);``\$n` `= ``count``(``\$arr``);``primeLcm(``\$arr``, ``\$n``);` `// This code is contributed by chandan_jnu``?>`

## Javascript

 ``

Output:

`2 3 5`

This article is contributed by Shashank Mishra ( Gullu ). 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.
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