Given an array arr[] of N elements, the task is to find the xor of the elements which have prime frequencies in the array. Note that 1 is neither prime nor composite.
Examples:
Input: arr[] = {5, 4, 6, 5, 4, 6}
Output: 7
Explanation: All the elements appear 2 times which is a prime
So, 5 ^ 4 ^ 6 = 7Input: arr[] = {1, 2, 3, 3, 2, 3, 2, 3, 3}
Output: 1
Explanation: Only 2 and 3 appears prime number of times i.e. 3 and 5 respectively.
So, 2 ^ 3 = 1
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 xor 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;
// 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 xor of elements // in an array having prime frequency int xorPrimeFreq( 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 xorVal = 0;
// 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]) {
xorVal ^= it->first;
}
}
return xorVal;
} // Driver code int main()
{ int arr[] = { 5, 4, 6, 5, 4, 6 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << xorPrimeFreq(arr, n);
return 0;
} |
// Java program to find xor of elements // in an array having prime frequency import java.util.*;
class GFG
{ // 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 xor of elements
// in an array having prime frequency
static int xorOfElements( int arr[], int n)
{
boolean prime[] = new boolean [n + 1 ];
Arrays.fill(prime, true );
SieveOfEratosthenes(prime, n + 1 );
int i, j;
// Map is used to store
// element frequencies
HashMap<Integer,
Integer> m = new HashMap<>();
for (i = 0 ; i < n; i++)
{
if (m.containsKey(arr[i]))
m.put(arr[i], m.get(arr[i]) + 1 );
else
m.put(arr[i], 1 );
}
int xor = 0 ;
// Traverse the map
for (Map.Entry<Integer,
Integer> entry : m.entrySet())
{
int key = entry.getKey();
int value = entry.getValue();
// xor the elements
// having prime frequencies
if (prime[value])
{
xor ^= (key);
}
}
return xor;
}
// Driver code
public static void main(String args[])
{
int arr[] = { 5 , 4 , 6 , 5 , 4 , 6 };
int n = arr.length;
System.out.println(xorOfElements(arr, n));
}
} // This code is contributed by NikhilRathor |
# Python3 implementation of the approach from math import sqrt
# 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 , int (sqrt(p_size)) + 1 ) :
# 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 (p * 2 , p_size + 1 , p) :
prime[i] = False ;
return prime
# Function to return the xor of elements # in an array having prime frequency def xorPrimeFreq( arr, n) :
prime = [ True ] * (n + 1 );
prime = SieveOfEratosthenes(prime, n + 1 );
# Map is used to store
# element frequencies
m = dict .fromkeys(arr, 0 );
for i in range (n) :
m[arr[i]] + = 1 ;
xorVal = 0 ;
# Traverse the map using iterators
for key,value in m.items() :
# Count the number of elements
# having prime frequencies
if (prime[value]) :
xorVal ^ = key;
return xorVal;
# Driver code if __name__ = = "__main__" :
arr = [ 5 , 4 , 6 , 5 , 4 , 6 ];
n = len (arr);
print (xorPrimeFreq(arr, n));
# This code is contributed by AnkitRai01 |
// C# program to find xor of elements // in an array having prime frequency using System;
using System.Collections.Generic;
class GFG
{ // 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 xor of elements
// in an array having prime frequency
static int xorOfElements( int []arr, int n)
{
int i, j;
bool []prime = new bool [n + 1];
for (i = 0; i< n + 1; i++)
prime[i] = true ;
SieveOfEratosthenes(prime, n + 1);
// Map is used to store
// element frequencies
Dictionary< int ,
int > m = new Dictionary< int ,
int >();
for (i = 0; i < n; i++)
{
if (m.ContainsKey(arr[i]))
m[arr[i]] = m[arr[i]] + 1;
else
m.Add(arr[i], 1);
}
int xor = 0;
// Traverse the map
foreach (KeyValuePair< int , int > entry in m)
{
int key = entry.Key;
int value = entry.Value;
// xor the elements
// having prime frequencies
if (prime[value])
{
xor ^= (key);
}
}
return xor;
}
// Driver code
public static void Main(String []args)
{
int []arr = { 5, 4, 6, 5, 4, 6 };
int n = arr.Length;
Console.WriteLine(xorOfElements(arr, n));
}
} // This code is contributed by 29AjayKumar |
<script> // javascript implementation of the approach // 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 xorPrimeFreq(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 xorVal = 0;
// Traverse the map using iterators
for ( var it in m) {
// Count the number of elements
// having prime frequencies
if (prime[m[it]]) {
xorVal ^= it;
}
}
return xorVal;
} // Driver code let a = [ 5, 4, 6, 5, 4, 6 ]; let len = a.length; document.write( xorPrimeFreq(a, len)); </script> |
7
Time Complexity: O( n* log(log(n))), As Sieve of Eratosthenes take O( n* log(log(n))) and other’s have relatively lower time complexity.
Auxiliary Space: O(n), As we are using n extra space for prime array and for creating a map.