Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Sum of element whose prime factors are present in array

  • Difficulty Level : Hard
  • Last Updated : 23 Sep, 2019

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 <bits/stdc++.h>
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
Output:
96


My Personal Notes
arrow_drop_up
Previous
Sum of elements from an array having even parity
Next

Python program to create a dictionary from a string
Recommended Articles
Page :
Print all numbers whose set of prime factors is a subset of the set of the prime factors of X
22, Apr 19
Count numbers in a given range whose count of prime factors is a Prime Number
28, Oct 20
Find prime factors of Array elements whose sum of exponents is divisible by K
15, Aug 20
Find number of factors of N when location of its two factors whose product is N is given
14, Aug 19
Check if a number exists having exactly N factors and K prime factors
10, May 20
Maximum number of prime factors a number can have with exactly x factors
07, May 20
Count numbers in a given range having prime and non-prime digits at prime and non-prime positions respectively
15, Jan 21
Super Ugly Number (Number whose prime factors are in given set)
05, Jan 17
Count numbers from range whose prime factors are only 2 and 3
04, Dec 18
Count of nodes in a Binary Tree whose child is its prime factors
09, Apr 20
Count of Nodes whose both immediate children are its prime factors
17, Apr 20
Find the row whose product has maximum count of prime factors
22, Apr 20
Count numbers from range whose prime factors are only 2 and 3 using Arrays | Set 2
31, May 20
Find prime factors of Z such that Z is product of all even numbers till N that are product of two distinct prime numbers
28, Jun 21
Count distinct prime factors for each element of an array
09, Feb 21
Count all prime numbers in a given range whose sum of digits is also prime
30, Jun 20
Count prime numbers in range [L, R] whose single digit sum is also prime
07, Jan 22
Count the factors of K present in the given Array
06, May 20
Maximize sum of count of distinct prime factors of K array elements
01, Feb 21
Sum of array elements which are prime factors of a given number
05, Mar 21
Count of elements in Array which are present K times & their double isn't present
31, Jan 22
First element of every K sets having consecutive elements with exactly K prime factors less than N
02, Jul 20
Numbers of pairs from an array whose average is also present in the array
07, May 21
Count array elements whose highest power of 2 less than or equal to that number is present in the given array
17, Jun 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Sanjit_Prasad
@Sanjit_Prasad
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!