# Product of elements in an array having prime frequency

• Difficulty Level : Expert
• Last Updated : 13 May, 2021

Given an array arr[] of N elements, the task is to find the product of the elements which have prime frequencies in the array. Since, the product can be large so print the product modulo 109 + 7. Note that 1 is neither prime nor composite.
Examples:

Input: arr[] = {5, 4, 6, 5, 4, 6}
Output: 120
All the elements appear 2 times which is a prime
So, 5 * 4 * 6 = 120
Input: arr[] = {1, 2, 3, 3, 2, 3, 2, 3, 3}
Output:
Only 2 and 3 appears prime number of times i.e. 3 and 5 respectively.
So, 2 * 3 = 6

Approach:

• Traverse the array and store the frequencies of all the elements in a map.
• Build Sieve of Eratosthenes which will be used to test the primality of a number in O(1) time.
• Calculate the product of elements having prime frequency using the Sieve array calculated in the previous step.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `#define MOD 1000000007` `// Function to create Sieve to check primes``void` `SieveOfEratosthenes(``bool` `prime[], ``int` `p_size)``{``    ``// False here indicates``    ``// that it is not prime``    ``prime[0] = ``false``;``    ``prime[1] = ``false``;` `    ``for` `(``int` `p = 2; p * p <= p_size; p++) {` `        ``// If prime[p] is not changed,``        ``// then it is a prime``        ``if` `(prime[p]) {` `            ``// Update all multiples of p,``            ``// set them to non-prime``            ``for` `(``int` `i = p * 2; i <= p_size; i += p)``                ``prime[i] = ``false``;``        ``}``    ``}``}` `// Function to return the product of elements``// in an array having prime frequency``int` `productPrimeFreq(``int` `arr[], ``int` `n)``{``    ``bool` `prime[n + 1];``    ``memset``(prime, ``true``, ``sizeof``(prime));` `    ``SieveOfEratosthenes(prime, n + 1);` `    ``int` `i, j;` `    ``// Map is used to store``    ``// element frequencies``    ``unordered_map<``int``, ``int``> m;``    ``for` `(i = 0; i < n; i++)``        ``m[arr[i]]++;` `    ``long` `product = 1;` `    ``// Traverse the map using iterators``    ``for` `(``auto` `it = m.begin(); it != m.end(); it++) {` `        ``// Count the number of elements``        ``// having prime frequencies``        ``if` `(prime[it->second]) {``            ``product *= (it->first % MOD);``            ``product %= MOD;``        ``}``    ``}` `    ``return` `(``int``)(product);``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 5, 4, 6, 5, 4, 6 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << productPrimeFreq(arr, n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;``    ` `class` `GFG``{``static` `int` `MOD = ``1000000007``;` `// Function to create Sieve to check primes``static` `void` `SieveOfEratosthenes(``boolean` `prime[],``                                ``int` `p_size)``{``    ``// False here indicates``    ``// that it is not prime``    ``prime[``0``] = ``false``;``    ``prime[``1``] = ``false``;` `    ``for` `(``int` `p = ``2``; p * p <= p_size; p++)``    ``{` `        ``// If prime[p] is not changed,``        ``// then it is a prime``        ``if` `(prime[p])``        ``{` `            ``// Update all multiples of p,``            ``// set them to non-prime``            ``for` `(``int` `i = p * ``2``;``                     ``i <= p_size; i += p)``                ``prime[i] = ``false``;``        ``}``    ``}``}` `// Function to return the product of elements``// in an array having prime frequency``static` `int` `productPrimeFreq(``int` `arr[], ``int` `n)``{``    ``boolean` `[]prime = ``new` `boolean``[n + ``1``];``    ``for` `(``int` `i = ``0``; i < n; i++)``        ``prime[i] = ``true``;` `    ``SieveOfEratosthenes(prime, n + ``1``);` `    ``int` `i, j;` `    ``// Map is used to store``    ``// element frequencies``    ``HashMap mp = ``new` `HashMap();` `    ``for` `(i = ``0` `; i < n; i++)``    ``{``        ``if``(mp.containsKey(arr[i]))``        ``{``            ``mp.put(arr[i], mp.get(arr[i]) + ``1``);``        ``}``        ``else``        ``{``            ``mp.put(arr[i], ``1``);``        ``}``    ``}``    ``long` `product = ``1``;` `    ``// Traverse the map using iterators``    ``for` `(Map.Entry it : mp.entrySet())``    ``{` `        ``// Count the number of elements``        ``// having prime frequencies``        ``if` `(prime[it.getValue()])``        ``{``            ``product *= (it.getKey() % MOD);``            ``product %= MOD;``        ``}``    ``}``    ``return` `(``int``)(product);``}` `// Driver code``static` `public` `void` `main (String []arg)``{``    ``int` `arr[] = { ``5``, ``4``, ``6``, ``5``, ``4``, ``6` `};``    ``int` `n = arr.length;` `    ``System.out.println(productPrimeFreq(arr, n));``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 implementation of the approach``MOD ``=` `1000000007` `# Function to create Sieve to check primes``def` `SieveOfEratosthenes(prime, p_size):``    ` `    ``# False here indicates``    ``# that it is not prime``    ``prime[``0``] ``=` `False``    ``prime[``1``] ``=` `False` `    ``for` `p ``in` `range``(``2``, p_size):` `        ``# If prime[p] is not changed,``        ``# then it is a prime``        ``if` `(prime[p]):` `            ``# Update all multiples of p,``            ``# set them to non-prime``            ``for` `i ``in` `range``(``2` `*` `p, p_size, p):``                ``prime[i] ``=` `False` `# Function to return the product of elements``# in an array having prime frequency``def` `productPrimeFreq(arr, n):``    ``prime ``=` `[``True` `for` `i ``in` `range``(n ``+` `1``)]` `    ``SieveOfEratosthenes(prime, n ``+` `1``)` `    ``i, j ``=` `0``, ``0` `    ``# Map is used to store``    ``# element frequencies``    ``m ``=` `dict``()``    ``for` `i ``in` `range``(n):``        ``m[arr[i]] ``=` `m.get(arr[i], ``0``) ``+` `1` `    ``product ``=` `1` `    ``# Traverse the map using iterators``    ``for` `it ``in` `m:` `        ``# Count the number of elements``        ``# having prime frequencies``        ``if` `(prime[m[it]]):``            ``product ``*``=` `it ``%` `MOD``            ``product ``%``=` `MOD` `    ``return` `product` `# Driver code``arr ``=` `[``5``, ``4``, ``6``, ``5``, ``4``, ``6``]``n ``=` `len``(arr)` `print``(productPrimeFreq(arr, n))` `# This code is contributed by Mohit Kumar`

## C#

 `// C# implementation for above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``static` `int` `MOD = 1000000007;` `// Function to create Sieve to check primes``static` `void` `SieveOfEratosthenes(``bool` `[]prime,``                                ``int` `p_size)``{``    ``// False here indicates``    ``// that it is not prime``    ``prime[0] = ``false``;``    ``prime[1] = ``false``;` `    ``for` `(``int` `p = 2; p * p <= p_size; p++)``    ``{` `        ``// If prime[p] is not changed,``        ``// then it is a prime``        ``if` `(prime[p])``        ``{` `            ``// Update all multiples of p,``            ``// set them to non-prime``            ``for` `(``int` `i = p * 2;``                     ``i <= p_size; i += p)``                ``prime[i] = ``false``;``        ``}``    ``}``}` `// Function to return the product of elements``// in an array having prime frequency``static` `int` `productPrimeFreq(``int` `[]arr, ``int` `n)``{``    ``bool` `[]prime = ``new` `bool``[n + 1];``    ``int` `i;``    ``for` `(i = 0; i < n; i++)``        ``prime[i] = ``true``;` `    ``SieveOfEratosthenes(prime, n + 1);` `    ``// Map is used to store``    ``// element frequencies``    ``Dictionary<``int``,``               ``int``> mp = ``new` `Dictionary<``int``,``                                        ``int``>();``    ``for` `(i = 0 ; i < n; i++)``    ``{``        ``if``(mp.ContainsKey(arr[i]))``        ``{``            ``var` `val = mp[arr[i]];``            ``mp.Remove(arr[i]);``            ``mp.Add(arr[i], val + 1);``        ``}``        ``else``        ``{``            ``mp.Add(arr[i], 1);``        ``}``    ``}``    ``long` `product = 1;` `    ``// Traverse the map using iterators``    ``foreach``(KeyValuePair<``int``, ``int``> it ``in` `mp)``    ``{` `        ``// Count the number of elements``        ``// having prime frequencies``        ``if` `(prime[it.Value])``        ``{``            ``product *= (it.Key % MOD);``            ``product %= MOD;``        ``}``    ``}``    ``return` `(``int``)(product);``}` `// Driver code``static` `public` `void` `Main (String []arg)``{``    ``int` `[]arr = { 5, 4, 6, 5, 4, 6 };``    ``int` `n = arr.Length;` `    ``Console.WriteLine(productPrimeFreq(arr, n));``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``

Output:

`120`

My Personal Notes arrow_drop_up