# XOR of K smallest 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 = 10
Composite XOR = 8
2, 5 and 13 are the three maximum primes
from the given array and 2 ^ 5 ^ 13 = 10.
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 = 2
Composite XOR = 4

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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 min heap minHeapPrime and all the composite numbers in min heap minHeapNonPrime
Now, pop out the top K elements from both the min 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[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] == ``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` `kMinXOR(``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);` `    ``// Max Heaps to store all the``    ``// prime and composite numbers``    ``priority_queue<``int``> maxHeapPrime, maxHeapNonPrime;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If current element is prime``        ``if` `(prime[arr[i]]) {``            ` `            ``// Max heap will only store k elements``            ``if` `(maxHeapPrime.size() < k)``                ``maxHeapPrime.push(arr[i]);``  ` `            ``// If the size of max heap is K and the``            ``// top element is greater than the current``            ``// element than it needs to be replaced``            ``// by the current element as only``            ``// minimum k elements are required``            ``else` `if` `(maxHeapPrime.top() > arr[i]) {``                ``maxHeapPrime.pop();``                ``maxHeapPrime.push(arr[i]);``            ``}``        ``}` `        ``// If current element is composite``        ``else` `if` `(arr[i] != 1) {``            ` `            ``// Heap will only store k elements``            ``if` `(maxHeapNonPrime.size() < k)``                ``maxHeapNonPrime.push(arr[i]);``  ` `            ``// If the size of max heap is K and the``            ``// top element is greater than the current``            ``// element than it needs to be replaced``            ``// by the current element as only``            ``// minimum k elements are required``            ``else` `if` `(maxHeapNonPrime.top() > arr[i]) {``                ``maxHeapNonPrime.pop();``                ``maxHeapNonPrime.push(arr[i]);``            ``}``        ``}``    ``}` `    ``long` `long` `int` `primeXOR = 0, nonPrimeXor = 0;``    ``while` `(k--) {` `        ``// Calculate the xor``        ``if` `(maxHeapPrime.size() > 0) {``            ``primeXOR ^= maxHeapPrime.top();``            ``maxHeapPrime.pop();``        ``}` `        ``if` `(maxHeapNonPrime.size() > 0) {``            ``nonPrimeXor ^= maxHeapNonPrime.top();``            ``maxHeapNonPrime.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[0]);``    ``int` `k = 3;` `    ``kMinXOR(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 sum``    ``// and product of k smallest and k``    ``// largest composite 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);` `        ``// Max Heap to store all the prime and composite numbers``        ``PriorityQueue maxHeapPrime =``                           ``new` `PriorityQueue((x, y) -> y - x);``        ``PriorityQueue maxHeapNonPrime =``                           ``new` `PriorityQueue((x, y) -> y - x);` `        ``for` `(``int` `i = ``0``; i < n; i++)``        ``{` `            ``// If current element is prime``            ``if` `(prime[arr[i]])``            ``{` `                ``// Max heap will only store k elements``                ``if` `(maxHeapPrime.size() < k)``                    ``maxHeapPrime.add(arr[i]);` `                ``// If the size of max heap is K and the``                ``// top element is greater than the current``                ``// element than it needs to be replaced``                ``// by the current element as only``                ``// minimum k elements are required``                ``else` `if` `(maxHeapPrime.peek() > arr[i])``                ``{``                    ``maxHeapPrime.poll();``                    ``maxHeapPrime.add(arr[i]);``                ``}``            ``}` `            ``// If current element is composite``            ``else` `if` `(arr[i] != -``1``)``            ``{` `                ``// Heap will only store k elements``                ``if` `(maxHeapNonPrime.size() < k)``                    ``maxHeapNonPrime.add(arr[i]);` `                ``// If the size of max heap is K and the``                ``// top element is greater than the current``                ``// element than it needs to be replaced``                ``// by the current element as only``                ``// minimum k elements are required``                ``else` `if` `(maxHeapNonPrime.peek() > arr[i])``                ``{``                    ``maxHeapNonPrime.poll();``                    ``maxHeapNonPrime.add(arr[i]);``                ``}``            ``}``        ``}` `        ``long` `primeXOR = ``0``, nonPrimeXor = ``0``;` `        ``while` `(k-- > ``0``)``        ``{` `            ``// Calculate the xor``            ``if` `(maxHeapPrime.size() > ``0``)``            ``{``                ``primeXOR ^= maxHeapPrime.peek();``                ``maxHeapPrime.poll();``            ``}` `            ``if` `(maxHeapNonPrime.size() > ``0``)``            ``{``                ``nonPrimeXor ^= maxHeapNonPrime.peek();``                ``maxHeapNonPrime.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`

## Python 3

 `from` `math ``import` `sqrt``# Python 3 implementation of the approach` `# Function for Sieve of Eratosthenes``def` `SieveOfEratosthenes(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.``    ``prime ``=` `[``True` `for` `i ``in` `range``(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` `    ``for` `p ``in` `range``(``2``,``int``(sqrt(max_val)) ``+` `1``, ``1``):``        ` `        ``# If prime[p] is not changed, then``        ``# it is a prime``        ``if` `(prime[p] ``=``=` `True``):``            ` `            ``# Update all multiples of p``            ``for` `i ``in` `range``(p ``*` `2``,max_val``+``1``,p):``                ``prime[i] ``=` `False` `    ``return` `prime` `# Function that calculates the xor``# of k smallest and k``# largest prime numbers in an array``def` `kMinXOR(arr, n, k):``    ` `    ``# 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)` `    ``# Max Heaps to store all the``    ``# prime and composite numbers``    ``maxHeapPrime ``=` `[]``    ``maxHeapNonPrime ``=` `[]` `    ``for` `i ``in` `range``(n):``        ` `        ``# If current element is prime``        ``if` `(prime[arr[i]]):` `            ``# Max heap will only store k elements``            ``if` `(``len``(maxHeapPrime) < k):``                ``maxHeapPrime.append(arr[i])``                ``maxHeapPrime.sort(reverse ``=` `True``)` `            ``# If the size of max heap is K and the``            ``# top element is greater than the current``            ``# element than it needs to be replaced``            ``# by the current element as only``            ``# minimum k elements are required``            ``elif``(maxHeapPrime[``0``] > arr[i]):``                ``maxHeapPrime.remove(maxHeapPrime[``0``])``                ``maxHeapPrime.append(arr[i])``                ``maxHeapPrime.sort(reverse ``=` `True``)` `        ``# If current element is composite``        ``elif``(arr[i] !``=` `1``):``            ` `            ``# Heap will only store k elements``            ``if` `(``len``(maxHeapNonPrime) < k):``                ``maxHeapNonPrime.append(arr[i])``                ``maxHeapNonPrime.sort(reverse ``=` `True``)` `            ``# If the size of max heap is K and the``            ``# top element is greater than the current``            ``# element than it needs to be replaced``            ``# by the current element as only``            ``# minimum k elements are required``            ``elif``(maxHeapNonPrime[``0``] > arr[i]):``                ``maxHeapNonPrime.remove(maxHeapNonPrime[``0``])``                ``maxHeapNonPrime.append(arr[i])``                ``maxHeapNonPrime.sort(reverse ``=` `True``)` `    ``primeXOR ``=` `0``    ``nonPrimeXor ``=` `0``    ``while` `(k):``        ` `        ``# Calculate the xor``        ``if` `(``len``(maxHeapPrime) > ``0``):``            ``primeXOR ^``=` `maxHeapPrime[``0``]``            ``maxHeapPrime.remove(maxHeapPrime[``0``])` `        ``if` `(``len``(maxHeapNonPrime) > ``0``):``            ``nonPrimeXor ^``=` `maxHeapNonPrime[``0``];``            ``maxHeapNonPrime.remove(maxHeapNonPrime[``0``])``        ` `        ``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` `    ``kMinXOR(arr, n, k);` `# This code is contributed by Surendra_Gangwar`

## 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];``    ``Array.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 sum``  ``// and product of k smallest and k``  ``// largest composite numbers in an array``  ``static` `void` `kMinXOR(``int``[] arr, ``int` `n, ``int` `k) ``  ``{` `    ``// Find maximum value in the array``    ``int` `max_val = arr[0];``    ``for``(``int` `i = 1; 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);` `    ``// Max Heap to store all the prime and composite numbers``    ``List<``int``> maxHeapPrime =  ``new` `List<``int``>();``    ``List<``int``> maxHeapNonPrime =  ``new` `List<``int``>();``    ``for` `(``int` `i = 0; i < n; i++) ``    ``{` `      ``// If current element is prime``      ``if` `(prime[arr[i]]) ``      ``{` `        ``// Max heap will only store k elements``        ``if` `(maxHeapPrime.Count < k)``        ``{``          ``maxHeapPrime.Add(arr[i]);``          ``maxHeapPrime.Sort();``          ``maxHeapPrime.Reverse();``        ``}` `        ``// If the size of max heap is K and the``        ``// top element is greater than the current``        ``// element than it needs to be replaced``        ``// by the current element as only``        ``// minimum k elements are required``        ``else` `if` `(maxHeapPrime[0] > arr[i]) ``        ``{``          ``maxHeapPrime.RemoveAt(0);``          ``maxHeapPrime.Add(arr[i]);``          ``maxHeapPrime.Sort();``          ``maxHeapPrime.Reverse();``        ``}``      ``}` `      ``// If current element is composite``      ``else` `if` `(arr[i] != -1) ``      ``{` `        ``// Heap will only store k elements``        ``if` `(maxHeapNonPrime.Count < k)``        ``{``          ``maxHeapNonPrime.Add(arr[i]);``          ``maxHeapNonPrime.Sort();``          ``maxHeapNonPrime.Reverse();``        ``}` `        ``// If the size of max heap is K and the``        ``// top element is greater than the current``        ``// element than it needs to be replaced``        ``// by the current element as only``        ``// minimum k elements are required``        ``else` `if` `(maxHeapNonPrime[0] > arr[i])``        ``{``          ``maxHeapNonPrime.RemoveAt(0);``          ``maxHeapNonPrime.Add(arr[i]);``          ``maxHeapNonPrime.Sort();``          ``maxHeapNonPrime.Reverse();``        ``}``      ``}``    ``}``    ``long` `primeXOR = 0, nonPrimeXor = 0;``    ``while` `(k-- > 0) ``    ``{` `      ``// Calculate the xor``      ``if` `(maxHeapPrime.Count > 0) ``      ``{``        ``primeXOR ^= maxHeapPrime[0];``        ``maxHeapPrime.RemoveAt(0);``      ``}``      ``if` `(maxHeapNonPrime.Count > 0) ``      ``{``        ``nonPrimeXor ^= maxHeapNonPrime[0];``        ``maxHeapNonPrime.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 = 10
Composite XOR = 8```

My Personal Notes arrow_drop_up