# Distinct Prime Factors of an Array

Given an array arr[] of size N, the task is to find the distinct prime factors of all the numbers in the given array.

Examples:

Input: N = 3, arr[] = {12, 15, 18}
Output: 2 3 5
Exlpanation:
12 = 2 x 2 x 3
15 = 3 x 5
18 = 2 x 3 x 3
Distinct prime factors among the given numbers are 2, 3, 5.

Input: N = 9, arr[] = {2, 3, 4, 5, 6, 7, 8, 9, 10}
Output: 2 3 5 7

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach: A simple approach of this problem will be finding the prime factors of each number in the array. Then find the distinct prime numbers among these prime factors.
Time Complexity: O(N2)

Efficient Approach: An efficient approach is to first find all prime numbers up to the given limit using Sieve of Eratosthenes and store them in an array. For every prime number in the prime array, check if any number in the input array is divisible or not. If it is divisible, then store that prime number in the answer array. Finally, return the answer array after repeating this process for all the numbers in the given input array.

Below is the implementation of the above approach:

 `#include ` ` `  `using` `namespace` `std; ` ` `  `//cppimplementation of the above approach ` ` `  `//Function to return an array ` `//of prime numbers upto n ` `//using Sieve of Eratosthenes ` `vector<``int``> seive(``int` `n){ ` `    ``vector<``int``> prime (n + 1,0); ` `    ``int` `p = 2; ` `    ``while``(p * p<= n){ ` `        ``if``(prime[p]== 0){ ` `            ``for` `(``int` `i=2*p;i allPrimes; ` `    ``for` `(``int` `i =2;i distPrime(vector<``int``> arr, vector<``int``> allPrimes){ ` ` `  `    ``//Creating an empty array ` `    ``//to store distinct prime factors ` `    ``vector<``int``> list1; ` ` `  `    ``//Iterating through all the ` `    ``//prime numbers and check if ` `    ``//any of the prime numbers is a ` `    ``//factor of the given input array ` `    ``for` `(``int` `i : allPrimes){ ` `        ``for` `(``int` `j :arr){ ` `            ``if``(j % i == 0){ ` `                ``list1.push_back(i); ` `                ``break``; ` `              ``} ` `            ``} ` `          ``} ` `    ``return` `list1; ` `  ``} ` ` `  `//Driver code ` ` `  `int` `main() ` `{ ` `  ``//Finding prime numbers upto 10000 ` `  ``//using Sieve of Eratosthenes ` `  ``vector<``int``> allPrimes = seive(10000); ` ` `  `  ``vector<``int``> arr = {15, 30, 60}; ` `  ``vector<``int``> ans = distPrime(arr, allPrimes); ` `  ``cout<<``"["``; ` `  ``for``(``int` `i:ans) cout<

 `// Java implementation of the above approach ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` ` `  `// Function to return an array ` `// of prime numbers upto n ` `// using Sieve of Eratosthenes ` `static` `ArrayList seive(``int` `n){ ` `    ``ArrayList prime = ``new` `ArrayList(); ` `    ``for``(``int` `i = ``0``; i < n + ``1``; i++) ` `    ``prime.add(``0``); ` `    ``int` `p = ``2``; ` `    ``while``(p * p <= n){ ` `        ``if``(prime.get(p) == ``0``){ ` `            ``for` `(``int` `i = ``2` `* p; i < n + ``1``; i += p) ` `                ``prime.set(i, ``1``); ` `            ``} ` `        ``p += ``1``; ` `    ``} ` ` `  `    ``ArrayList allPrimes = ``new` `ArrayList(); ` `    ``for` `(``int` `i = ``2``; i < n; i++){ ` `    ``if` `(prime.get(i) == ``0``) ` `        ``allPrimes.add(i); ` `    ``} ` `    ``return` `allPrimes; ` `} ` ` `  `// Function to return distinct ` `// prime factors from the given array ` `static` `ArrayList distPrime(ArrayList arr,  ` `                            ``ArrayList allPrimes){ ` ` `  `    ``// Creating an empty array ` `    ``// to store distinct prime factors ` `    ``ArrayList list1 = ``new` `ArrayList(); ` ` `  `    ``// Iterating through all the ` `    ``// prime numbers and check if ` `    ``// any of the prime numbers is a ` `    ``// factor of the given input array ` `    ``for` `(``int` `i = ``0``; i < allPrimes.size(); i++){ ` `        ``for` `(``int` `j = ``0``; j < arr.size(); j++){ ` `            ``if``(arr.get(j) % allPrimes.get(i) == ``0``){ ` `                ``list1.add(allPrimes.get(i)); ` `                ``break``; ` `            ``} ` `            ``} ` `        ``} ` `    ``return` `list1; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `     `  `    ``// Finding prime numbers upto 10000 ` `    ``// using Sieve of Eratosthenes ` `    ``ArrayList allPrimes = ``new` `ArrayList(seive(``10000``)); ` `    ``ArrayList arr = ``new` `ArrayList(); ` `    ``arr.add(``15``); ` `    ``arr.add(``30``); ` `    ``arr.add(``60``); ` `    ``ArrayList ans = ``new` `ArrayList(distPrime(arr, allPrimes)); ` `    ``System.out.print(``"["``); ` `    ``for``(``int` `i = ``0``; i < ans.size(); i++) ` `    ``System.out.print(ans.get(i) + ``" "``); ` `    ``System.out.print(``"]"``); ` `} ` `} ` ` `  `// This code is contributed by Surendra_Gangwar `

 `# Python3 implementation of the above approach ` ` `  `# Function to return an array  ` `# of prime numbers upto n  ` `# using Sieve of Eratosthenes ` `def` `seive(n): ` `    ``prime ``=``[``True``]``*``(n ``+` `1``) ` `    ``p ``=` `2` `    ``while``(p ``*` `p<``=` `n): ` `        ``if``(prime[p] ``=``=` `True``): ` `            ``for` `i ``in` `range``(p ``*` `p, n ``+` `1``, p): ` `                ``prime[i] ``=` `False` `        ``p ``+``=` `1` `    ``allPrimes ``=` `[x ``for` `x ``in` `range``(``2``, n)``if` `prime[x]] ` `    ``return` `allPrimes ` ` `  `# Function to return distinct  ` `# prime factors from the given array  ` `def` `distPrime(arr, allPrimes): ` ` `  `    ``# Creating an empty array ` `    ``# to store distinct prime factors ` `    ``list1 ``=` `list``() ` `     `  `    ``# Iterating through all the  ` `    ``# prime numbers and check if  ` `    ``# any of the prime numbers is a ` `    ``# factor of the given input array ` `    ``for` `i ``in` `allPrimes: ` `        ``for` `j ``in` `arr: ` `            ``if``(j ``%` `i ``=``=` `0``): ` `                ``list1.append(i) ` `                ``break` `    ``return` `list1 ` ` `  `# Driver code ` `if` `__name__``=``=``"__main__"``: ` ` `  `    ``# Finding prime numbers upto 10000 ` `    ``# using Sieve of Eratosthenes ` `    ``allPrimes ``=` `seive(``10000``) ` ` `  `    ``arr ``=` `[``15``, ``30``, ``60``] ` `    ``ans ``=` `distPrime(arr, allPrimes) ` `    ``print``(ans) ` ` `  `# This code is contributed by mohit kumar 29 `

Output:
```[2, 3, 5]
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Check out this Author's contributed articles.

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :