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 N⁴, for all N.

  Time Complexity:

  
  
  
  

  

• Efficient Approach (O(N⁴), 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++

  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

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

  filter_none

  Java

  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

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

  filter_none

  Python3

  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

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

  filter_none

  C#

  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

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

  filter_none

  PHP

  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  <?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_right

  filter_none

  Output:

  Yes
  

  Time Complexity:

  

• Another Efficient Approach (O(N²log 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 :

  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

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

  filter_none

  Output:

  Yes
  

  Time Complexity:

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.