Quadruplet pair with XOR zero in the given Array

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++

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    Output:

    Yes
    

    Time Complexity:

  • 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 :

    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

    
    

    Output:

    Yes
    

    Time Complexity:



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.