Open In App

# 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

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] = 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[0]);` `    ``// 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] = 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`

## Javascript

 `// JavaScript program to find the sum of the``// elements of an array whose prime factors``// are present in the same array``let MAXN = 1000001``let MAXN_sqrt = Math.floor(MAXN ** (0.5))` `// Stores smallest prime factor``// for every number``let spf = ``new` `Array(MAXN)` `// Function to calculate SPF (Smallest``// Prime Factor) for every number till MAXN``function` `sieve()``{``    ``spf[1] = 1``    ``for` `(``var` `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` `(``var` `i = 4; i <  MAXN; i += 2)``        ``spf[i] = 2` `    ``for` `(``var` `i = 3; i < MAXN_sqrt; i++)``    ``{``        ``// If i is prime``        ``if` `(spf[i] == i)``        ``{``            ``// Marking SPF for all numbers``            ``// divisible by i``            ``for` `(``var` `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``function` `sumFactors(arr, n)``{``    ``// Function call to calculate smallest``    ``// prime factors of all the numbers upto MAXN``    ``sieve()` `    ``// Create map for each element``    ``let Map = {}` `    ``for` `(``var` `i = 0; i < n; i++)``        ``Map[arr[i]] = 1` `    ``let Sum = 0` `    ``for` `(``var` `i = 0; i < n; i++)``    ``{``        ``let num = arr[i]``        ` `        ``// If smallest prime factor of num``        ``// is present in array``        ``while` `(num != 1 && Map.hasOwnProperty(spf[num]))``            ``num = Math.floor(num / spf[num])``        ` `        ``// Each factor of arr[i] is present``        ``// in the array``        ``if` `(num == 1)``            ``Sum += arr[i]``    ``}``    ` `    ``return` `Sum``}`  `// Driver Code``let arr = [5, 11, 55, 25, 100]``let n = arr.length` `// Function call to print``// required answer``console.log(sumFactors(arr, n))` `// This code is contributed by phasing17`

Output:

`96`

Time Complexity: O(MAXN*log(log(MAXN)))

Auxiliary Space: O(MAXN)