Generate an array of minimum sum whose XOR of same-indexed elements with given array are Prime Numbers

• Last Updated : 15 Apr, 2021

Given an array Arr[] of N ( 1 â‰¤ N â‰¤ 105)integers, the task is to generate an array B[] consisting of N non-zero elements, such that XOR of Ai ^ Bi always results in a prime number.

Note: The sum of XORs obtained should be minimized.

Examples:

Input: arr[] = {5, 4, 7, 6}
Output: {7, 6, 5, 4}
Explanation:
2 is the smallest prime number. Therefore, XORing A[i] with (A[i] ^ 2)
gives us the smallest number which is prime.
A[i] ^ (A[i] ^ 2) = (A[i] ^ A[i]) ^ 2 = 0 ^ 2 = 2
because
1. XOR of 5 ^ 7 = 2, which is prime
2. XOR of 4 ^ 6 = 2, which is prime.
3. XOR of 7 ^ 5 = 2, which is prime.
4. XOR of 6 ^ 4 = 2, which is prime.
The resultant sum is – 2 + 2 + 2 + 2 = 8, which is the minimum possible

Input: arr[] = {10, 16}
Output: {8, 18}

Approach: This problem can be solved using a Greedy technique. Follow the steps below to solve the problem:

1. Since 2 is the smallest prime number possible, XOR of Arr[i] with B[i] = (Arr[i] ^ 2) will give us a prime number 2.
2. The contradiction arises when any of the array elements itself is Arr[i] = 2. In this case, B[i] = 2 ^ 2 results in 0.
3. Therefore, if Arr[i] = 2, set B[i] = (2 ^ 3) = 1, such that Arr[i] ^ K = 3, next smallest prime number.

Below is the implementation of the above approach:

C++

 `// C++ implementation of the above approach` `#include ``using` `namespace` `std;` `// Function to generate an array whose XOR``// with same-indexed elements of the given``// array is always a prime``void` `minXOR(vector<``int``>& Arr, ``int` `N)``{``    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// If current array element is 2``        ``if` `(Arr[i] == 2) {` `            ``// Print its XOR with 3``            ``cout << (Arr[i] ^ 3) << ``" "``;``        ``}``        ``// Otherwise``        ``else` `{` `            ``// Print its XOR with 2``            ``cout << (Arr[i] ^ 2) << ``" "``;``        ``}``    ``}``}` `// Driver Code``int` `main()``{``    ``// Given array``    ``vector<``int``> Arr = { 5, 4, 7, 6 };` `    ``// Size of the array``    ``int` `N = Arr.size();` `    ``// Prints the required array``    ``minXOR(Arr, N);``    ``return` `0;``}`

Java

 `// Java implementation of the above approach``class` `GFG{` `// Function to generate an array whose XOR``// with same-indexed elements of the given``// array is always a prime``private` `static` `void` `minXOR(``int` `Arr[], ``int` `N)``{``    ` `    ``// Traverse the array``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ` `        ``// If current array element is 2``        ``if` `(Arr[i] == ``2``)``        ``{``            ` `            ``// Print its XOR with 3``            ``System.out.print((Arr[i] ^ ``3``) + ``" "``);``        ``}``        ` `        ``// Otherwise``        ``else``        ``{``            ` `            ``// Print its XOR with 2``            ``System.out.print((Arr[i] ^ ``2``) + ``" "``);``        ``}``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given array``    ``int` `Arr[] = { ``5``, ``4``, ``7``, ``6` `};``    ` `    ``// Size of the array``    ``int` `N = Arr.length;``    ` `    ``// Prints the required array``    ``minXOR(Arr, N);``}``}` `// This code is contributed by MuskanKalra1`

Python3

 `# Python3 implementation of the above approach`` ` `# Function to generate an array whose XOR``# with same-indexed elements of the given``# array is always a prime``def` `minXOR(Arr, N):``  ` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):`` ` `        ``# If current array element is 2``        ``if` `(Arr[i] ``=``=` `2``):`` ` `            ``# Print its XOR with 3``            ``print``(Arr[i] ^ ``3``,end``=``" "``)``        ``# Otherwise``        ``else``:`` ` `            ``# Print its XOR with 2``            ``print``(Arr[i] ^ ``2``,end``=``" "``)`` ` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Given array``    ``Arr ``=` `[``5``, ``4``, ``7``, ``6` `]`` ` `    ``# Size of the array``    ``N ``=` `len``(Arr)`` ` `    ``# Prints the required array``    ``minXOR(Arr, N)`` ` `# This code is contributed by mohit kumar 29`

C#

 `// C# program to implement``// the above approach ``using` `System;` `class` `GFG{` `// Function to generate an array whose XOR``// with same-indexed elements of the given``// array is always a prime``private` `static` `void` `minXOR(``int``[] Arr, ``int` `N)``{``    ` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ` `        ``// If current array element is 2``        ``if` `(Arr[i] == 2)``        ``{``            ` `            ``// Print its XOR with 3``            ``Console.Write((Arr[i] ^ 3) + ``" "``);``        ``}``        ` `        ``// Otherwise``        ``else``        ``{``            ` `            ``// Print its XOR with 2``            ``Console.Write((Arr[i] ^ 2) + ``" "``);``        ``}``    ``}``}` `// Driver code``public` `static` `void` `Main()``{``    ` `    ``// Given array``    ``int``[] Arr = { 5, 4, 7, 6 };``    ` `    ``// Size of the array``    ``int` `N = Arr.Length;``    ` `    ``// Prints the required array``    ``minXOR(Arr, N);``}``}`

Javascript

 ``

Output:

`7 6 5 4`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up