Given an array arr[] of N integers such that any two adjacent elements in the array differ at only one position in their binary representation. The task is to find whether there exists a quadruple (arr[i], arr[j], arr[k], arr[l]) such that arr[i] ^ arr[j] ^ arr[k] ^ arr[l] = 0. Here ^ denotes the bitwise xor operation and 1 ≤ i < j < k < l ≤ N.
Examples:
Input: arr[] = {1, 3, 7, 3}
Output: No
1 ^ 3 ^ 7 ^ 3 = 6Input: arr[] = {1, 0, 2, 3, 7}
Output: Yes
1 ^ 0 ^ 2 ^ 3 = 0
- Naive approach: Check for all possible quadruples whether their xor is zero or not. But the time complexity of such a solution would be N4, for all N.
Time Complexity:
- Efficient Approach (O(N4), for N ≤ 130): We can Say that for array length more than or equal to 130 we can have at least 65 adjacent pairs each denoting xor of two elements. Here it is given that all adjacent elements differ at only one position in their binary form thus there would result in only one set bit. Since we have only 64 possible positions, we can say that at least two pairs will have the same xor. Thus xor of these 4 integers will be 0. For N < 130 we can use the naive approach.
Below is the implementation of the above approach:
C++
// C++ implementation of the approach
#include <bits/stdc++.h>
using
namespace
std;
const
int
MAX = 130;
// Function that returns true if the array
// contains a valid quadruplet pair
bool
validQuadruple(
int
arr[],
int
n)
{
// We can always find a valid quadruplet pair
// for array size greater than MAX
if
(n >= MAX)
return
true
;
// For smaller size arrays, perform brute force
for
(
int
i = 0; i < n; i++)
for
(
int
j = i + 1; j < n; j++)
for
(
int
k = j + 1; k < n; k++)
for
(
int
l = k + 1; l < n; l++) {
if
((arr[i] ^ arr[j] ^ arr[k] ^ arr[l]) == 0) {
return
true
;
}
}
return
false
;
}
// Driver code
int
main()
{
int
arr[] = { 1, 0, 2, 3, 7 };
int
n =
sizeof
(arr) /
sizeof
(arr[0]);
if
(validQuadruple(arr, n))
cout <<
"Yes"
;
else
cout <<
"No"
;
return
0;
}
chevron_rightfilter_noneJava
// Java implementation of the approach
import
java.util.*;
import
java.lang.*;
import
java.io.*;
class
GFG
{
static
int
MAX =
130
;
// Function that returns true if the array
// contains a valid quadruplet pair
static
boolean
validQuadruple(
int
arr[],
int
n)
{
// We can always find a valid quadruplet pair
// for array size greater than MAX
if
(n >= MAX)
return
true
;
// For smaller size arrays, perform brute force
for
(
int
i =
0
; i < n; i++)
for
(
int
j = i +
1
; j < n; j++)
for
(
int
k = j +
1
; k < n; k++)
for
(
int
l = k +
1
; l < n; l++)
{
if
((arr[i] ^ arr[j] ^
arr[k] ^ arr[l]) ==
0
)
{
return
true
;
}
}
return
false
;
}
// Driver code
public
static
void
main (String[] args)
throws
java.lang.Exception
{
int
arr[] = {
1
,
0
,
2
,
3
,
7
};
int
n = arr.length;
if
(validQuadruple(arr, n))
System.out.println(
"Yes"
);
else
System.out.println(
"No"
);
}
}
// This code is contributed by nidhiva
chevron_rightfilter_nonePython3
# Python3 implementation of the approach
MAX
=
130
# Function that returns true if the array
# contains a valid quadruplet pair
def
validQuadruple(arr, n):
# We can always find a valid quadruplet pair
# for array size greater than MAX
if
(n >
=
MAX
):
return
True
# For smaller size arrays,
# perform brute force
for
i
in
range
(n):
for
j
in
range
(i
+
1
, n):
for
k
in
range
(j
+
1
, n):
for
l
in
range
(k
+
1
, n):
if
((arr[i] ^ arr[j] ^
arr[k] ^ arr[l])
=
=
0
):
return
True
return
False
# Driver code
arr
=
[
1
,
0
,
2
,
3
,
7
]
n
=
len
(arr)
if
(validQuadruple(arr, n)):
print
(
"Yes"
)
else
:
print
(
"No"
)
# This code is contributed
# by Mohit Kumar
chevron_rightfilter_noneC#
// C# implementation of the approach
using
System;
class
GFG
{
static
int
MAX = 130;
// Function that returns true if the array
// contains a valid quadruplet pair
static
Boolean validQuadruple(
int
[]arr,
int
n)
{
// We can always find a valid quadruplet pair
// for array size greater than MAX
if
(n >= MAX)
return
true
;
// For smaller size arrays, perform brute force
for
(
int
i = 0; i < n; i++)
for
(
int
j = i + 1; j < n; j++)
for
(
int
k = j + 1; k < n; k++)
for
(
int
l = k + 1; l < n; l++)
{
if
((arr[i] ^ arr[j] ^
arr[k] ^ arr[l]) == 0)
{
return
true
;
}
}
return
false
;
}
// Driver code
public
static
void
Main (String[] args)
{
int
[]arr = { 1, 0, 2, 3, 7 };
int
n = arr.Length;
if
(validQuadruple(arr, n))
Console.WriteLine(
"Yes"
);
else
Console.WriteLine(
"No"
);
}
}
// This code is contributed by 29AjayKumar
chevron_rightfilter_nonePHP
<?php
// PHP implementation of the approach
const
MAX = 130;
// Function that returns true if the array
// contains a valid quadruplet pair
function
validQuadruple(
$arr
,
$n
)
{
// We can always find a valid quadruplet pair
// for array size greater than MAX
if
(
$n
>= MAX)
return
true;
// For smaller size arrays,
// perform brute force
for
(
$i
= 0;
$i
<
$n
;
$i
++)
for
(
$j
=
$i
+ 1;
$j
<
$n
;
$j
++)
for
(
$k
=
$j
+ 1;
$k
<
$n
;
$k
++)
for
(
$l
=
$k
+ 1;
$l
<
$n
;
$l
++)
{
if
((
$arr
[
$i
] ^
$arr
[
$j
] ^
$arr
[
$k
] ^
$arr
[
$l
]) == 0)
{
return
true;
}
}
return
false;
}
// Driver code
$arr
=
array
(1, 0, 2, 3, 7);
$n
=
count
(
$arr
);
if
(validQuadruple(
$arr
,
$n
))
echo
(
"Yes"
);
else
echo
(
"No"
);
// This code is contributed by Naman_Garg
?>
chevron_rightfilter_noneOutput:Yes
Time Complexity:
- Another Efficient Approach (O(N2log N), for N ≤ 130):
Compute Xor of all pairs and hash it. ie, store indexes i and j in a list and Hash it in form <xor, list>. If the same xor is found again for different i and j, then we have a Quadruplet pair.Below is the implementation of the above approach :
// Java implementation of the approach
import
java.util.HashMap;
import
java.util.LinkedList;
import
java.util.List;
import
java.util.Map;
public
class
QuadrapuleXor {
static
boolean
check(
int
arr[])
{
int
n = arr.length;
if
(n <
4
)
return
false
;
if
(n >=
130
)
return
true
;
Map<Integer,List<Integer>> map =
new
HashMap<>();
for
(
int
i=
0
;i<n-
1
;i++)
{
for
(
int
j=i+
1
;j<n;j++)
{
int
k = arr[i] ^ arr[j];
if
(!map.containsKey(k))
map.put(k,
new
LinkedList<>());
List<Integer> data = map.get(k);
if
(!data.contains(i) && !data.contains(j))
{
data.add(i);
data.add(j);
if
(data.size()>=
4
)
return
true
;
map.put(k, data);
}
}
}
return
false
;
}
// Driver code
public
static
void
main (String[] args)
throws
java.lang.Exception
{
int
arr[] = {
1
,
0
,
2
,
3
,
7
};
if
(check(arr))
System.out.println(
"Yes"
);
else
System.out.println(
"No"
);
}
}
//This code contributed by Pramod Hosahalli
chevron_rightfilter_noneOutput:Yes
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.