Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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 
 

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 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 <bits/stdc++.h>
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 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[0]);
    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<Integer> minHeapPrime = new PriorityQueue<>();
        PriorityQueue<Integer> 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[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(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[0] < 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[0] < 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[0];
        minHeapPrime.RemoveAt(0);
      }
 
      if (minHeapNonPrime.Count > 0) 
      {
        nonPrimeXor ^= minHeapNonPrime[0];
        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




<script>
 
    // Javascript implementation of the approach
     
    // Function for Sieve of Eratosthenes
    function 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.
      let prime = new Array(max_val + 1);
      for(let 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[0] = false;
      prime[1] = false;
 
      for (let 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 (let 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
    function kMinXOR(arr, n, k)
    {
 
      // Find maximum value in the array
      let max_val = Number.MIN_VALUE;
      for(let 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
      let prime = SieveOfEratosThenes(max_val);
 
      // Min Heaps to store the max K prime
      // and composite numbers
      let minHeapPrime = [];
      let minHeapNonPrime = [];
 
      for (let i = 0; i < n; i++)
      {
 
        // If current element is prime
        if (prime[arr[i]])
        {
 
          // Min heap will only store k elements
          if (minHeapPrime.length < 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[0] < arr[i])
          {
            minHeapPrime.shift();
            minHeapPrime.push(arr[i]);
          }
          minHeapPrime.sort(function(a, b){return a - b});
        }
 
        // If current element is composite
        else if (arr[i] != -1)
        {
 
          // Heap will only store k elements
          if (minHeapNonPrime.length < 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[0] < arr[i])
          {
            minHeapNonPrime.shift();
            minHeapNonPrime.push(arr[i]);
          }
          minHeapNonPrime.sort(function(a, b){return a - b});
        }
      }
 
      let primeXOR = 0, nonPrimeXor = 0;
 
      while (k-- > 0)
      {
 
        // Calculate the xor
        if (minHeapPrime.length > 0)
        {
          primeXOR ^= minHeapPrime[0];
          minHeapPrime.shift();
        }
 
        if (minHeapNonPrime.length > 0)
        {
          nonPrimeXor ^= minHeapNonPrime[0];
          minHeapNonPrime.shift();
        }
      }
 
      document.write("Prime XOR = " + primeXOR + "</br>");
      document.write("Composite XOR = " + nonPrimeXor);
    }
       
    let arr = [ 4, 2, 12, 13, 5, 19 ];
    let n = arr.length;
    let k = 3;
  
    kMinXOR(arr, n, k);
     
</script>
Output: 
Prime XOR = 27
Composite XOR = 8

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :