# Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR

Given an array arr[] of size N, the task is to replace a pair of array elements whose Bitwise XOR is even by their Bitwise XOR. Repeat the above step as long as possible. Finally, print the count of such operations performed on the array

Examples:

Input: arr[] = { 4, 6, 1, 3 }
Output: 3
Explanation:
Step 1: Remove the pair (4, 6) and replace them by their XOR value (= 2) in the array. Therefore, the array arr[] modifies to {2, 1, 3}.
Step 2: Remove the pair (1, 3) and replace them by their XOR value (= 2) in the array, modifies the array as arr[] = {2, 2}.
At last select the pair (2, 2) and then remove the pair and insert the xor of 2 and 2 in the array which modifies the array as arr[] ={0}.
Now no other pair can be chosen therefore 3 is the maximum number of pairs whose Xor is even.

Input: arr[ ] = { 1, 2, 3, 4, 5 }
Output: 3

Naive Approach: The simplest approach to solve this problem is to find all possible pairs of the array and for each pair, check if their Bitwise XOR is even or not. If found to be true, then increment the count of pairs and remove both the elements from the array and add their XOR to the array. Repeat the above steps until no more pairs can be selected. Print the count of operations performed.

## C++

 `#include ``#include ``using` `namespace` `std;` `// Function to check if the bitwise XOR of two elements is``// even``bool` `isEvenXOR(``int` `a, ``int` `b) { ``return` `!((a ^ b) & 1); }` `int` `replacePair(vector<``int``>& arr)``{``    ``int` `operations = 0;``    ``bool` `replaced = ``true``;` `    ``while` `(replaced) {``        ``replaced = ``false``;``        ``int` `first, second;` `        ``for` `(``int` `i = 0; i < arr.size() - 1; i++) {``            ``for` `(``int` `j = i + 1; j < arr.size(); j++) {` `                ``if` `(isEvenXOR(arr[i], arr[j])) {``                    ``first = i;``                    ``second = j;``                    ``replaced = ``true``;``                    ``operations++;``                    ``break``;``                ``}``            ``}``            ``if` `(replaced)``                ``break``;``        ``}``        ``if` `(replaced) {``            ``int` `xorr = arr[first] ^ arr[second];``            ``arr.erase(arr.begin() + first);``            ``arr.erase(arr.begin() + second - 1);``            ``arr.push_back(xorr);``        ``}``    ``}``    ``return` `operations;``}` `int` `main()``{``    ``vector<``int``> arr = { 1,2,3,4,5 };``    ``int` `operations = replacePair(arr);``    ``cout << ``"Operations performed: "` `<< operations << endl;``    ``for` `(``int` `i = 0; i < arr.size(); i++) {``        ``cout << arr[i] << ``" "``;``    ``}``    ``return` `0;``}`

## Java

 `import` `java.util.ArrayList;``import` `java.util.List;` `class` `Main {``    ``// Function to check if the bitwise XOR of two elements is``    ``// even``    ``public` `static` `boolean` `isEvenXOR(``int` `a, ``int` `b) { ``return` `(a ^ b) % ``2` `== ``0``; }` `    ``public` `static` `int` `replacePair(List arr) {``        ``int` `operations = ``0``;``        ``boolean` `replaced = ``true``;` `        ``while` `(replaced) {``            ``replaced = ``false``;``            ``int` `first = ``0``, second = ``0``;` `            ``for` `(``int` `i = ``0``; i < arr.size() - ``1``; i++) {``                ``for` `(``int` `j = i + ``1``; j < arr.size(); j++) {` `                    ``if` `(isEvenXOR(arr.get(i), arr.get(j))) {``                        ``first = i;``                        ``second = j;``                        ``replaced = ``true``;``                        ``operations++;``                        ``break``;``                    ``}``                ``}``                ``if` `(replaced)``                    ``break``;``            ``}``            ``if` `(replaced) {``                ``int` `xorr = arr.get(first) ^ arr.get(second);``                ``arr.remove(first);``                ``arr.remove(second - ``1``);``                ``arr.add(xorr);``            ``}``        ``}``        ``return` `operations;``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``List arr = ``new` `ArrayList<>();``        ``arr.add(``1``);``        ``arr.add(``2``);``        ``arr.add(``3``);``        ``arr.add(``4``);``        ``arr.add(``5``);``        ``int` `operations = replacePair(arr);``        ``System.out.println(``"Operations performed: "` `+ operations);``        ``for` `(``int` `i = ``0``; i < arr.size(); i++) {``            ``System.out.print(arr.get(i) + ``" "``);``        ``}``    ``}``}`

## Python3

 `def` `is_even_xor(a, b): ``    ``return` `(a ^ b) ``%` `2` `=``=` `0` `def` `replace_pair(arr): ``    ``operations ``=` `0``    ``replaced ``=` `True` `    ``while` `replaced: ``        ``replaced ``=` `False``        ``first ``=` `0``        ``second ``=` `0` `        ``for` `i ``in` `range``(``len``(arr) ``-` `1``): ``            ``for` `j ``in` `range``(i ``+` `1``, ``len``(arr)): ` `                ``if` `is_even_xor(arr[i], arr[j]): ``                    ``first ``=` `i``                    ``second ``=` `j``                    ``replaced ``=` `True``                    ``operations ``+``=` `1``                    ``break``            ``if` `replaced: ``                ``break``        ``if` `replaced: ``            ``xorr ``=` `arr[first] ^ arr[second]``            ``arr.pop(first)``            ``arr.pop(second ``-` `1``)``            ``arr.append(xorr)``    ``return` `operations` `arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``] ``operations ``=` `replace_pair(arr) ``print``(``"Operations performed:"``, operations) ``for` `i ``in` `range``(``len``(arr)): ``    ``print``(arr[i], end``=``" "``)`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``    ``// Function to check if the bitwise XOR of two elements is``    ``// even``    ``static` `bool` `isEvenXOR(``int` `a, ``int` `b) ``    ``{ ``        ``return` `((a ^ b) & 1)==0;``    ``}``    ` `    ``static` `int` `replacePair(List<``int``> arr)``    ``{``        ``int` `operations = 0;``        ``bool` `replaced = ``true``;``    ` `        ``while` `(replaced) {``            ``replaced = ``false``;``            ``int` `first=0, second=0;``    ` `            ``for` `(``int` `i = 0; i < arr.Count - 1; i++) {``                ``for` `(``int` `j = i + 1; j < arr.Count; j++) {``    ` `                    ``if` `(isEvenXOR(arr[i], arr[j])) {``                        ``first = i;``                        ``second = j;``                        ``replaced = ``true``;``                        ``operations++;``                        ``break``;``                    ``}``                ``}``                ``if` `(replaced)``                    ``break``;``            ``}``            ``if` `(replaced) {``                ``int` `xorr = arr[first] ^ arr[second];``                ``arr.Remove(arr[first]);``                ``arr.Remove(arr[second - 1]);``                ``arr.Add(xorr);``            ``}``        ``}``        ``return` `operations;``    ``}``    ` `    ``static` `void` `Main(``string``[] args)``    ``{``        ``List<``int``> arr = ``new` `List<``int``>{ 1,2,3,4,5 };``        ``int` `operations = replacePair(arr);``        ``Console.WriteLine(``"Operations performed: "` `+ operations);``        ``for` `(``int` `i = 0; i < arr.Count; i++) {``            ``Console.Write(arr[i]+``" "``);``        ``}``    ``}``}`

## Javascript

 `// JavaScript code to implement above approach` `// Function to check if the bitwise XOR of two elements is``// even``function` `isEvenXOR(a, b) {``  ``return` `(a ^ b) % 2 === 0;``}` `function` `replacePair(arr) {``  ``let operations = 0;``  ``let replaced = ``true``;` `  ``while` `(replaced) {``    ``replaced = ``false``;``    ``let first = 0,``      ``second = 0;` `    ``for` `(let i = 0; i < arr.length - 1; i++) {``      ``for` `(let j = i + 1; j < arr.length; j++) {``        ``if` `(isEvenXOR(arr[i], arr[j])) {``          ``first = i;``          ``second = j;``          ``replaced = ``true``;``          ``operations++;``          ``break``;``        ``}``      ``}``      ``if` `(replaced) ``break``;``    ``}``    ``if` `(replaced) {``      ``let xorr = arr[first] ^ arr[second];``      ``arr.splice(first, 1);``      ``arr.splice(second - 1, 1);``      ``arr.push(xorr);``    ``}``  ``}``  ``return` `operations;``}` `// Driver code``let arr = [1, 2, 3, 4, 5];``let operations = replacePair(arr);``console.log(``"Operations performed: "` `+ operations);``console.log(arr);``// this code is contributed by devendra salunke`

Output
```Operations performed: 3
5 4 ```

Time Complexity: O(N2), as we have to use nested loops to traverse N3 times.
Auxiliary Space: O(1), as we are not using any extra space.

Efficient Approach: The above approach can be optimized based on the following observations:

• Even ^ Even = Even
• Odd ^ Odd = Even
• The total number of pairs that can be formed from only odd numbers satisfying the conditions is odd / 2.
• The total numbers of pairs that can be formed from only even numbers satisfying the conditions is even – 1.

Follow the steps below to solve the problem:

1. Traverse the array.
2. Count the frequency of odd numbers and store it in a variable, say odd.
3. The total number of pairs with even XOR that can be formed from all the odd array elements is floor(odd / 2).
4. Deleting the formed pairs in the above step and replacing them with their XOR values respectively, increases the count of even elements by floor(odd / 2).
5. Finally, print the count of pairs that can be formed with even XOR as (N – odd + odd/2 -1) + odd / 2.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement the above approach``#include ``using` `namespace` `std;` `// Function to maximize the count``// of pairs with even XOR possible``// in an array by given operations``int` `countPairs(``int` `arr[], ``int` `N)``{``    ``// Stores count of odd``    ``// array elements``    ``int` `odd = 0;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// If arr[i] is odd``        ``if` `(arr[i] & 1)``            ``odd++;``    ``}` `    ``// Stores the total number``    ``// of even pairs``    ``int` `ans = (N - odd + odd / 2``               ``- 1)``              ``+ odd / 2;` `    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``// Input``    ``int` `arr[] = { 4, 6, 1, 3 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Function call to count the number``    ``// of pairs whose XOR is even``    ``cout << countPairs(arr, N);` `    ``return` `0;``}`

## C

 `// C program to implement the above approach``#include ` `// Function to maximize the count``// of pairs with even XOR possible``// in an array by given operations``int` `countPairs(``int` `arr[], ``int` `N)``{``  ``// Stores count of odd``  ``// array elements``  ``int` `odd = 0;` `  ``// Traverse the array``  ``for` `(``int` `i = 0; i < N; i++) {` `    ``// If arr[i] is odd``    ``if` `(arr[i] & 1)``      ``odd++;``  ``}` `  ``// Stores the total number``  ``// of even pairs``  ``int` `ans = (N - odd + odd / 2``             ``- 1)``    ``+ odd / 2;` `  ``return` `ans;``}` `// Driver Code``int` `main()``{``  ``// Input``  ``int` `arr[] = { 4, 6, 1, 3 };``  ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `  ``// Function call to count the number``  ``// of pairs whose XOR is even``  ``printf``(``"%d\n"``, countPairs(arr, N));` `  ``return` `0;``}` `// This code is contributed by phalashi.`

## Python3

 `# Python3 program to implement the above approach` `# Function to maximize the count``# of pairs with even XOR possible``# in an array by given operations``def` `countPairs(arr, N):``  ` `    ``# Stores count of odd``    ``# array elements``    ``odd ``=` `0` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):` `        ``# If arr[i] is odd``        ``if` `(arr[i] & ``1``):``            ``odd ``+``=` `1` `    ``# Stores the total number``    ``# of even pairs``    ``ans ``=` `(N ``-` `odd ``+` `odd ``/``/` `2` `-` `1``) ``+` `odd ``/``/` `2` `    ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `  ``# Input``    ``arr ``=``[``4``, ``6``, ``1``, ``3``]``    ``N ``=` `len``(arr)` `    ``# Function call to count the number``    ``# of pairs whose XOR is even``    ``print` `(countPairs(arr, N))` `    ``# This code is contributed by mohit kumar 29.`

## Java

 `// Java program to implement the above approach``public` `class` `GFG``{` `  ``// Function to maximize the count``  ``// of pairs with even XOR possible``  ``// in an array by given operations``  ``static` `int` `countPairs(``int` `[]arr, ``int` `N)``  ``{` `    ``// Stores count of odd``    ``// array elements``    ``int` `odd = ``0``;` `    ``// Traverse the array``    ``for` `(``int` `i = ``0``; i < N; i++) ``    ``{` `      ``// If arr[i] is odd``      ``if` `((arr[i] & ``1``)!=``0``)``        ``odd++;``    ``}` `    ``// Stores the total number``    ``// of even pairs``    ``int` `ans = (N - odd + odd / ``2``               ``- ``1``)``      ``+ odd / ``2``;` `    ``return` `ans;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String args[])``  ``{` `    ``// Input``    ``int` `[]arr = { ``4``, ``6``, ``1``, ``3` `};``    ``int` `N = arr.length;` `    ``// Function call to count the number``    ``// of pairs whose XOR is even``    ``System.out.println(countPairs(arr, N));``  ``}``}` `// This code is contributed by AnkThon.`

## C#

 `// C# program to implement the above approach``using` `System;``class` `GFG``{` `// Function to maximize the count``// of pairs with even XOR possible``// in an array by given operations``static` `int` `countPairs(``int` `[]arr, ``int` `N)``{``  ` `    ``// Stores count of odd``    ``// array elements``    ``int` `odd = 0;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) ``    ``{` `        ``// If arr[i] is odd``        ``if` `((arr[i] & 1)!=0)``            ``odd++;``    ``}` `    ``// Stores the total number``    ``// of even pairs``    ``int` `ans = (N - odd + odd / 2``               ``- 1)``              ``+ odd / 2;` `    ``return` `ans;``}` `// Driver Code``public` `static` `void` `Main()``{``  ` `    ``// Input``    ``int` `[]arr = { 4, 6, 1, 3 };``    ``int` `N = arr.Length;` `    ``// Function call to count the number``    ``// of pairs whose XOR is even``    ``Console.Write(countPairs(arr, N));``}``}` `// This code is contributed by SURENDRA_GANGWAR.`

## Javascript

 ``

Output:
`3`

Time Complexity: O(N), as we are using a loop to traverse N times.
Auxiliary Space: O(1), as we are not using any extra space.

Previous
Next