Make Array elements equal by replacing adjacent elements with their XOR
Last Updated :
11 Sep, 2021
Given an array A[] consisting of N integers, the task is to check if it is possible to reduce array of at least length 2 such that all the elements in the array are equal. In an operation, choose any index i, and replace A[i] and A[i+1] with their XOR value.
Example:
Input: A[] = {0, 2, 2}
Output: YES
Explanation: Apply the given operation for i=0 (zero based indexing). Therefore, replace A[0] and A[1] to A[0]^A[1] i.e., 0^2->2. The resulting array is {2, 2} having all the elements equal.
Input: A[] = {2, 3, 1, 10}
Output: NO
Explanation: There is no possible way for the array to have all equal elements
Naive Approach: The above problem can be solved using the observation that the given array can be reduced to an array with either two equal elements or three equal elements. Below are the steps by step approach to solve the above problem:
- Create a prefix array in which the ith index stores the XOR of elements from index 0 to i of the array A[].
- Case 1 where the array can be reduced to two equal elements
- Suppose the resulting array is {X, X}. Since the XOR of all elements of the array will remain constant, therefore X^X=0=XOR( A[0…N-1]). This case can be easily handled by checking if the XOR of all the elements of the array is 0.
- Case 2 where the array can be reduced to three equal elements
- This case can be handled by iterating over all the possible values of (i, j) such that 0<= i < j <=N-1 and check if there exist a value of (i, j) such that XOR(A[0…i]) = XOR(A[i+1…j]) = XOR(A[j+1…N]).
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void possibleEqualArray(int A[], int N)
{
vector<int> pref(N);
pref[0] = A[0];
for (int i = 1; i < N; i++) {
pref[i] = pref[i - 1] ^ A[i];
}
if (pref[N - 1] == 0) {
cout << "YES";
return;
}
int cur_xor = 0;
for (int i = N - 1; i >= 0; i--) {
cur_xor ^= A[i];
for (int j = 0; j < i; j++) {
if (j) {
int middle_xor
= pref[j - 1] ^ pref[i - 1];
int left_xor = pref[j - 1];
int right_xor = cur_xor;
if (left_xor == middle_xor
&& middle_xor == right_xor) {
cout << "YES";
return;
}
}
}
}
cout << "NO";
}
int main()
{
int A[] = { 0, 2, 2 };
int N = sizeof(A) / sizeof(int);
possibleEqualArray(A, N);
return 0;
}
|
Java
import java.io.*;
class GFG
{
static void possibleEqualArray(int A[], int N)
{
int[] pref= new int[N];
pref[0] = A[0];
for (int i = 1; i < N; i++) {
pref[i] = pref[i - 1] ^ A[i];
}
if (pref[N - 1] == 0) {
System.out.println("YES");
return;
}
int cur_xor = 0;
for (int i = N - 1; i >= 0; i--) {
cur_xor ^= A[i];
for (int j = 0; j < i; j++) {
if (j!=0) {
int middle_xor
= pref[j - 1] ^ pref[i - 1];
int left_xor = pref[j - 1];
int right_xor = cur_xor;
if (left_xor == middle_xor
&& middle_xor == right_xor) {
System.out.println( "YES");
return;
}
}
}
}
System.out.println( "NO");
}
public static void main (String[] args)
{
int A[] = { 0, 2, 2 };
int N = A.length;
possibleEqualArray(A, N);
}
}
|
Python3
def possibleEqualArray(A, N):
pref = [0 for i in range(N)]
pref[0] = A[0]
for i in range(1, N, 1):
pref[i] = pref[i - 1] ^ A[i]
if (pref[N - 1] == 0):
print("YES")
return
cur_xor = 0
i = N - 1
while(i >= 0):
cur_xor ^= A[i]
for j in range(i):
if (j):
middle_xor = pref[j - 1] ^ pref[i - 1]
left_xor = pref[j - 1]
right_xor = cur_xor
if (left_xor == middle_xor and middle_xor == right_xor):
print("YES")
return
i -= 1
print("NO")
if __name__ == '__main__':
A = [0, 2, 2]
N = len(A)
possibleEqualArray(A, N)
|
C#
using System;
public class GFG
{
static void possibleEqualArray(int []A, int N)
{
int[] pref= new int[N];
pref[0] = A[0];
for (int i = 1; i < N; i++) {
pref[i] = pref[i - 1] ^ A[i];
}
if (pref[N - 1] == 0) {
Console.WriteLine("YES");
return;
}
int cur_xor = 0;
for (int i = N - 1; i >= 0; i--) {
cur_xor ^= A[i];
for (int j = 0; j < i; j++) {
if (j!=0) {
int middle_xor
= pref[j - 1] ^ pref[i - 1];
int left_xor = pref[j - 1];
int right_xor = cur_xor;
if (left_xor == middle_xor
&& middle_xor == right_xor) {
Console.WriteLine( "YES");
return;
}
}
}
}
Console.WriteLine( "NO");
}
public static void Main(String[] args)
{
int []A = { 0, 2, 2 };
int N = A.Length;
possibleEqualArray(A, N);
}
}
|
Javascript
<script>
function possibleEqualArray(A, N) {
let pref = new Array(N);
pref[0] = A[0];
for (let i = 1; i < N; i++) {
pref[i] = pref[i - 1] ^ A[i];
}
if (pref[N - 1] == 0) {
document.write("YES");
return;
}
let cur_xor = 0;
for (let i = N - 1; i >= 0; i--) {
cur_xor ^= A[i];
for (let j = 0; j < i; j++) {
if (j) {
let middle_xor = pref[j - 1] ^ pref[i - 1];
let left_xor = pref[j - 1];
let right_xor = cur_xor;
if (left_xor == middle_xor && middle_xor == right_xor) {
document.write("YES");
return;
}
}
}
}
document.write("NO");
}
let A = [0, 2, 2];
let N = A.length;
possibleEqualArray(A, N);
</script>
|
Time Complexity: O(N2)
Space Complexity: O(N)
Efficient Approach: The above approach can be optimized using the observation that in the case where the array can be reduced to the three equal elements, the resultant array can be represented as {X, X, X}. Since, (X^X^X) = XOR(A[0…N-1]) it implies that X = XOR(A[0…N-1]). Case 1 can be handled the same as that of the naive approach. Case 2 can be solved as follows:
- Initialize cnt and cur_XOR by 0, and store the XOR of all elements of A[] in tot_XOR.
- Iterate over array A[] and keep track of the XOR till the current element in cur_XOR.
- If cur_XOR = tot_XOR, increment the cnt by 1 and initialize cur_XOR = 0.
- After traversing the whole array, if the value of cnt > 2, it is possible to make all the elements of the array equal using the given operation.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void possibleEqualArray(int A[], int N)
{
int tot_XOR = 0;
for (int i = 0; i < N; i++) {
tot_XOR ^= A[i];
}
if (tot_XOR == 0) {
cout << "YES";
return;
}
int cur_XOR = 0;
int cnt = 0;
for (int i = 0; i < N; i++) {
cur_XOR ^= A[i];
if (cur_XOR == tot_XOR) {
cnt++;
cur_XOR = 0;
}
}
if (cnt > 2) {
cout << "YES";
}
else {
cout << "NO";
}
}
int main()
{
int A[] = { 0, 2, 2 };
int N = sizeof(A) / sizeof(int);
possibleEqualArray(A, N);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void possibleEqualArray(int A[], int N)
{
int tot_XOR = 0;
for (int i = 0; i < N; i++) {
tot_XOR ^= A[i];
}
if (tot_XOR == 0) {
System.out.print("YES");
return;
}
int cur_XOR = 0;
int cnt = 0;
for (int i = 0; i < N; i++) {
cur_XOR ^= A[i];
if (cur_XOR == tot_XOR) {
cnt++;
cur_XOR = 0;
}
}
if (cnt > 2) {
System.out.print("YES");
}
else {
System.out.print("NO");
}
}
public static void main(String[] args)
{
int A[] = { 0, 2, 2 };
int N =( A.length);
possibleEqualArray(A, N);
}
}
|
Python3
def possibleEqualArray(A, N):
tot_XOR = 0
for i in range(N):
tot_XOR ^= A[i]
if (tot_XOR == 0):
print("YES")
return
cur_XOR = 0
cnt = 0
for i in range(N):
cur_XOR ^= A[i]
if (cur_XOR == tot_XOR):
cnt += 1
cur_XOR = 0
if (cnt > 2):
print("YES")
else:
print("NO")
if __name__ == '__main__':
A = [0, 2, 2]
N = len(A)
possibleEqualArray(A, N)
|
C#
using System;
class GFG{
static void possibleEqualArray(int []A, int N)
{
int tot_XOR = 0;
for (int i = 0; i < N; i++) {
tot_XOR ^= A[i];
}
if (tot_XOR == 0) {
Console.Write("YES");
return;
}
int cur_XOR = 0;
int cnt = 0;
for (int i = 0; i < N; i++) {
cur_XOR ^= A[i];
if (cur_XOR == tot_XOR) {
cnt++;
cur_XOR = 0;
}
}
if (cnt > 2) {
Console.Write("YES");
}
else {
Console.Write("NO");
}
}
public static void Main(String[] args)
{
int []A = { 0, 2, 2 };
int N =( A.Length);
possibleEqualArray(A, N);
}
}
|
Javascript
<script>
function possibleEqualArray( A, N)
{
var tot_XOR = 0;
for (var i = 0; i < N; i++) {
tot_XOR ^= A[i];
}
if (tot_XOR == 0) {
document.write("YES");
return;
}
var cur_XOR = 0;
var cnt = 0;
for (var i = 0; i < N; i++) {
cur_XOR ^= A[i];
if (cur_XOR == tot_XOR) {
cnt++;
cur_XOR = 0;
}
}
if (cnt > 2) {
document.write("YES");
}
else {
document.write("NO");
}
}
var A = [ 0, 2, 2 ];
var N =( A.length);
possibleEqualArray(A, N);
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...