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: 6
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++ implementation of the approach #include <bits/stdc++.h> 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 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<Integer,
Integer> mp = new HashMap<Integer,
Integer>();
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<Integer,
Integer> 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 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# 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 |
<script> // JavaScript implementation of the approach let MOD = 1000000007; // Function to create Sieve to check primes function SieveOfEratosthenes(prime, p_size){
// False here indicates
// that it is not prime
prime[0] = false ;
prime[1] = false ;
for (let 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 (let i = p * 2; i <= p_size; i += p)
prime[i] = false ;
}
}
return prime;
} // Function to return the product of elements // in an array having prime frequency function productPrimeFreq(arr, n){
let prime = [];
for (let i = 0;i<n+1;i++){
prime.push( true );
}
prime = SieveOfEratosthenes(prime, n + 1);
let i, j;
// Map is used to store
// element frequencies
let m = new Map();
for (i = 0; i < n; i++){
if (m[arr[i]])
m[arr[i]]++;
else
m[arr[i]] = 1;
}
let product = 1;
// Traverse the map using iterators
for ( var it in m) {
// Count the number of elements
// having prime frequencies
if (prime[m[it]]) {
product *= (it % MOD);
product %= MOD;
}
}
return (product);
} // Driver code let a = [ 5, 4, 6, 5, 4, 6 ]; let len = a.length; document.write(productPrimeFreq(a, len)); </script> |
120
Time Complexity: O(n * log(log(n))
Auxiliary Space: O(n), where n is the size of the given array.