Related Articles
XOR of K largest prime and composite numbers from the given array
• Last Updated : 14 Apr, 2021

Given an array arr[] of N non-zero positive integers and an integer K, the task is to find the XOR of the K largest prime and composite numbers.
Examples:

Input: arr[] = {4, 2, 12, 13, 5, 19}, K = 3
Output:
Prime XOR = 27
Composite XOR = 8
5, 13 and 19 are the three maximum primes
from the given array and 5 ^ 13 ^ 19 = 27.
There are only 2 composites in the array i.e. 4 and 12.
And 4 ^ 12 = 8
Input: arr[] = {1, 2, 3, 4, 5, 6, 7}, K = 1
Output:
Prime XOR = 7
Composite XOR = 6

Approach: Using Sieve of Eratosthenes generate a boolean vector upto the size of the maximum element from the array which can be used to check whether a number is prime or not.
Now traverse the array and insert all the numbers which are prime in a max heap maxHeapPrime and all the composite numbers in max heap maxHeapNonPrime
Now, pop out the top K elements from both the max heaps and take the xor of these elements.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function for Sieve of Eratosthenes``vector<``bool``> SieveOfEratosthenes(``int` `max_val)``{``    ``// Create a boolean vector "prime[0..n]". A``    ``// value in prime[i] will finally be false``    ``// if i is Not a prime, else true.``    ``vector<``bool``> prime(max_val + 1, ``true``);` `    ``// Set 0 and 1 as non-primes as``    ``// they don't need to be``    ``// counted as prime numbers``    ``prime = ``false``;``    ``prime = ``false``;` `    ``for` `(``int` `p = 2; p * p <= max_val; p++) {` `        ``// If prime[p] is not changed, then``        ``// it is a prime``        ``if` `(prime[p] == ``true``) {` `            ``// Update all multiples of p``            ``for` `(``int` `i = p * 2; i <= max_val; i += p)``                ``prime[i] = ``false``;``        ``}``    ``}``    ``return` `prime;``}` `// Function that calculates the xor``// of k smallest and k``// largest prime numbers in an array``void` `kMaxXOR(``int` `arr[], ``int` `n, ``int` `k)``{``    ``// Find maximum value in the array``    ``int` `max_val = *max_element(arr, arr + n);` `    ``// Use sieve to find all prime numbers``    ``// less than or equal to max_val``    ``vector<``bool``> prime = SieveOfEratosthenes(max_val);` `    ``// Min Heaps to store the max K prime``    ``// and composite numbers``    ``priority_queue<``int``, vector<``int``>, greater<``int``> >``        ``minHeapPrime, minHeapNonPrime;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If current element is prime``        ``if` `(prime[arr[i]]) {` `            ``// Min heap will only store k elements``            ``if` `(minHeapPrime.size() < k)``                ``minHeapPrime.push(arr[i]);` `            ``// If the size of min heap is K and the``            ``// top element is smaller than the current``            ``// element than it needs to be replaced``            ``// by the current element as only``            ``// max k elements are required``            ``else` `if` `(minHeapPrime.top() < arr[i]) {``                ``minHeapPrime.pop();``                ``minHeapPrime.push(arr[i]);``            ``}``        ``}` `        ``// If current element is composite``        ``else` `if` `(arr[i] != 1) {` `            ``// Heap will only store k elements``            ``if` `(minHeapNonPrime.size() < k)``                ``minHeapNonPrime.push(arr[i]);` `            ``// If the size of min heap is K and the``            ``// top element is smaller than the current``            ``// element than it needs to be replaced``            ``// by the current element as only``            ``// max k elements are required``            ``else` `if` `(minHeapNonPrime.top() < arr[i]) {``                ``minHeapNonPrime.pop();``                ``minHeapNonPrime.push(arr[i]);``            ``}``        ``}``    ``}` `    ``long` `long` `int` `primeXOR = 0, nonPrimeXor = 0;``    ``while` `(k--) {` `        ``// Calculate the xor``        ``if` `(minHeapPrime.size() > 0) {``            ``primeXOR ^= minHeapPrime.top();``            ``minHeapPrime.pop();``        ``}` `        ``if` `(minHeapNonPrime.size() > 0) {``            ``nonPrimeXor ^= minHeapNonPrime.top();``            ``minHeapNonPrime.pop();``        ``}``    ``}` `    ``cout << ``"Prime XOR = "` `<< primeXOR << ``"\n"``;``    ``cout << ``"Composite XOR = "` `<< nonPrimeXor << ``"\n"``;``}` `// Driver code``int` `main()``{` `    ``int` `arr[] = { 4, 2, 12, 13, 5, 19 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `k = 3;` `    ``kMaxXOR(arr, n, k);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{` `    ``// Function for Sieve of Eratosthenes``    ``static` `boolean``[] SieveOfEratosThenes(``int` `max_val)``    ``{` `        ``// Create a boolean vector "prime[0..n]". A``        ``// value in prime[i] will finally be false``        ``// if i is Not a prime, else true.``        ``boolean``[] prime = ``new` `boolean``[max_val + ``1``];``        ``Arrays.fill(prime, ``true``);` `        ``// Set 0 and 1 as non-primes as``        ``// they don't need to be``        ``// counted as prime numbers``        ``prime[``0``] = ``false``;``        ``prime[``1``] = ``false``;` `        ``for` `(``int` `p = ``2``; p * p <= max_val; p++)``        ``{` `            ``// If prime[p] is not changed, then``            ``// it is a prime``            ``if` `(prime[p])``            ``{` `                ``// Update all multiples of p``                ``for` `(``int` `i = p * ``2``; i <= max_val; i += p)``                    ``prime[i] = ``false``;``            ``}``        ``}``        ``return` `prime;``    ``}` `    ``// Function that calculates the xor``    ``// of k smallest and k``    ``// largest prime numbers in an array``    ``static` `void` `kMinXOR(Integer[] arr, ``int` `n, ``int` `k)``    ``{` `        ``// Find maximum value in the array``        ``int` `max_val = Collections.max(Arrays.asList(arr));` `        ``// Use sieve to find all prime numbers``        ``// less than or equal to max_val``        ``boolean``[] prime = SieveOfEratosThenes(max_val);` `        ``// Min Heaps to store the max K prime``        ``// and composite numbers``        ``PriorityQueue minHeapPrime = ``new` `PriorityQueue<>();``        ``PriorityQueue minHeapNonPrime = ``new` `PriorityQueue<>();` `        ``for` `(``int` `i = ``0``; i < n; i++)``        ``{` `            ``// If current element is prime``            ``if` `(prime[arr[i]])``            ``{` `                ``// Min heap will only store k elements``                ``if` `(minHeapPrime.size() < k)``                    ``minHeapPrime.add(arr[i]);` `                ``// If the size of min heap is K and the``                ``// top element is smaller than the current``                ``// element than it needs to be replaced``                ``// by the current element as only``                ``// max k elements are required``                ``else` `if` `(minHeapPrime.peek() < arr[i])``                ``{``                    ``minHeapPrime.poll();``                    ``minHeapPrime.add(arr[i]);``                ``}``            ``}` `            ``// If current element is composite``            ``else` `if` `(arr[i] != -``1``)``            ``{` `                ``// Heap will only store k elements``                ``if` `(minHeapNonPrime.size() < k)``                    ``minHeapNonPrime.add(arr[i]);` `                ``// If the size of min heap is K and the``                ``// top element is smaller than the current``                ``// element than it needs to be replaced``                ``// by the current element as only``                ``// max k elements are required``                ``else` `if` `(minHeapNonPrime.peek() < arr[i])``                ``{``                    ``minHeapNonPrime.poll();``                    ``minHeapNonPrime.add(arr[i]);``                ``}``            ``}``        ``}` `        ``long` `primeXOR = ``0``, nonPrimeXor = ``0``;` `        ``while` `(k-- > ``0``)``        ``{` `            ``// Calculate the xor``            ``if` `(minHeapPrime.size() > ``0``)``            ``{``                ``primeXOR ^= minHeapPrime.peek();``                ``minHeapPrime.poll();``            ``}` `            ``if` `(minHeapNonPrime.size() > ``0``)``            ``{``                ``nonPrimeXor ^= minHeapNonPrime.peek();``                ``minHeapNonPrime.poll();``            ``}``        ``}` `        ``System.out.println(``"Prime XOR = "` `+ primeXOR);``        ``System.out.println(``"Composite XOR = "` `+ nonPrimeXor);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``Integer[] arr = { ``4``, ``2``, ``12``, ``13``, ``5``, ``19` `};``        ``int` `n = arr.length;``        ``int` `k = ``3``;` `        ``kMinXOR(arr, n, k);``    ``}``}` `// This code is contributed by``// sanjeev2552`

## Python3

 `# Python implimentation of above approach` `import` `heapq`  `# Function for Sieve of Eratosthenes``def` `SieveOfEratosthenes(max_val: ``int``) ``-``> ``list``:` `    ``# Create a boolean vector "prime[0..n]". A``    ``# value in prime[i] will finally be false``    ``# if i is Not a prime, else true.``    ``prime ``=` `[``True``] ``*` `(max_val ``+` `1``)` `    ``# Set 0 and 1 as non-primes as``    ``# they don't need to be``    ``# counted as prime numbers``    ``prime[``0``] ``=` `False``    ``prime[``1``] ``=` `False` `    ``p ``=` `2``    ``while` `p ``*` `p <``=` `max_val:` `        ``# If prime[p] is not changed, then``        ``# it is a prime``        ``if` `prime[p]:` `            ``# Update all multiples of p``            ``for` `i ``in` `range``(p ``*` `2``, max_val ``+` `1``, p):``                ``prime[i] ``=` `False``        ``p ``+``=` `1``    ``return` `prime`  `# Function that calculates the xor``# of k smallest and k``# largest prime numbers in an array``def` `kMaxXOR(arr: ``list``, n: ``int``, k: ``int``):` `    ``# Find maximum value in the array``    ``max_val ``=` `max``(arr)` `    ``# Use sieve to find all prime numbers``    ``# less than or equal to max_val``    ``prime ``=` `SieveOfEratosthenes(max_val)` `    ``# Min Heaps to store the max K prime``    ``# and composite numbers``    ``minHeapPrime, minHeapNonPrime ``=` `[], []``    ``heapq.heapify(minHeapPrime)``    ``heapq.heapify(minHeapNonPrime)` `    ``for` `i ``in` `range``(n):` `        ``# If current element is prime``        ``if` `prime[arr[i]]:` `            ``# Min heap will only store k elements``            ``if` `len``(minHeapPrime) < k:``                ``heapq.heappush(minHeapPrime, arr[i])` `            ``# If the size of min heap is K and the``            ``# top element is smaller than the current``            ``# element than it needs to be replaced``            ``# by the current element as only``            ``# max k elements are required``            ``elif` `heapq.nsmallest(``1``, minHeapPrime)[``0``] < arr[i]:``                ``heapq.heappop(minHeapPrime)``                ``heapq.heappush(minHeapPrime, arr[i])` `        ``# If current element is composite``        ``elif` `arr[i] !``=` `1``:` `            ``# Heap will only store k elements``            ``if` `len``(minHeapNonPrime) < k:``                ``heapq.heappush(minHeapNonPrime, arr[i])` `            ``# If the size of min heap is K and the``            ``# top element is smaller than the current``            ``# element than it needs to be replaced``            ``# by the current element as only``            ``# max k elements are required``            ``elif` `heapq.nsmallest(``1``, minHeapNonPrime)[``0``] < arr[i]:``                ``heapq.heappop(minHeapNonPrime)``                ``heapq.heappush(minHeapNonPrime, arr[i])` `    ``primeXOR ``=` `0``    ``nonPrimeXor ``=` `0` `    ``while` `k > ``0``:` `        ``# Calculate the xor``        ``if` `len``(minHeapPrime) > ``0``:``            ``primeXOR ^``=` `heapq.nsmallest(``1``, minHeapPrime)[``0``]``            ``heapq.heappop(minHeapPrime)` `        ``if` `len``(minHeapNonPrime) > ``0``:``            ``nonPrimeXor ^``=` `heapq.nsmallest(``1``, minHeapNonPrime)[``0``]``            ``heapq.heappop(minHeapNonPrime)``        ``k ``-``=` `1` `    ``print``(``"Prime XOR ="``, primeXOR)``    ``print``(``"Composite XOR ="``, nonPrimeXor)`  `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``4``, ``2``, ``12``, ``13``, ``5``, ``19``]``    ``n ``=` `len``(arr)``    ``k ``=` `3``    ``kMaxXOR(arr, n, k)` `# This code is contributed by``# sanjeev2552`

## C#

 `// C# implementation of the approach ``using` `System;``using` `System.Collections.Generic;``class` `GFG {` `  ``// Function for Sieve of Eratosthenes``  ``static` `bool``[] SieveOfEratosThenes(``int` `max_val)``  ``{` `    ``// Create a boolean vector "prime[0..n]". A``    ``// value in prime[i] will finally be false``    ``// if i is Not a prime, else true.``    ``bool``[] prime = ``new` `bool``[max_val + 1];``    ``for``(``int` `i = 0; i < max_val + 1; i++)``    ``{``      ``prime[i] = ``true``;``    ``}` `    ``// Set 0 and 1 as non-primes as``    ``// they don't need to be``    ``// counted as prime numbers``    ``prime = ``false``;``    ``prime = ``false``;` `    ``for` `(``int` `p = 2; p * p <= max_val; p++)``    ``{` `      ``// If prime[p] is not changed, then``      ``// it is a prime``      ``if` `(prime[p]) ``      ``{` `        ``// Update all multiples of p``        ``for` `(``int` `i = p * 2; i <= max_val; i += p)``          ``prime[i] = ``false``;``      ``}``    ``}``    ``return` `prime;``  ``}` `  ``// Function that calculates the xor``  ``// of k smallest and k``  ``// largest prime numbers in an array``  ``static` `void` `kMinXOR(``int``[] arr, ``int` `n, ``int` `k) ``  ``{` `    ``// Find maximum value in the array``    ``int` `max_val = Int32.MinValue;``    ``for``(``int` `i = 0; i < arr.Length; i++)``    ``{``      ``max_val = Math.Max(max_val,arr[i]);``    ``}` `    ``// Use sieve to find all prime numbers``    ``// less than or equal to max_val``    ``bool``[] prime = SieveOfEratosThenes(max_val);` `    ``// Min Heaps to store the max K prime``    ``// and composite numbers``    ``List<``int``> minHeapPrime = ``new` `List<``int``>();``    ``List<``int``> minHeapNonPrime = ``new` `List<``int``>();` `    ``for` `(``int` `i = 0; i < n; i++)``    ``{` `      ``// If current element is prime``      ``if` `(prime[arr[i]]) ``      ``{` `        ``// Min heap will only store k elements``        ``if` `(minHeapPrime.Count < k)``        ``{``          ``minHeapPrime.Add(arr[i]);``        ``}` `        ``// If the size of min heap is K and the``        ``// top element is smaller than the current``        ``// element than it needs to be replaced``        ``// by the current element as only``        ``// max k elements are required``        ``else` `if` `(minHeapPrime < arr[i])``        ``{``          ``minHeapPrime.RemoveAt(0);``          ``minHeapPrime.Add(arr[i]);``        ``}``        ``minHeapPrime.Sort();``      ``}` `      ``// If current element is composite``      ``else` `if` `(arr[i] != -1)``      ``{` `        ``// Heap will only store k elements``        ``if` `(minHeapNonPrime.Count < k)``          ``minHeapNonPrime.Add(arr[i]);` `        ``// If the size of min heap is K and the``        ``// top element is smaller than the current``        ``// element than it needs to be replaced``        ``// by the current element as only``        ``// max k elements are required``        ``else` `if` `(minHeapNonPrime < arr[i]) ``        ``{``          ``minHeapNonPrime.RemoveAt(0);``          ``minHeapNonPrime.Add(arr[i]);``        ``}``        ``minHeapNonPrime.Sort();``      ``}``    ``}` `    ``long` `primeXOR = 0, nonPrimeXor = 0;` `    ``while` `(k-- > 0) ``    ``{` `      ``// Calculate the xor``      ``if` `(minHeapPrime.Count > 0)``      ``{``        ``primeXOR ^= minHeapPrime;``        ``minHeapPrime.RemoveAt(0);``      ``}` `      ``if` `(minHeapNonPrime.Count > 0) ``      ``{``        ``nonPrimeXor ^= minHeapNonPrime;``        ``minHeapNonPrime.RemoveAt(0);``      ``}``    ``}` `    ``Console.WriteLine(``"Prime XOR = "` `+ primeXOR);``    ``Console.WriteLine(``"Composite XOR = "` `+ nonPrimeXor);``  ``}` `  ``// Driver code``  ``static` `void` `Main()``  ``{``    ``int``[] arr = { 4, 2, 12, 13, 5, 19 };``    ``int` `n = arr.Length;``    ``int` `k = 3;` `    ``kMinXOR(arr, n, k);``  ``}``}` `// This code is contributed by divyesh072019.`

## Javascript

 ``
Output:
```Prime XOR = 27
Composite XOR = 8```

My Personal Notes arrow_drop_up