 GeeksforGeeks App
Open App Browser
Continue

# Form an Array so that their Bitwise XOR sum satisfies given conditions

Given an array arr[] of size N ( N is even ), the task is to construct an array B[] such that the sum of B[i] XOR PrefixXor[i], where 1 ≤ i ≤ N is even and is divisible by the first N/2 elements of arr[]

PrefixXor[] array is an array where each element will indicate the XOR of all elements from 1st element to the current index element.

Examples:

Input: N = 4, arr[] = {2, 6, 1, 5}
Output: B[] = {0, 6, 3, 6}
Explanation: Since, prefix array is prefixXor[] = {2, 4, 5, 0}, (2 ^ 0) + (4 ^ 6) + (5 ^ 3) + (0^6) = 2 + 2 + 6 + 6 = 16, which is even and divisible by 8.

Input: N = 6, arr[] = {2,  5, 3,  4, 6, 1}
Output: B[] = {0, 5, 1, 5, 5, 4}
Explanation: Since  prefix, the array is prefixXor[]={2, 7, 4, 0, 6, 7}, So, (2 ^ 0) + (7 ^ 5) + (4 ^ 1) + (0 ^ 5) + (6 ^ 5) + (7 ^ 4) = 2 + 2 + 5 + 5 + 3 + 3 = 20, which is even and divisible by 10.

Approach: Implement the idea below to solve the problem:

Let’s first analyze the question. The given sum should be even and should be divisible by the first N/2 elements. So more formally it means :

if array arr[] = {a, b, c, d},  then its prefix xor is Prefix_xor[]=[a, a^b, a^b^c, a^b^c^d}
Let assume array B[] = {x, y, z, w} then S= (x^a) + (y^(a^b)) + (z^(a^b^c)) + ( w^(a^b^c^d)). So according to the question:

• S%2 == 0 and
• S%(a+b) == 0

So on combining we get S % (2*(a + b)) == 0

Steps were taken to solve the problem:

• Initialize the pointer = 0 variable to iterate over array arr[].
• Calculate prefixXor[] array.
• Initialize array B[] of size N.
• While iterating over the array, if the difference == 2, increment the pointer, otherwise:
• Store arr[pointer] ^ prefixXor[i] in B[i].
• Increment difference by 1

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the approach` `#include ``using` `namespace` `std;` `// Function to generates valid array``// according to the given conditions``void` `valid_array_formation(``int` `N, ``int` `arr[])``{``    ``int` `prefix_xor[N] = { arr };` `    ``// Calculating the prefix xor array``    ``for` `(``int` `i = 1; i < N; i++) {``        ``prefix_xor[i] = prefix_xor[i - 1] ^ arr[i];``    ``}` `    ``int` `B[N] = { 0 };` `    ``// Pointer to extract which element``    ``// is to be extracted from array a``    ``int` `pointer = 0;` `    ``int` `difference = 0;` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// If difference becomes 2 then we``        ``// increment the pointer``        ``if` `(difference == 2) {``            ``pointer++;``            ``difference = 0;``        ``}` `        ``// B[i] i calculated accordingly``        ``B[i] = prefix_xor[i] ^ arr[pointer];``        ``difference++;``    ``}` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Printing the required array b``        ``cout << B[i] << ``" "``;``    ``}` `    ``cout << endl;``}` `// Driver code``int` `main()``{` `    ``// Test case 1``    ``int` `N = 4;``    ``int` `arr1[] = { 2, 6, 1, 5 };` `    ``// Function call``    ``valid_array_formation(N, arr1);` `    ``// Test case 2``    ``N = 6;``    ``int` `arr2[] = { 2, 5, 3, 4, 6, 1 };` `    ``// Function call``    ``valid_array_formation(N, arr2);` `    ``return` `0;``}`

## Java

 `// Java code to implement the approach``import` `java.util.*;` `class` `GFG {` `  ``// Function to generates valid array``  ``// according to the given conditions``  ``public` `static` `void` `valid_array_formation(``int` `N,``                                           ``int` `arr[])``  ``{``    ``int` `prefix_xor[] = ``new` `int``[N];``    ``prefix_xor[``0``] = arr[``0``];` `    ``// Calculating the prefix xor array``    ``for` `(``int` `i = ``1``; i < N; i++) {``      ``prefix_xor[i] = prefix_xor[i - ``1``] ^ arr[i];``    ``}` `    ``int` `B[] = ``new` `int``[N];` `    ``// Pointer to extract which element``    ``// is to be extracted from array a``    ``int` `pointer = ``0``;` `    ``int` `difference = ``0``;` `    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``// If difference becomes 2 then we``      ``// increment the pointer``      ``if` `(difference == ``2``) {``        ``pointer++;``        ``difference = ``0``;``      ``}` `      ``// B[i] i calculated accordingly``      ``B[i] = prefix_xor[i] ^ arr[pointer];``      ``difference++;``    ``}` `    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``// Printing the required array b``      ``System.out.print(B[i] + ``" "``);``    ``}` `    ``System.out.println();``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String args[])``  ``{` `    ``// Test case 1``    ``int` `N = ``4``;``    ``int` `arr1[] = { ``2``, ``6``, ``1``, ``5` `};` `    ``// Function call``    ``valid_array_formation(N, arr1);` `    ``// Test case 2``    ``N = ``6``;``    ``int` `arr2[] = { ``2``, ``5``, ``3``, ``4``, ``6``, ``1` `};` `    ``// Function call``    ``valid_array_formation(N, arr2);``  ``}``}` `// This Code is Contributed by Prasad Kandekar(prasad264)`

## Javascript

 `// Function to generates valid array``// according to the given conditions``function` `validArrayFormation(N, arr) {``  ``let prefixXor = [arr];` `  ``// Calculating the prefix xor array``  ``for` `(let i = 1; i < N; i++) {``    ``prefixXor.push(prefixXor[i - 1] ^ arr[i]);``  ``}` `  ``let B = Array(N).fill(0);` `  ``// Pointer to extract which element``  ``// is to be extracted from array a``  ``let pointer = 0;` `  ``let difference = 0;` `  ``for` `(let i = 0; i < N; i++) {``    ``// If difference becomes 2 then we``    ``// increment the pointer``    ``if` `(difference == 2) {``      ``pointer++;``      ``difference = 0;``    ``}` `    ``// B[i] i calculated accordingly``    ``B[i] = prefixXor[i] ^ arr[pointer];``    ``difference++;``  ``}` `  ``// Printing the required array b``  ``console.log(B.join(``" "``));``}` `// Test case 1``let N = 4;``let arr1 = [2, 6, 1, 5];` `// Function call``validArrayFormation(N, arr1);` `// Test case 2``N = 6;``let arr2 = [2, 5, 3, 4, 6, 1];` `// Function call``validArrayFormation(N, arr2);`

## Python3

 `# Function to generates valid array``# according to the given conditions``def` `valid_array_formation(N, arr):``    ``prefix_xor ``=` `[arr[``0``]]` `    ``# Calculating the prefix xor array``    ``for` `i ``in` `range``(``1``, N):``        ``prefix_xor.append(prefix_xor[i``-``1``] ^ arr[i])` `    ``B ``=` `[``0``] ``*` `N` `    ``# Pointer to extract which element``    ``# is to be extracted from array a``    ``pointer ``=` `0` `    ``difference ``=` `0` `    ``for` `i ``in` `range``(N):``        ``# If difference becomes 2 then we``        ``# increment the pointer``        ``if` `difference ``=``=` `2``:``            ``pointer ``+``=` `1``            ``difference ``=` `0` `        ``# B[i] i calculated accordingly``        ``B[i] ``=` `prefix_xor[i] ^ arr[pointer]``        ``difference ``+``=` `1` `    ``# Printing the required array b``    ``print``(``*``B)` `# Test case 1``N ``=` `4``arr1 ``=` `[``2``, ``6``, ``1``, ``5``]` `# Function call``valid_array_formation(N, arr1)` `# Test case 2``N ``=` `6``arr2 ``=` `[``2``, ``5``, ``3``, ``4``, ``6``, ``1``]` `# Function call``valid_array_formation(N, arr2)`

## C#

 `using` `System;` `public` `class` `Program``{``    ``// Function to generates valid array``    ``// according to the given conditions``    ``public` `static` `void` `ValidArrayFormation(``int` `N, ``int``[] arr)``    ``{``        ``int``[] prefixXor = ``new` `int``[N];``        ``prefixXor = arr;` `        ``// Calculating the prefix xor array``        ``for` `(``int` `i = 1; i < N; i++)``        ``{``            ``prefixXor[i] = prefixXor[i - 1] ^ arr[i];``        ``}` `        ``int``[] B = ``new` `int``[N];` `        ``// Pointer to extract which element``        ``// is to be extracted from array a``        ``int` `pointer = 0;` `        ``int` `difference = 0;` `        ``for` `(``int` `i = 0; i < N; i++)``        ``{``            ``// If difference becomes 2 then we``            ``// increment the pointer``            ``if` `(difference == 2)``            ``{``                ``pointer++;``                ``difference = 0;``            ``}` `            ``// B[i] i calculated accordingly``            ``B[i] = prefixXor[i] ^ arr[pointer];``            ``difference++;``        ``}` `        ``// Printing the required array b``        ``Console.WriteLine(``string``.Join(``" "``, B));``    ``}` `    ``public` `static` `void` `Main()``    ``{``        ``// Test case 1``        ``int` `N = 4;``        ``int``[] arr1 = ``new` `int``[] { 2, 6, 1, 5 };` `        ``// Function call``        ``ValidArrayFormation(N, arr1);` `        ``// Test case 2``        ``N = 6;``        ``int``[] arr2 = ``new` `int``[] { 2, 5, 3, 4, 6, 1 };` `        ``// Function call``        ``ValidArrayFormation(N, arr2);``    ``}``}`

Output

```0 6 3 6
0 5 1 5 5 4 ```

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

My Personal Notes arrow_drop_up