# Quadruplet pair with XOR zero in the given Array

• Last Updated : 04 Jul, 2022

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 = 6
Input: 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 &leq; 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 ``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;``}`

## Java

 `// 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`

## Python3

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

## C#

 `// 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`

## PHP

 `= 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``?>`

## Javascript

 ``

Output:

`Yes`

• Time Complexity:

• Auxiliary Space: O(1)
• Another Efficient Approach (O(N2log N), for N &leq; 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

 `// 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> map = ``new` `HashMap<>();``        ` `        ``for``(``int` `i=``0``;i());``                ` `                ``List 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`

## Python3

 `# Python3 implementation of the approach``def` `check(arr):` `    ``n ``=` `len``(arr)``    ` `    ``# if n is less than 4, no quadruplet``    ``# can be possibly formed``    ``if``(n < ``4``):``        ``return` `False``    ``# if n >= 130, there is guaranteed``    ``# to be a quadruplet``    ``if``(n >``=``130``):``        ``return` `True``             ` `    ``# initializing a dictionary``    ``map` `=` `dict``()``    ` `    ``# building the map``    ``for` `i ``in` `range``(n ``-` `1``):``        ``for` `j ``in` `range``(i ``+` `1``, n):``            ``k ``=` `arr[i] ^ arr[j]``            ``if` `k ``not` `in` `map``:``                ``map``[k] ``=` `[]``            ``data ``=` `map``[k]``            ``if` `i ``not` `in` `data ``and` `j ``not` `in` `data:``                ``data.append(i)``                ``data.append(j)``                ` `                ``# if a  quadruplet has been found``                ``# return true``                ``if` `(``len``(data) >``=` `4``):``                    ``return` `True``                ``map``[k] ``=` `data` `    ``return` `False` `# Driver code``arr``=``[ ``1``, ``0``, ``2``, ``3``, ``7` `]``if` `(check(arr)):``    ``print``(``"Yes"``)``else``:``    ``print``(``"No"``)`  `# This code is contributed by phasing17`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `QuadrapuleXor {` `  ``// Function to check whether a quadruplet with XOR 0``  ``// exists in the given array``  ``static` `bool` `check(``int``[] arr)``  ``{``    ``int` `n = arr.Length;` `    ``if` `(n < 4)``      ``return` `false``;``    ``if` `(n >= 130)``      ``return` `true``;` `    ``Dictionary<``int``, List<``int``> > map``      ``= ``new` `Dictionary<``int``, List<``int``> >();` `    ``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[k] = ``new` `List<``int``>();` `        ``List<``int``> data = map[k];``        ``if` `(!data.Contains(i)``            ``&& !data.Contains(j)) {``          ``data.Add(i);``          ``data.Add(j);``          ``if` `(data.Count >= 4)``            ``return` `true``;``          ``map[k] = data;``        ``}``      ``}``    ``}``    ``return` `false``;``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int``[] arr = { 1, 0, 2, 3, 7 };` `    ``// Function Call``    ``if` `(check(arr))``      ``Console.WriteLine(``"Yes"``);``    ``else``      ``Console.WriteLine(``"No"``);``  ``}``}` `// This code is contributed by phasing17`

## Javascript

 ``

Output:

`Yes`

• Time Complexity:

Auxiliary Space: O(N2)

My Personal Notes arrow_drop_up