XOR of elements in an array having prime frequency
Last Updated :
08 Aug, 2022
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 = 7
Input: 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++
#include <bits/stdc++.h>
using namespace std;
void SieveOfEratosthenes( bool prime[], int p_size)
{
prime[0] = false ;
prime[1] = false ;
for ( int p = 2; p * p <= p_size; p++) {
if (prime[p]) {
for ( int i = p * 2; i <= p_size; i += p)
prime[i] = false ;
}
}
}
int xorPrimeFreq( int arr[], int n)
{
bool prime[n + 1];
memset (prime, true , sizeof (prime));
SieveOfEratosthenes(prime, n + 1);
int i, j;
unordered_map< int , int > m;
for (i = 0; i < n; i++)
m[arr[i]]++;
long xorVal = 0;
for ( auto it = m.begin(); it != m.end(); it++) {
if (prime[it->second]) {
xorVal ^= it->first;
}
}
return xorVal;
}
int main()
{
int arr[] = { 5, 4, 6, 5, 4, 6 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << xorPrimeFreq(arr, n);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static void SieveOfEratosthenes( boolean prime[],
int p_size)
{
prime[ 0 ] = false ;
prime[ 1 ] = false ;
for ( int p = 2 ; p * p <= p_size; p++)
{
if (prime[p])
{
for ( int i = p * 2 ;
i <= p_size; i += p)
prime[i] = false ;
}
}
}
static int xorOfElements( int arr[], int n)
{
boolean prime[] = new boolean [n + 1 ];
Arrays.fill(prime, true );
SieveOfEratosthenes(prime, n + 1 );
int i, j;
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 ;
for (Map.Entry<Integer,
Integer> entry : m.entrySet())
{
int key = entry.getKey();
int value = entry.getValue();
if (prime[value])
{
xor ^= (key);
}
}
return xor;
}
public static void main(String args[])
{
int arr[] = { 5 , 4 , 6 , 5 , 4 , 6 };
int n = arr.length;
System.out.println(xorOfElements(arr, n));
}
}
|
Python3
from math import sqrt
def SieveOfEratosthenes(prime, p_size) :
prime[ 0 ] = False ;
prime[ 1 ] = False ;
for p in range ( 2 , int (sqrt(p_size)) + 1 ) :
if (prime[p]) :
for i in range (p * 2 , p_size + 1 , p) :
prime[i] = False ;
return prime
def xorPrimeFreq( arr, n) :
prime = [ True ] * (n + 1 );
prime = SieveOfEratosthenes(prime, n + 1 );
m = dict .fromkeys(arr, 0 );
for i in range (n) :
m[arr[i]] + = 1 ;
xorVal = 0 ;
for key,value in m.items() :
if (prime[value]) :
xorVal ^ = key;
return xorVal;
if __name__ = = "__main__" :
arr = [ 5 , 4 , 6 , 5 , 4 , 6 ];
n = len (arr);
print (xorPrimeFreq(arr, n));
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static void SieveOfEratosthenes( bool []prime,
int p_size)
{
prime[0] = false ;
prime[1] = false ;
for ( int p = 2; p * p <= p_size; p++)
{
if (prime[p])
{
for ( int i = p * 2;
i <= p_size; i += p)
prime[i] = false ;
}
}
}
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);
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;
foreach (KeyValuePair< int , int > entry in m)
{
int key = entry.Key;
int value = entry.Value;
if (prime[value])
{
xor ^= (key);
}
}
return xor;
}
public static void Main(String []args)
{
int []arr = { 5, 4, 6, 5, 4, 6 };
int n = arr.Length;
Console.WriteLine(xorOfElements(arr, n));
}
}
|
Javascript
<script>
function SieveOfEratosthenes(prime, p_size){
prime[0] = false ;
prime[1] = false ;
for (let p = 2; p * p <= p_size; p++) {
if (prime[p]) {
for (let i = p * 2; i <= p_size; i += p)
prime[i] = false ;
}
}
return prime;
}
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;
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;
for ( var it in m) {
if (prime[m[it]]) {
xorVal ^= it;
}
}
return xorVal;
}
let a = [ 5, 4, 6, 5, 4, 6 ];
let len = a.length;
document.write( xorPrimeFreq(a, len));
</script>
|
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.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...