# 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)

Share your thoughts in the comments