# Sum of element whose prime factors are present in array

Given an array arr[] of non-negative integers where 2 ≤ arr[i] ≤ 106. The task is to find the sum of all those elements from the array whose prime factors are present in the same array.

Examples:

Input: arr[] = {2, 3, 10}
Output: 5
Factor of 2 is 2 which is present in the array
Factor of 3 is 3, also present in the array
Factors of 10 are 2 and 5, out of which only 2 is present in the array.
So, sum = 2 + 3 = 5

Input: arr[] = {5, 11, 55, 25, 100}
Output: 96

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

Approach: The idea is to first calculate the least prime factor till maximum element of the array with Prime Factorization using Sieve.

1. Now, Iterate the array and for an element arr[i]
2. If arr[i] != 1:
• If leastPrimeFactor(arr[i]) is present in the array then update arr[i] / leastPrimeFactor(arr[i]) and go to step 2.
• Else go to step 1.
3. Else update sum = sum + originalVal(arr[i]).
4. Print the sum in the end.

Below is the implementation of the above approach:

## C++

 `// C++ program to find the sum of the elements of an array ` `// whose prime factors are present in the same array ` `#include ` `using` `namespace` `std; ` ` `  `#define MAXN 1000001 ` ` `  `// Stores smallest prime factor for every number ` `int` `spf[MAXN]; ` ` `  `// Function to calculate SPF (Smallest Prime Factor) ` `// for every number till MAXN ` `void` `sieve() ` `{ ` `    ``spf = 1; ` `    ``for` `(``int` `i = 2; i < MAXN; i++) ` ` `  `        ``// Marking smallest prime factor for every ` `        ``// number to be itself. ` `        ``spf[i] = i; ` ` `  `    ``// Separately marking spf for every even ` `    ``// number as 2 ` `    ``for` `(``int` `i = 4; i < MAXN; i += 2) ` `        ``spf[i] = 2; ` ` `  `    ``for` `(``int` `i = 3; i * i < MAXN; i++) { ` ` `  `        ``// If i is prime ` `        ``if` `(spf[i] == i) { ` ` `  `            ``// Marking SPF for all numbers divisible by i ` `            ``for` `(``int` `j = i * i; j < MAXN; j += i) ` ` `  `                ``// Marking spf[j] if it is not ` `                ``// previously marked ` `                ``if` `(spf[j] == j) ` `                    ``spf[j] = i; ` `        ``} ` `    ``} ` `} ` ` `  `// Function to return the sum of the elements of an array ` `// whose prime factors are present in the same array ` `int` `sumFactors(``int` `arr[], ``int` `n) ` `{ ` ` `  `    ``// Function call to calculate smallest prime factors of ` `    ``// all the numbers upto MAXN ` `    ``sieve(); ` ` `  `    ``// Create map for each element ` `    ``std::map<``int``, ``int``> map; ` ` `  `    ``for` `(``int` `i = 0; i < n; ++i) ` `        ``map[arr[i]] = 1; ` ` `  `    ``int` `sum = 0; ` ` `  `    ``for` `(``int` `i = 0; i < n; ++i) { ` `        ``int` `num = arr[i]; ` ` `  `        ``// If smallest prime factor of num is present in array ` `        ``while` `(num != 1 && map[spf[num]] == 1) { ` `            ``num /= spf[num]; ` `        ``} ` ` `  `        ``// Each factor of arr[i] is present in the array ` `        ``if` `(num == 1) ` `            ``sum += arr[i]; ` `    ``} ` ` `  `    ``return` `sum; ` `} ` ` `  `// Driver program ` `int` `main() ` `{ ` `    ``int` `arr[] = { 5, 11, 55, 25, 100 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` ` `  `    ``// Function call to print required answer ` `    ``cout << sumFactors(arr, n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to find the sum of the elements of an array  ` `// whose prime factors are present in the same array  ` ` `  `import` `java.util.*;   ` ` `  `public` `class` `GFG{ ` ` `  `final` `static` `int` `MAXN = ``1000001` `; ` ` `  `// Stores smallest prime factor for every number  ` `static` `int` `spf[] = ``new` `int` `[MAXN];  ` ` `  `    ``// Function to calculate SPF (Smallest Prime Factor)  ` `    ``// for every number till MAXN  ` `    ``static` `void` `sieve()  ` `    ``{  ` `        ``spf[``1``] = ``1``;  ` `        ``for` `(``int` `i = ``2``; i < MAXN; i++)  ` `     `  `            ``// Marking smallest prime factor for every  ` `            ``// number to be itself.  ` `            ``spf[i] = i;  ` `     `  `        ``// Separately marking spf for every even  ` `        ``// number as 2  ` `        ``for` `(``int` `i = ``4``; i < MAXN; i += ``2``)  ` `            ``spf[i] = ``2``;  ` `     `  `        ``for` `(``int` `i = ``3``; i * i < MAXN; i++) {  ` `     `  `            ``// If i is prime  ` `            ``if` `(spf[i] == i) {  ` `     `  `                ``// Marking SPF for all numbers divisible by i  ` `                ``for` `(``int` `j = i * i; j < MAXN; j += i)  ` `     `  `                    ``// Marking spf[j] if it is not  ` `                    ``// previously marked  ` `                    ``if` `(spf[j] == j)  ` `                        ``spf[j] = i;  ` `            ``}  ` `        ``}  ` `    ``}  ` `     `  `    ``// Function to return the sum of the elements of an array  ` `    ``// whose prime factors are present in the same array  ` `    ``static` `int` `sumFactors(``int` `arr[], ``int` `n)  ` `    ``{  ` `     `  `        ``// Function call to calculate smallest prime factors of  ` `        ``// all the numbers upto MAXN  ` `        ``sieve();  ` `     `  `        ``// Create map for each element  ` `        ``Map map=``new` `HashMap(); ` `         `  `        ``for``(``int` `i = ``0` `; i < MAXN ; ++i) ` `            ``map.put(i,``0``) ; ` `             `  `        ``for` `(``int` `i = ``0``; i < n; ++i)  ` `            ``map.put(arr[i],``1``);  ` `         `  `     `  `        ``int` `sum = ``0``;  ` `     `  `        ``for` `(``int` `i = ``0``; i < n; ++i) {  ` `            ``int` `num = arr[i];  ` `     `  `            ``// If smallest prime factor of num is present in array  ` `            ``while` `(num != ``1` `&& (``int``)(map.get(spf[num])) == ``1``) {  ` `                ``num /= spf[num];  ` `            ``}  ` `     `  `            ``// Each factor of arr[i] is present in the array  ` `            ``if` `(num == ``1``)  ` `                ``sum += arr[i];  ` `        ``}  ` `     `  `        ``return` `sum;  ` `    ``}  ` `     `  `    ``// Driver program  ` `     ``public` `static` `void` `main(String []args) ` `    ``{  ` `        ``int` `arr[] = { ``5``, ``11``, ``55``, ``25``, ``100` `};  ` `        ``int` `n = arr.length ; ` `     `  `        ``// Function call to print required answer  ` `         ``System.out.println(sumFactors(arr, n)) ; ` `    ``}  ` `    ``// This code is contributed by Ryuga ` `} `

## Python3

 `# Python program to find the sum of the  ` `# elements of an array whose prime factors ` `# are present in the same array  ` `from` `collections ``import` `defaultdict ` ` `  `MAXN ``=` `1000001` `MAXN_sqrt ``=` `int``(MAXN ``*``*` `(``0.5``)) ` ` `  `# Stores smallest prime factor ` `# for every number  ` `spf ``=` `[``None``] ``*` `(MAXN)  ` ` `  `# Function to calculate SPF (Smallest  ` `# Prime Factor) for every number till MAXN  ` `def` `sieve(): ` ` `  `    ``spf[``1``] ``=` `1` `    ``for` `i ``in` `range``(``2``, MAXN):  ` ` `  `        ``# Marking smallest prime factor  ` `        ``# for every number to be itself.  ` `        ``spf[i] ``=` `i  ` ` `  `    ``# Separately marking spf for every  ` `    ``# even number as 2  ` `    ``for` `i ``in` `range``(``4``, MAXN, ``2``):  ` `        ``spf[i] ``=` `2` ` `  `    ``for` `i ``in` `range``(``3``, MAXN_sqrt):  ` ` `  `        ``# If i is prime  ` `        ``if` `spf[i] ``=``=` `i: ` ` `  `            ``# Marking SPF for all numbers  ` `            ``# divisible by i  ` `            ``for` `j ``in` `range``(i ``*` `i, MAXN, i):  ` ` `  `                ``# Marking spf[j] if it is   ` `                ``# not previously marked  ` `                ``if` `spf[j] ``=``=` `j: ` `                    ``spf[j] ``=` `i  ` `         `  `# Function to return the sum of the elements  ` `# of an array whose prime factors are present  ` `# in the same array  ` `def` `sumFactors(arr, n):  ` ` `  `    ``# Function call to calculate smallest  ` `    ``# prime factors of all the numbers upto MAXN  ` `    ``sieve()  ` ` `  `    ``# Create map for each element  ` `    ``Map` `=` `defaultdict(``lambda``:``0``)  ` ` `  `    ``for` `i ``in` `range``(``0``, n):  ` `        ``Map``[arr[i]] ``=` `1` ` `  `    ``Sum` `=` `0` ` `  `    ``for` `i ``in` `range``(``0``, n):  ` `        ``num ``=` `arr[i]  ` `         `  `        ``# If smallest prime factor of num ` `        ``# is present in array  ` `        ``while` `num !``=` `1` `and` `Map``[spf[num]] ``=``=` `1``:  ` `            ``num ``=` `num ``/``/` `spf[num]  ` `         `  `        ``# Each factor of arr[i] is present  ` `        ``# in the array  ` `        ``if` `num ``=``=` `1``:  ` `            ``Sum` `+``=` `arr[i]  ` `     `  `    ``return` `Sum` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` ` `  `    ``arr ``=` `[``5``, ``11``, ``55``, ``25``, ``100``]  ` `    ``n ``=` `len``(arr)  ` ` `  `    ``# Function call to print  ` `    ``# required answer  ` `    ``print``(sumFactors(arr, n))  ` ` `  `# This code is contributed by Rituraj Jain `

## C#

 `// C# program to find the sum of the elements  ` `// of an array whose prime factors are present ` `// in the same array  ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG ` `{ ` `    ``static` `int` `MAXN = 1000001; ` `     `  `    ``// Stores smallest prime factor for every number  ` `    ``static` `int` `[]spf = ``new` `int` `[MAXN];  ` ` `  `    ``// Function to calculate SPF (Smallest Prime Factor)  ` `    ``// for every number till MAXN  ` `    ``static` `void` `sieve()  ` `    ``{  ` `        ``spf = 1;  ` `        ``for` `(``int` `i = 2; i < MAXN; i++)  ` `     `  `            ``// Marking smallest prime factor for  ` `            ``// every number to be itself.  ` `            ``spf[i] = i;  ` `     `  `        ``// Separately marking spf for every even  ` `        ``// number as 2  ` `        ``for` `(``int` `i = 4; i < MAXN; i += 2)  ` `            ``spf[i] = 2;  ` `     `  `        ``for` `(``int` `i = 3; i * i < MAXN; i++)  ` `        ``{  ` `     `  `            ``// If i is prime  ` `            ``if` `(spf[i] == i) ` `            ``{  ` `     `  `                ``// Marking SPF for all numbers divisible by i  ` `                ``for` `(``int` `j = i * i; j < MAXN; j += i)  ` `     `  `                    ``// Marking spf[j] if it is not  ` `                    ``// previously marked  ` `                    ``if` `(spf[j] == j)  ` `                        ``spf[j] = i;  ` `            ``}  ` `        ``}  ` `    ``}  ` `     `  `    ``// Function to return the sum of the elements  ` `    ``// of an array whose prime factors are present  ` `    ``// in the same array  ` `    ``static` `int` `sumFactors(``int` `[]arr, ``int` `n)  ` `    ``{  ` `     `  `        ``// Function call to calculate smallest  ` `        ``// prime factors of all the numbers upto MAXN  ` `        ``sieve();  ` `     `  `        ``// Create map for each element  ` `        ``Dictionary<``int``, ``int``> map = ``new` `Dictionary<``int``, ``int``>(); ` `         `  `        ``for``(``int` `i = 0 ; i < MAXN ; ++i) ` `            ``map.Add(i, 0); ` `             `  `        ``for` `(``int` `i = 0; i < n; ++i) ` `        ``{ ` `            ``if``(map.ContainsKey(arr[i])) ` `            ``{ ` `                ``map[arr[i]] = 1;  ` `            ``} ` `            ``else` `            ``{ ` `                ``map.Add(arr[i], 1); ` `            ``} ` `        ``} ` `         `  `        ``int` `sum = 0;  ` `     `  `        ``for` `(``int` `i = 0; i < n; ++i)  ` `        ``{  ` `            ``int` `num = arr[i];  ` `     `  `            ``// If smallest prime factor of num  ` `            ``// is present in array  ` `            ``while` `(num != 1 &&  ` `             ``(``int``)(map[spf[num]]) == 1)  ` `            ``{  ` `                ``num /= spf[num];  ` `            ``}  ` `     `  `            ``// Each factor of arr[i] is present ` `            ``// in the array  ` `            ``if` `(num == 1)  ` `                ``sum += arr[i];  ` `        ``}  ` `        ``return` `sum;  ` `    ``}  ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `Main(String []args) ` `    ``{  ` `        ``int` `[]arr = { 5, 11, 55, 25, 100 };  ` `        ``int` `n = arr.Length; ` `     `  `        ``// Function call to print required answer  ` `        ``Console.WriteLine(sumFactors(arr, n)); ` `    ``}  ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:

```96
```

My Personal Notes arrow_drop_up 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 :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.