Related Articles

# Count all Quadruples from four arrays such that their XOR equals to ‘x’

• Difficulty Level : Medium
• Last Updated : 06 Jul, 2021

Given four arrays and an integer x, find the number of quadruples which satisfy a^b^c^d = x, where a belongs from Arr1, b belongs from Arr2, c belongs from Arr3, d belongs from Arr4.

Examples :

```Input :  x = 0;
a[] = { 1 , 10 };
b[] = { 1 , 10 };
c[] = { 1 , 10 };
d[] = { 1 , 10 };
Output : 4
Explanation: There are total 8 Quadruples
with XOR value equals to 0.
{1, 1, 1, 1}, {10, 10, 10, 10}, {1, 1, 10, 10},
{10, 10, 1, 1}, {10, 1, 10, 1}, {1, 10, 1, 10},
{1, 10, 10, 1}, {10, 1, 1, 10}

Input : x = 3
a[] = {0, 1}
b[] = {2, 0}
c[] = {0, 1}
d[] = {0, 1}
Output : 4
Explanation: There are total 4 Quadruples
with XOR value equals to 3.
{0, 2, 0, 1}, {1, 2, 0, 0}, {0, 2, 1, 0},
{1, 2, 1, 1}```

Method 1(Naive approach)
It can be done using 4 loops, covering every quadruple and checking whether it is equal to x or not.

## C++

 `// C++ program to find number of Quadruples from four``// arrays such that their XOR equals to 'x'``#include``using` `namespace` `std;` `// Function to return the number of Quadruples with XOR``// equals to x such that every element of Quadruple is``// from different array.``int` `findQuadruples(``int` `a[], ``int` `b[], ``int` `c[], ``int` `d[],``                    ``int` `x, ``int` `n)``{``    ``int` `count = 0;``    ``for` `(``int` `i = 0 ; i < n ; i++)``        ``for` `(``int` `j = 0 ; j < n ; j++)``            ``for` `(``int` `k = 0 ; k < n ; k++)``                ``for` `(``int` `l = 0 ; l < n ; l++)` `                    ``// Check whether XOR is equal to x``                    ``if` `((a[i] ^ b[j] ^ c[k] ^ d[l]) == x)``                        ``count++;` `    ``return` `count;``}` `// Driver Program``int` `main()``{``    ``int` `x = 3;``    ``int` `a[] = {0, 1};``    ``int` `b[] = {2, 0};``    ``int` `c[] = {0, 1};``    ``int` `d[] = {0, 1};` `    ``int` `n = ``sizeof``(a)/``sizeof``(a[0]);` `    ``cout << findQuadruples(a, b, c, d, x, n) << endl;` `    ``return` `0;``}`

## Java

 `// Java program to find number of Quadruples from four``// arrays such that their XOR equals to 'x'``class` `GFG {``    ` `    ``// Function to return the number of Quadruples with XOR``    ``// equals to x such that every element of Quadruple is``    ``// from different array.``    ``static` `int` `findQuadruples(``int` `a[], ``int` `b[], ``int` `c[],``                                ``int` `d[], ``int` `x, ``int` `n)``    ``{``        ``int` `count = ``0``;``        ``for` `(``int` `i = ``0` `; i < n ; i++)``            ``for` `(``int` `j = ``0` `; j < n ; j++)``                ``for` `(``int` `k = ``0` `; k < n ; k++)``                    ``for` `(``int` `l = ``0` `; l < n ; l++)``    ` `                        ``// Check whether XOR is equal to x``                        ``if` `((a[i] ^ b[j] ^ c[k] ^ d[l]) == x)``                            ``count++;``    ` `        ``return` `count;``    ``}``    ` `    ``// Driver method``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `x = ``3``;``        ``int` `a[] = {``0``, ``1``};``        ``int` `b[] = {``2``, ``0``};``        ``int` `c[] = {``0``, ``1``};``        ``int` `d[] = {``0``, ``1``};``    ` `        ``int` `n = a.length;``    ` `        ``System.out.println(findQuadruples(a, b, c, d, x, n));``    ``}``}` `// This code is contributed by Anant Agarwal.`

## Python3

 `# Python3 program to find number of``# Quadruples from four arrays such``# that their XOR equals to 'x'` `# Function to return the number of``# Quadruples with XOR equals to x``# such that every element of Quadruple``# is from different array.``def` `findQuadruples(a, b, c, d, x, n):` `    ``count ``=` `0``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(n):``            ``for` `k ``in` `range``(n):``                ``for` `l ``in` `range``(n):` `                    ``# Check whether XOR is equal to x``                    ``if` `((a[i] ^ b[j] ^ c[k] ^ d[l]) ``=``=` `x):``                        ``count ``+``=` `1``    ``return` `count` `# Driver Code``x ``=` `3``a ``=` `[``0``, ``1``]``b ``=` `[``2``, ``0``]``c ``=` `[``0``, ``1``]``d ``=` `[``0``, ``1``]``n ``=` `len``(a)``print``(findQuadruples(a, b, c, d, x, n))` `# This code is contributed by Anant Agarwal.`

## C#

 `// C# program to find number of``// Quadruples from four arrays such``// that their XOR equals to 'x'``using` `System;` `class` `GFG {``    ` `    ``// Function to return the number of``    ``// Quadruples with XOR equals to x such that``    ``// every element of Quadruple is from different array.``    ``static` `int` `findQuadruples(``int` `[]a, ``int` `[]b, ``int` `[]c,``                                ``int` `[]d, ``int` `x, ``int` `n)``    ``{``        ``int` `count = 0;``        ``for` `(``int` `i = 0; i < n; i++)``            ``for` `(``int` `j = 0; j < n; j++)``                ``for` `(``int` `k = 0; k < n; k++)``                    ``for` `(``int` `l = 0; l < n; l++)``    ` `                        ``// Check whether XOR is equal to x``                        ``if` `((a[i] ^ b[j] ^ c[k] ^ d[l]) == x)``                            ``count++;``    ` `        ``return` `count;``    ``}``    ` `    ``// Driver method``    ``public` `static` `void` `Main()``    ``{``        ``int` `x = 3;``        ``int` `[]a = {0, 1};``        ``int` `[]b = {2, 0};``        ``int` `[]c = {0, 1};``        ``int` `[]d = {0, 1};``    ` `        ``int` `n = a.Length;``        ` `        ``// Function calling``        ``Console.Write(findQuadruples(a, b, c, d, x, n));``    ``}``}` `// This code is contributed by nitin mittal.`

## PHP

 ``

## Javascript

 ``

Output:

`4`

Time Complexity: O(n4
Auxiliary Space: O(1)

Method 2 (Efficient Approach)
The idea is to use meet in the middle algorithm.
For this, observe the pattern below:
a ^ b ^ c ^ d = x
XOR c and d both sides
a ^ b ^ c ^ d ^ c ^ d = x ^ c ^ d
Since, c ^ c = 0 and d ^ d = 0
a ^ b ^ 0 ^ 0 = x ^ c ^ d
That is, a ^ b = x ^ c ^ d

Now, we just have to compute a ^ b and x ^ c ^ d which can be computed in O(n2) each and then find elements by using binary search.

## C++

 `// C++ program to find number of Quadruples from four``// arrays such that their XOR equals to 'x'``#include``using` `namespace` `std;` `// Function to return the number of Quadruples with XOR``// equals to x such that every element of Quadruple is``// from different array.``int` `findQuadruples(``int` `a[], ``int` `b[], ``int` `c[], ``int` `d[],``                   ``int` `x, ``int` `n)``{``    ``int` `count = 0;``    ``vector<``int``> v1, v2;` `    ``// Loop to get two different subsets``    ``for` `(``int` `i = 0 ; i < n ; i++)``    ``{``        ``for` `(``int` `j = 0 ; j < n ; j++)``        ``{``            ``// v1 for first and second array``            ``v1.push_back(a[i]^b[j]);` `            ``// v2 for third and forth array.``            ``// x is a constant, so no need for``            ``// a separate loop``            ``v2.push_back(x ^ c[i] ^ d[j]);``        ``}``    ``}` `    ``// Sorting the first set (Containing XOR``    ``// of a[] and b[]``    ``sort(v1.begin(), v1.end());` `    ``// Finding the lower and upper bound of an``    ``// element to find its number``    ``for` `(``int` `i = 0 ; i < v2.size() ; i++)``    ``{``        ``// Count number of occurrences of v2[i] in sorted``        ``// v1[] and add the count to result.``        ``auto` `low = lower_bound(v1.begin(), v1.end(), v2[i]);``        ``auto` `high = upper_bound(v1.begin(), v1.end(), v2[i]);``        ``count += high - low;``    ``}` `    ``return` `count;``}` `// Driver Program``int` `main()``{``    ``int`  `x = 3;``    ``int` `a[] = {0, 1};``    ``int` `b[] = {2, 0};``    ``int` `c[] = {0, 1};``    ``int` `d[] = {0, 1};` `    ``int` `n = ``sizeof``(a)/``sizeof``(a[0]);` `    ``cout << findQuadruples(a, b, c, d, x, n) << endl;` `    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */``import` `java.io.*;``import` `java.util.ArrayList;``import` `java.util.Collections;` `class` `GFG``{``  ` `    ``// Function to return the number of Quadruples with XOR``    ``// equals to x such that every element of Quadruple is``    ``// from different array.``    ``public` `static` `int` `findQuadruples(``int` `a[], ``int` `b[],``                                     ``int` `c[], ``int` `d[],``                                     ``int` `x, ``int` `n)``    ``{``        ``int` `count = ``0``;``        ``ArrayList v1 = ``new` `ArrayList<>();``        ``ArrayList v2 = ``new` `ArrayList<>();` `        ``// Loop to get two different subsets``        ``for` `(``int` `i = ``0``; i < n; i++)``        ``{``            ``for` `(``int` `j = ``0``; j < n; j++)``            ``{``              ` `                ``// v1 for first and second array``                ``v1.add(a[i] ^ b[j]);` `                ``// v2 for third and forth array.``                ``// x is a constant, so no need for``                ``// a separate loop``                ``v2.add(x ^ c[i] ^ d[j]);``            ``}``        ``}``        ``Collections.sort(v1);` `        ``// Finding the lower and upper bound of an``        ``// element to find its number``        ``for` `(``int` `i = ``0``; i < v2.size(); i++)``        ``{``          ` `            ``// Count number of occurrences of v2[i] in``            ``// sorted v1[] and add the count to result.``            ``int` `low``                ``= Collections.binarySearch(v1, v2.get(i));``            ``int` `j = low;``            ``for` `(j = low; j >= ``0``; j--)``            ``{``                ``if` `(v1.get(j) != v2.get(i))``                ``{``                    ``j++;``                    ``break``;``                ``}``            ``}``            ``low = j;``            ``int` `high = Collections.binarySearch(v1, v2.get(i));``            ``j = high;``            ``for` `(j = high; j < v1.size(); j++)``            ``{``                ``if` `(v1.get(j) != v2.get(i)) {``                    ``break``;``                ``}``            ``}``            ``high = j;``            ``count += high - low;``        ``}` `        ``return` `count;``    ``}` `  ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `x = ``3``;``        ``int` `a[] = { ``0``, ``1` `};``        ``int` `b[] = { ``2``, ``0` `};``        ``int` `c[] = { ``0``, ``1` `};``        ``int` `d[] = { ``0``, ``1` `};` `        ``int` `n = ``2``;``        ``System.out.println(``            ``findQuadruples(a, b, c, d, x, n));``    ``}``}` `// This code is contributed by aditya7409`

## Python3

 `# Python3 program to find number of Quadruples``# from four arrays such that their XOR equals``# to 'x'``from` `bisect ``import` `bisect_left, bisect_right` `# Function to return the number of Quadruples``# with XOR equals to x such that every element``# of Quadruple is from different array.``def` `findQuadruples(a, b, c, d, x, n):``    ` `    ``count ``=` `0``    ``v1, v2 ``=` `[], []` `    ``# Loop to get two different subsets``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(n):``            ` `            ``# v1 for first and second array``            ``v1.append(a[i] ^ b[j])` `            ``# v2 for third and forth array.``            ``# x is a constant, so no need for``            ``# a separate loop``            ``v2.append(x ^ c[i] ^ d[j])` `    ``# Sorting the first set (Containing XOR``    ``# of aand b``    ``v1 ``=` `sorted``(v1)` `    ``# Finding the lower and upper bound of an``    ``# element to find its number``    ``for` `i ``in` `range``(``len``(v2)):``        ` `        ``# Count number of occurrences of v2[i]``        ``# in sorted v1and add the count to result.``        ``low ``=` `bisect_left(v1, v2[i])``        ``high ``=` `bisect_right(v1, v2[i])``        ``count ``+``=` `high ``-` `low` `    ``return` `count` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``x ``=` `3``    ``a ``=` `[ ``0``, ``1` `]``    ``b ``=` `[ ``2``, ``0` `]``    ``c ``=` `[ ``0``, ``1` `]``    ``d ``=` `[ ``0``, ``1` `]` `    ``n ``=` `len``(a)` `    ``print``(findQuadruples(a, b, c, d, x, n))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to find number of Quadruples from four``// arrays such that their XOR equals to 'x'``using` `System;``using` `System.Collections.Generic;``class` `GFG``{``    ` `    ``// Function to return the number of Quadruples with XOR``    ``// equals to x such that every element of Quadruple is``    ``// from different array.``    ``static` `int` `findQuadruples(``int``[] a, ``int``[] b,``                              ``int``[] c, ``int``[] d,``                              ``int` `x, ``int` `n)``    ``{``        ``int` `count = 0;``        ``List<``int``> v1 = ``new` `List<``int``>();``        ``List<``int``> v2 = ``new` `List<``int``>();``     ` `        ``// Loop to get two different subsets``        ``for` `(``int` `i = 0 ; i < n ; i++)``        ``{``            ``for` `(``int` `j = 0 ; j < n ; j++)``            ``{``              ` `                ``// v1 for first and second array``                ``v1.Add(a[i]^b[j]);``     ` `                ``// v2 for third and forth array.``                ``// x is a constant, so no need for``                ``// a separate loop``                ``v2.Add(x ^ c[i] ^ d[j]);``            ``}``        ``}``     ` `        ``// Sorting the first set (Containing XOR``        ``// of a[] and b[]``        ``v1.Sort();``     ` `        ``// Finding the lower and upper bound of an``        ``// element to find its number``        ``for` `(``int` `i = 0 ; i < v2.Count; i++)``        ``{``            ``// Count number of occurrences of v2[i] in``            ``// sorted v1[] and add the count to result.``            ``int` `low = v1.BinarySearch(v2[i]);``            ``int` `j = low;``            ``for` `(j = low; j >= 0; j--)``            ``{``                ``if` `(v1[j] != v2[i])``                ``{``                    ``j++;``                    ``break``;``                ``}``            ``}``            ``low = j;``            ``int` `high = v1.BinarySearch(v2[i]);``            ``j = high;``            ``for` `(j = high; j < v1.Count; j++)``            ``{``                ``if` `(v1[j] != v2[i])``                ``{``                    ``break``;``                ``}``            ``}``            ``high = j;``            ``count += high - low;``        ``}    ``        ``return` `count;``    ``}` `  ``// Driver code``  ``static` `void` `Main()``  ``{``    ``int`  `x = 3;``    ``int``[] a = {0, 1};``    ``int``[] b = {2, 0};``    ``int``[] c = {0, 1};``    ``int``[] d = {0, 1};`` ` `    ``int` `n = a.Length;``    ``Console.WriteLine(findQuadruples(a, b, c, d, x, n));``  ``}``}` `// This code is contributed by divyesh072019`

## Javascript

 ``

Output:

`4`

Time Complexity: O(n2log(n))
Auxiliary Space: O(n2)

This article is contributed by Shubham Gupta. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.