# Count quadruples from four sorted arrays whose sum is equal to a given value x

Given four sorted arrays each of size n of distinct elements. Given a value x. The problem is to count all quadruples(group of four numbers) from all the four arrays whose sum is equal to x.

Note: The quadruple has an element from each of the four arrays.

Examples:

```Input : arr1 = {1, 4, 5, 6},
arr2 = {2, 3, 7, 8},
arr3 = {1, 4, 6, 10},
arr4 = {2, 4, 7, 8}
n = 4, x = 30

Output : 4
(4, 8, 10, 8), (5, 7, 10, 8),
(5, 8, 10, 7), (6, 7, 10, 7)

Input : For the same above given fours arrays
x = 25
Output : 14
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Method 1 (Naive Approach): Using four nested loops generate all quadruples and check whether elements in the quadruple sum up to x or not.

## C++

 `   `  `// C++ implementation to count quadruples from four sorted arrays ` `// whose sum is equal to a given value x ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// function to count all quadruples from ` `// four sorted arrays whose sum is equal ` `// to a given value x ` `int` `countQuadruples(``int` `arr1[], ``int` `arr2[], ` `                    ``int` `arr3[], ``int` `arr4[], ``int` `n, ``int` `x) ` `{ ` `    ``int` `count = 0; ` ` `  `    ``// generate all possible quadruples from ` `    ``// the four sorted arrays ` `    ``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 elements of ` `                    ``// quadruple sum up to x or not ` `                    ``if` `((arr1[i] + arr2[j] + arr3[k] + arr4[l]) == x) ` `                        ``count++; ` ` `  `    ``// required count of quadruples ` `    ``return` `count; ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``// four sorted arrays each of size 'n' ` `    ``int` `arr1[] = { 1, 4, 5, 6 }; ` `    ``int` `arr2[] = { 2, 3, 7, 8 }; ` `    ``int` `arr3[] = { 1, 4, 6, 10 }; ` `    ``int` `arr4[] = { 2, 4, 7, 8 }; ` ` `  `    ``int` `n = ``sizeof``(arr1) / ``sizeof``(arr1); ` `    ``int` `x = 30; ` `    ``cout << ``"Count = "` `         ``<< countQuadruples(arr1, arr2, arr3, ` `                            ``arr4, n, x); ` `    ``return` `0; ` `} `

## Java

 `// Java implementation to count quadruples from four sorted arrays ` `// whose sum is equal to a given value x ` `class` `GFG { ` `// function to count all quadruples from ` `// four sorted arrays whose sum is equal ` `// to a given value x ` ` `  `    ``static` `int` `countQuadruples(``int` `arr1[], ``int` `arr2[], ` `            ``int` `arr3[], ``int` `arr4[], ``int` `n, ``int` `x) { ` `        ``int` `count = ``0``; ` ` `  `        ``// generate all possible quadruples from ` `        ``// the four sorted arrays ` `        ``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 elements of ` `                    ``// quadruple sum up to x or not ` `                    ``{ ` `                        ``if` `((arr1[i] + arr2[j] + arr3[k] + arr4[l]) == x) { ` `                            ``count++; ` `                        ``} ` `                    ``} ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// required count of quadruples ` `        ``return` `count; ` `    ``} ` ` `  `// Driver program to test above ` `    ``public` `static` `void` `main(String[] args) { ` ` `  `        ``// four sorted arrays each of size 'n' ` `        ``int` `arr1[] = {``1``, ``4``, ``5``, ``6``}; ` `        ``int` `arr2[] = {``2``, ``3``, ``7``, ``8``}; ` `        ``int` `arr3[] = {``1``, ``4``, ``6``, ``10``}; ` `        ``int` `arr4[] = {``2``, ``4``, ``7``, ``8``}; ` ` `  `        ``int` `n = arr1.length; ` `        ``int` `x = ``30``; ` `        ``System.out.println(``"Count = "` `                ``+ countQuadruples(arr1, arr2, arr3, ` `                        ``arr4, n, x)); ` ` `  `    ``} ` `} ` `//This code is contributed by PrinciRaj1992 `

## Python3

 `# A Python3 implementation to count  ` `# quadruples from four sorted arrays ` `# whose sum is equal to a given value x ` ` `  `# function to count all quadruples  ` `# from four sorted arrays whose sum  ` `# is equal to a given value x ` `def` `countQuuadruples(arr1, arr2,  ` `                     ``arr3, arr4, n, x): ` `    ``count ``=` `0` ` `  `    ``# generate all possible  ` `    ``# quadruples from the four ` `    ``# sorted arrays ` `    ``for` `i ``in` `range``(n): ` `        ``for` `j ``in` `range``(n): ` `            ``for` `k ``in` `range``(n): ` `                ``for` `l ``in` `range``(n): ` ` `  `                    ``# check whether elements of ` `                    ``# quadruple sum up to x or not ` `                    ``if` `(arr1[i] ``+` `arr2[j] ``+`  `                        ``arr3[k] ``+` `arr4[l] ``=``=` `x): ` `                        ``count ``+``=` `1` `                         `  `    ``# required count of quadruples ` `    ``return` `count ` ` `  `# Driver Code ` `arr1 ``=` `[``1``, ``4``, ``5``, ``6``] ` `arr2 ``=` `[``2``, ``3``, ``7``, ``8``] ` `arr3 ``=` `[``1``, ``4``, ``6``, ``10``] ` `arr4 ``=` `[``2``, ``4``, ``7``, ``8` `] ` `n ``=` `len``(arr1) ` `x ``=` `30` `print``(``"Count = "``, countQuuadruples(arr1, arr2,  ` `                                   ``arr3, arr4, n, x)) ` ` `  `# This code is contributed  ` `# by Shrikant13 `

## C#

 `// C# implementation to count quadruples from four sorted arrays  ` `// whose sum is equal to a given value x  ` `using` `System; ` `public` `class` `GFG {  ` `// function to count all quadruples from  ` `// four sorted arrays whose sum is equal  ` `// to a given value x  ` ` `  `    ``static` `int` `countQuadruples(``int` `[]arr1, ``int` `[]arr2,  ` `            ``int` `[]arr3, ``int` `[]arr4, ``int` `n, ``int` `x) {  ` `        ``int` `count = 0;  ` ` `  `        ``// generate all possible quadruples from  ` `        ``// the four sorted arrays  ` `        ``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 elements of  ` `                    ``// quadruple sum up to x or not  ` `                    ``{  ` `                        ``if` `((arr1[i] + arr2[j] + arr3[k] + arr4[l]) == x) {  ` `                            ``count++;  ` `                        ``}  ` `                    ``}  ` `                ``}  ` `            ``}  ` `        ``}  ` ` `  `        ``// required count of quadruples  ` `        ``return` `count;  ` `    ``}  ` ` `  `// Driver program to test above  ` `    ``public` `static` `void` `Main() {  ` ` `  `        ``// four sorted arrays each of size 'n'  ` `        ``int` `[]arr1 = {1, 4, 5, 6};  ` `        ``int` `[]arr2 = {2, 3, 7, 8};  ` `        ``int` `[]arr3 = {1, 4, 6, 10};  ` `        ``int` `[]arr4 = {2, 4, 7, 8};  ` ` `  `        ``int` `n = arr1.Length;  ` `        ``int` `x = 30;  ` `        ``Console.Write(``"Count = "` `                ``+ countQuadruples(arr1, arr2, arr3,  ` `                        ``arr4, n, x));  ` ` `  `    ``}  ` `}  ` ` `  `// This code is contributed by PrinciRaj19992 `

## PHP

 ` `

Output:

```Count = 4
```

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

Method 2 (Binary Search): Generate all triplets from the 1st three arrays. For each triplet so generated, find the sum of elements in the triplet. Let it be T. Now, search the value (x – T) in the 4th array. If value found in the 4th array, then increment count. This process is repeated for all the triplets generated from the 1st three arrays.

## C++

 `// C++ implementation to count quadruples from ` `// four sorted arrays whose sum is equal to a ` `// given value x ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// find the 'value' in the given array 'arr[]' ` `// binary search technique is applied ` `bool` `isPresent(``int` `arr[], ``int` `low, ``int` `high, ``int` `value) ` `{ ` `    ``while` `(low <= high) { ` `        ``int` `mid = (low + high) / 2; ` ` `  `        ``// 'value' found ` `        ``if` `(arr[mid] == value) ` `            ``return` `true``; ` `        ``else` `if` `(arr[mid] > value) ` `            ``high = mid - 1; ` `        ``else` `            ``low = mid + 1; ` `    ``} ` ` `  `    ``// 'value' not found ` `    ``return` `false``; ` `} ` ` `  `// function to count all quadruples from four ` `// sorted arrays whose sum is equal to a given value x ` `int` `countQuadruples(``int` `arr1[], ``int` `arr2[], ``int` `arr3[], ` `                    ``int` `arr4[], ``int` `n, ``int` `x) ` `{ ` `    ``int` `count = 0; ` ` `  `    ``// generate all triplets from the 1st three arrays ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``for` `(``int` `j = 0; j < n; j++) ` `            ``for` `(``int` `k = 0; k < n; k++) { ` ` `  `                ``// calculate the sum of elements in ` `                ``// the triplet so generated ` `                ``int` `T = arr1[i] + arr2[j] + arr3[k]; ` ` `  `                ``// check if 'x-T' is present in 4th ` `                ``// array or not ` `                ``if` `(isPresent(arr4, 0, n, x - T)) ` ` `  `                    ``// increment count ` `                    ``count++; ` `            ``} ` ` `  `    ``// required count of quadruples ` `    ``return` `count; ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``// four sorted arrays each of size 'n' ` `    ``int` `arr1[] = { 1, 4, 5, 6 }; ` `    ``int` `arr2[] = { 2, 3, 7, 8 }; ` `    ``int` `arr3[] = { 1, 4, 6, 10 }; ` `    ``int` `arr4[] = { 2, 4, 7, 8 }; ` ` `  `    ``int` `n = ``sizeof``(arr1) / ``sizeof``(arr1); ` `    ``int` `x = 30; ` `    ``cout << ``"Count = "` `         ``<< countQuadruples(arr1, arr2, arr3, arr4, n, x); ` `    ``return` `0; ` `} `

## Java

 `// Java implementation to count quadruples from  ` `// four sorted arrays whose sum is equal to a  ` `// given value x  ` `class` `GFG ` `{ ` `     `  `    ``// find the 'value' in the given array 'arr[]'  ` `    ``// binary search technique is applied  ` `    ``static` `boolean` `isPresent(``int``[] arr, ``int` `low, ` `                            ``int` `high, ``int` `value)  ` `    ``{  ` `        ``while` `(low <= high)  ` `        ``{ ` `            ``int` `mid = (low + high) / ``2``;  ` ` `  `            ``// 'value' found  ` `            ``if` `(arr[mid] == value)  ` `                ``return` `true``;  ` `            ``else` `if` `(arr[mid] > value)  ` `                ``high = mid - ``1``;  ` `            ``else` `                ``low = mid + ``1``;  ` `        ``}  ` ` `  `        ``// 'value' not found  ` `        ``return` `false``;  ` `    ``}  ` ` `  `    ``// function to count all quadruples from four  ` `    ``// sorted arrays whose sum is equal to a given value x  ` `    ``static` `int` `countQuadruples(``int``[] arr1, ``int``[] arr2, ` `                               ``int``[] arr3, ``int``[] arr4, ` `                               ``int` `n, ``int` `x)  ` `    ``{  ` `        ``int` `count = ``0``;  ` ` `  `        ``// generate all triplets from the 1st three arrays  ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `            ``for` `(``int` `j = ``0``; j < n; j++)  ` `                ``for` `(``int` `k = ``0``; k < n; k++)  ` `                ``{ ` ` `  `                    ``// calculate the sum of elements in  ` `                    ``// the triplet so generated  ` `                    ``int` `T = arr1[i] + arr2[j] + arr3[k];  ` ` `  `                    ``// check if 'x-T' is present in 4th  ` `                    ``// array or not  ` `                    ``if` `(isPresent(arr4, ``0``, n-``1``, x - T))  ` `     `  `                        ``// increment count  ` `                        ``count++;  ` `                ``}  ` ` `  `        ``// required count of quadruples  ` `        ``return` `count;  ` `    ``}  ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{  ` `        ``// four sorted arrays each of size 'n'  ` `        ``int``[] arr1 = { ``1``, ``4``, ``5``, ``6` `};  ` `        ``int``[] arr2 = { ``2``, ``3``, ``7``, ``8` `};  ` `        ``int``[] arr3 = { ``1``, ``4``, ``6``, ``10` `};  ` `        ``int``[] arr4 = { ``2``, ``4``, ``7``, ``8` `};  ` `        ``int` `n = ``4``;  ` `        ``int` `x = ``30``;  ` `        ``System.out.println( ``"Count = "` `        ``+ countQuadruples(arr1, arr2, arr3, arr4, n, x));  ` `    ``} ` `}  ` ` `  `// This code is contributed by Rajput-Ji `

## C#

 `// C# implementation to count quadruples from  ` `// four sorted arrays whose sum is equal to a  ` `// given value x  ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `    ``// find the 'value' in the given array 'arr[]'  ` `    ``// binary search technique is applied  ` `    ``static` `bool` `isPresent(``int``[] arr, ``int` `low, ` `                            ``int` `high, ``int` `value)  ` `    ``{  ` `        ``while` `(low <= high)  ` `        ``{ ` `            ``int` `mid = (low + high) / 2;  ` ` `  `            ``// 'value' found  ` `            ``if` `(arr[mid] == value)  ` `                ``return` `true``;  ` `            ``else` `if` `(arr[mid] > value)  ` `                ``high = mid - 1;  ` `            ``else` `                ``low = mid + 1;  ` `        ``}  ` ` `  `        ``// 'value' not found  ` `        ``return` `false``;  ` `    ``}  ` ` `  `    ``// function to count all quadruples from four  ` `    ``// sorted arrays whose sum is equal to a given value x  ` `    ``static` `int` `countQuadruples(``int``[] arr1, ``int``[] arr2, ` `                            ``int``[] arr3, ``int``[] arr4, ` `                            ``int` `n, ``int` `x)  ` `    ``{  ` `        ``int` `count = 0;  ` ` `  `        ``// generate all triplets from the 1st three arrays  ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `            ``for` `(``int` `j = 0; j < n; j++)  ` `                ``for` `(``int` `k = 0; k < n; k++)  ` `                ``{ ` ` `  `                    ``// calculate the sum of elements in  ` `                    ``// the triplet so generated  ` `                    ``int` `T = arr1[i] + arr2[j] + arr3[k];  ` ` `  `                    ``// check if 'x-T' is present in 4th  ` `                    ``// array or not  ` `                    ``if` `(isPresent(arr4, 0, n-1, x - T))  ` `     `  `                        ``// increment count  ` `                        ``count++;  ` `                ``}  ` ` `  `        ``// required count of quadruples  ` `        ``return` `count;  ` `    ``}  ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{  ` `        ``// four sorted arrays each of size 'n'  ` `        ``int``[] arr1 = { 1, 4, 5, 6 };  ` `        ``int``[] arr2 = { 2, 3, 7, 8 };  ` `        ``int``[] arr3 = { 1, 4, 6, 10 };  ` `        ``int``[] arr4 = { 2, 4, 7, 8 };  ` `        ``int` `n = 4;  ` `        ``int` `x = 30;  ` `        ``Console.WriteLine( ``"Count = "` `        ``+ countQuadruples(arr1, arr2, arr3, arr4, n, x));  ` `    ``} ` `} ` ` `  `// This code has been contributed by 29AjayKumar `

## PHP

 ` ``\$value``) ` `            ``\$high` `= ``\$mid` `- 1; ` `        ``else` `            ``\$low` `= ``\$mid` `+ 1; ` `    ``} ` ` `  `    ``// 'value' not found ` `    ``return` `false; ` `} ` ` `  `// function to count all quadruples from  ` `// four sorted arrays whose sum is equal  ` `// to a given value x ` `function` `countQuadruples(``\$arr1``, ``\$arr2``, ``\$arr3``, ` `                         ``\$arr4``, ``\$n``, ``\$x``) ` `{ ` `    ``\$count` `= 0; ` ` `  `    ``// generate all triplets from the  ` `    ``// 1st three arrays ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ` `        ``for` `(``\$j` `= 0; ``\$j` `< ``\$n``; ``\$j``++) ` `            ``for` `(``\$k` `= 0; ``\$k` `< ``\$n``; ``\$k``++) ` `            ``{ ` ` `  `                ``// calculate the sum of elements in ` `                ``// the triplet so generated ` `                ``\$T` `= ``\$arr1``[``\$i``] + ``\$arr2``[``\$j``] + ``\$arr3``[``\$k``]; ` ` `  `                ``// check if 'x-T' is present in 4th ` `                ``// array or not ` `                ``if` `(isPresent(``\$arr4``, 0, ``\$n``, ``\$x` `- ``\$T``)) ` ` `  `                    ``// increment count ` `                    ``\$count``++; ` `            ``} ` ` `  `    ``// required count of quadruples ` `    ``return` `\$count``; ` `} ` ` `  `// Driver Code ` ` `  `// four sorted arrays each of size 'n' ` `\$arr1` `= ``array``(1, 4, 5, 6); ` `\$arr2` `= ``array``(2, 3, 7, 8); ` `\$arr3` `= ``array``(1, 4, 6, 10); ` `\$arr4` `= ``array``(2, 4, 7, 8); ` ` `  `\$n` `= sizeof(``\$arr1``); ` `\$x` `= 30; ` `echo` `"Count = "` `. countQuadruples(``\$arr1``, ``\$arr2``, ``\$arr3``, ` `                                  ``\$arr4``, ``\$n``, ``\$x``); ` ` `  `// This code is contributed  ` `// by Akanksha Rai ` `?> `

Output:

```Count = 4
```

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

Method 3 (Use of two pointers): Generate all pairs from the 1st two arrays. For each pair so generated, find the sum of elements in the pair. Let it be p_sum. For each p_sum, count pairs from the 3rd and 4th sorted array with sum equal to (x – p_sum). Accumulate these count in the total_count of quadruples.

## C++

 `// C++ implementation to count quadruples from ` `// four sorted arrays whose sum is equal to a ` `// given value x ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// count pairs from the two sorted array whose sum ` `// is equal to the given 'value' ` `int` `countPairs(``int` `arr1[], ``int` `arr2[], ``int` `n, ``int` `value) ` `{ ` `    ``int` `count = 0; ` `    ``int` `l = 0, r = n - 1; ` ` `  `    ``// traverse 'arr1[]' from left to right ` `    ``// traverse 'arr2[]' from right to left ` `    ``while` `(l < n & amp; &r >= 0) { ` `        ``int` `sum = arr1[l] + arr2[r]; ` ` `  `        ``// if the 'sum' is equal to 'value', then ` `        ``// increment 'l', decrement 'r' and ` `        ``// increment 'count' ` `        ``if` `(sum == value) { ` `            ``l++, r--; ` `            ``count++; ` `        ``} ` ` `  `        ``// if the 'sum' is greater than 'value', then ` `        ``// decrement r ` `        ``else` `if` `(sum > value) ` `            ``r--; ` ` `  `        ``// else increment l ` `        ``else` `            ``l++; ` `    ``} ` ` `  `    ``// required count of pairs ` `    ``return` `count; ` `} ` ` `  `// function to count all quadruples from four sorted arrays ` `// whose sum is equal to a given value x ` `int` `countQuadruples(``int` `arr1[], ``int` `arr2[], ``int` `arr3[], ` `                    ``int` `arr4[], ``int` `n, ``int` `x) ` `{ ` `    ``int` `count = 0; ` ` `  `    ``// generate all pairs from arr1[] and arr2[] ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``for` `(``int` `j = 0; j < n; j++) { ` `            ``// calculate the sum of elements in ` `            ``// the pair so generated ` `            ``int` `p_sum = arr1[i] + arr2[j]; ` ` `  `            ``// count pairs in the 3rd and 4th array ` `            ``// having value 'x-p_sum' and then ` `            ``// accumulate it to 'count' ` `            ``count += countPairs(arr3, arr4, n, x - p_sum); ` `        ``} ` ` `  `    ``// required count of quadruples ` `    ``return` `count; ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``// four sorted arrays each of size 'n' ` `    ``int` `arr1[] = { 1, 4, 5, 6 }; ` `    ``int` `arr2[] = { 2, 3, 7, 8 }; ` `    ``int` `arr3[] = { 1, 4, 6, 10 }; ` `    ``int` `arr4[] = { 2, 4, 7, 8 }; ` ` `  `    ``int` `n = ``sizeof``(arr1) / ``sizeof``(arr1); ` `    ``int` `x = 30; ` `    ``cout << ``"Count = "` `         ``<< countQuadruples(arr1, arr2, arr3, ` `                            ``arr4, n, x); ` `    ``return` `0; ` `} `

## Java

 `// Java implementation to count quadruples from ` `// four sorted arrays whose sum is equal to a ` `// given value x ` ` `  `class` `GFG { ` ` `  `// count pairs from the two sorted array whose sum ` `// is equal to the given 'value' ` `static` `int` `countPairs(``int` `arr1[], ``int` `arr2[], ``int` `n, ``int` `value) ` `{ ` `    ``int` `count = ``0``; ` `    ``int` `l = ``0``, r = n - ``1``; ` `  `  `    ``// traverse 'arr1[]' from left to right ` `    ``// traverse 'arr2[]' from right to left ` `    ``while` `(l < n & r >= ``0``) { ` `        ``int` `sum = arr1[l] + arr2[r]; ` `  `  `        ``// if the 'sum' is equal to 'value', then ` `        ``// increment 'l', decrement 'r' and ` `        ``// increment 'count' ` `        ``if` `(sum == value) { ` `            ``l++; r--; ` `            ``count++; ` `        ``} ` `  `  `        ``// if the 'sum' is greater than 'value', then ` `        ``// decrement r ` `        ``else` `if` `(sum > value) ` `            ``r--; ` `  `  `        ``// else increment l ` `        ``else` `            ``l++; ` `    ``} ` `  `  `    ``// required count of pairs ` `    ``return` `count; ` `} ` `  `  `// function to count all quadruples from four sorted arrays ` `// whose sum is equal to a given value x ` `static` `int` `countQuadruples(``int` `arr1[], ``int` `arr2[], ``int` `arr3[], ` `                    ``int` `arr4[], ``int` `n, ``int` `x) ` `{ ` `    ``int` `count = ``0``; ` `  `  `    ``// generate all pairs from arr1[] and arr2[] ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``for` `(``int` `j = ``0``; j < n; j++) { ` `            ``// calculate the sum of elements in ` `            ``// the pair so generated ` `            ``int` `p_sum = arr1[i] + arr2[j]; ` `  `  `            ``// count pairs in the 3rd and 4th array ` `            ``// having value 'x-p_sum' and then ` `            ``// accumulate it to 'count' ` `            ``count += countPairs(arr3, arr4, n, x - p_sum); ` `        ``} ` `  `  `    ``// required count of quadruples ` `    ``return` `count; ` `} ` `// Driver program to test above ` `    ``static` `public` `void` `main(String[] args) { ` `        ``// four sorted arrays each of size 'n' ` `        ``int` `arr1[] = {``1``, ``4``, ``5``, ``6``}; ` `        ``int` `arr2[] = {``2``, ``3``, ``7``, ``8``}; ` `        ``int` `arr3[] = {``1``, ``4``, ``6``, ``10``}; ` `        ``int` `arr4[] = {``2``, ``4``, ``7``, ``8``}; ` ` `  `        ``int` `n = arr1.length; ` `        ``int` `x = ``30``; ` `        ``System.out.println(``"Count = "` `                ``+ countQuadruples(arr1, arr2, arr3, arr4, n, x)); ` `    ``} ` `} ` ` `  `// This code is contributed by PrinciRaj19992 `

## C#

 `     `  `// C# implementation to count quadruples from ` `// four sorted arrays whose sum is equal to a ` `// given value x ` ` ``using` `System; ` `public` `class` `GFG { ` ` `  `    ``// count pairs from the two sorted array whose sum ` `    ``// is equal to the given 'value' ` `    ``static` `int` `countPairs(``int` `[]arr1, ``int` `[]arr2, ``int` `n, ``int` `value) ` `    ``{ ` `        ``int` `count = 0; ` `        ``int` `l = 0, r = n - 1; ` ` `  `        ``// traverse 'arr1[]' from left to right ` `        ``// traverse 'arr2[]' from right to left ` `        ``while` `(l < n & r >= 0) { ` `            ``int` `sum = arr1[l] + arr2[r]; ` ` `  `            ``// if the 'sum' is equal to 'value', then ` `            ``// increment 'l', decrement 'r' and ` `            ``// increment 'count' ` `            ``if` `(sum == value) { ` `                ``l++; r--; ` `                ``count++; ` `            ``} ` ` `  `            ``// if the 'sum' is greater than 'value', then ` `            ``// decrement r ` `            ``else` `if` `(sum > value) ` `                ``r--; ` ` `  `            ``// else increment l ` `            ``else` `                ``l++; ` `        ``} ` ` `  `        ``// required count of pairs ` `        ``return` `count; ` `    ``} ` ` `  `    ``// function to count all quadruples from four sorted arrays ` `    ``// whose sum is equal to a given value x ` `    ``static` `int` `countQuadruples(``int` `[]arr1, ``int` `[]arr2, ``int` `[]arr3, ` `                        ``int` `[]arr4, ``int` `n, ``int` `x) ` `    ``{ ` `        ``int` `count = 0; ` ` `  `        ``// generate all pairs from arr1[] and arr2[] ` `        ``for` `(``int` `i = 0; i < n; i++) ` `            ``for` `(``int` `j = 0; j < n; j++) { ` `                ``// calculate the sum of elements in ` `                ``// the pair so generated ` `                ``int` `p_sum = arr1[i] + arr2[j]; ` ` `  `                ``// count pairs in the 3rd and 4th array ` `                ``// having value 'x-p_sum' and then ` `                ``// accumulate it to 'count' ` `                ``count += countPairs(arr3, arr4, n, x - p_sum); ` `            ``} ` ` `  `        ``// required count of quadruples ` `        ``return` `count; ` `    ``} ` `    ``// Driver program to test above ` `    ``static` `public` `void` `Main() { ` `        ``// four sorted arrays each of size 'n' ` `        ``int` `[]arr1 = {1, 4, 5, 6}; ` `        ``int` `[]arr2 = {2, 3, 7, 8}; ` `        ``int` `[]arr3 = {1, 4, 6, 10}; ` `        ``int` `[]arr4 = {2, 4, 7, 8}; ` `  `  `        ``int` `n = arr1.Length; ` `        ``int` `x = 30; ` `        ``Console.Write(``"Count = "` `                ``+ countQuadruples(arr1, arr2, arr3, arr4, n, x)); ` `    ``} ` `} ` `  `  `// This code is contributed by PrinciRaj19992 `

Output:

```Count = 4
```

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

Method 4 Efficient Approach(Hashing): Create a hash table where (key, value) tuples are represented as (sum, frequency) tuples. Here the sum are obtained from the pairs of 1st and 2nd array and their frequency count is maintained in the hash table. Hash table is implemented using unordered_map in C++. Now, generate all pairs from the 3rd and 4th array. For each pair so generated, find the sum of elements in the pair. Let it be p_sum. For each p_sum, check whether (x – p_sum) exists in the hash table or not. If it exists, then add the frequency of (x – p_sum) to the count of quadruples.

## C++

 `// C++ implementation to count quadruples from ` `// four sorted arrays whose sum is equal to a ` `// given value x ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// function to count all quadruples from four sorted ` `// arrays whose sum is equal to a given value x ` `int` `countQuadruples(``int` `arr1[], ``int` `arr2[], ``int` `arr3[], ` `                    ``int` `arr4[], ``int` `n, ``int` `x) ` `{ ` `    ``int` `count = 0; ` ` `  `    ``// unordered_map 'um' implemented as hash table ` `    ``// for tuples ` `    ``unordered_map<``int``, ``int``> um; ` ` `  `    ``// count frequency of each sum obtained from the ` `    ``// pairs of arr1[] and arr2[] and store them in 'um' ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``for` `(``int` `j = 0; j < n; j++) ` `            ``um[arr1[i] + arr2[j]]++; ` ` `  `    ``// generate pair from arr3[] and arr4[] ` `    ``for` `(``int` `k = 0; k < n; k++) ` `        ``for` `(``int` `l = 0; l < n; l++) { ` ` `  `            ``// calculate the sum of elements in ` `            ``// the pair so generated ` `            ``int` `p_sum = arr3[k] + arr4[l]; ` ` `  `            ``// if 'x-p_sum' is present in 'um' then ` `            ``// add frequency of 'x-p_sum' to 'count' ` `            ``if` `(um.find(x - p_sum) != um.end()) ` `                ``count += um[x - p_sum]; ` `        ``} ` ` `  `    ``// required count of quadruples ` `    ``return` `count; ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``// four sorted arrays each of size 'n' ` `    ``int` `arr1[] = { 1, 4, 5, 6 }; ` `    ``int` `arr2[] = { 2, 3, 7, 8 }; ` `    ``int` `arr3[] = { 1, 4, 6, 10 }; ` `    ``int` `arr4[] = { 2, 4, 7, 8 }; ` ` `  `    ``int` `n = ``sizeof``(arr1) / ``sizeof``(arr1); ` `    ``int` `x = 30; ` `    ``cout << ``"Count = "` `         ``<< countQuadruples(arr1, arr2, arr3, arr4, n, x); ` `    ``return` `0; ` `} `

## Java

 `// Java implementation to count quadruples from ` `// four sorted arrays whose sum is equal to a ` `// given value x ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `// function to count all quadruples from four sorted ` `// arrays whose sum is equal to a given value x ` `static` `int` `countQuadruples(``int` `arr1[], ``int` `arr2[], ``int` `arr3[], ` `                                    ``int` `arr4[], ``int` `n, ``int` `x) ` `{ ` `    ``int` `count = ``0``; ` ` `  `    ``// unordered_map 'um' implemented as hash table ` `    ``// for tuples ` `    ``Map m = ``new` `HashMap<>(); ` `     `  `    ``// count frequency of each sum obtained from the ` `    ``// pairs of arr1[] and arr2[] and store them in 'um' ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``for` `(``int` `j = ``0``; j < n; j++) ` `            ``if``(m.containsKey(arr1[i] + arr2[j])) ` `                ``m.put((arr1[i] + arr2[j]), m.get((arr1[i] + arr2[j]))+``1``); ` `            ``else` `                ``m.put((arr1[i] + arr2[j]), ``1``); ` `                 `  `    ``// generate pair from arr3[] and arr4[] ` `    ``for` `(``int` `k = ``0``; k < n; k++) ` `        ``for` `(``int` `l = ``0``; l < n; l++) ` `        ``{ ` ` `  `            ``// calculate the sum of elements in ` `            ``// the pair so generated ` `            ``int` `p_sum = arr3[k] + arr4[l]; ` ` `  `            ``// if 'x-p_sum' is present in 'um' then ` `            ``// add frequency of 'x-p_sum' to 'count' ` `            ``if` `(m.containsKey(x - p_sum)) ` `                ``count += m.get(x - p_sum); ` `        ``} ` ` `  `    ``// required count of quadruples ` `    ``return` `count; ` `} ` ` `  `// Driver program to test above ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``// four sorted arrays each of size 'n' ` `    ``int` `arr1[] = { ``1``, ``4``, ``5``, ``6` `}; ` `    ``int` `arr2[] = { ``2``, ``3``, ``7``, ``8` `}; ` `    ``int` `arr3[] = { ``1``, ``4``, ``6``, ``10` `}; ` `    ``int` `arr4[] = { ``2``, ``4``, ``7``, ``8` `}; ` ` `  `    ``int` `n = arr1.length; ` `    ``int` `x = ``30``; ` `    ``System.out.println(``"Count = "` `        ``+ countQuadruples(arr1, arr2, arr3, arr4, n, x)); ` `} ` `} ` ` `  `// This code has been contributed by 29AjayKumar `

## C#

 `// C# implementation to count quadruples from ` `// four sorted arrays whose sum is equal to a ` `// given value x ` `using` `System;  ` `using` `System.Collections.Generic; ` ` `  `class` `GFG  ` `{ ` `  `  `// function to count all quadruples from four sorted ` `// arrays whose sum is equal to a given value x ` `static` `int` `countQuadruples(``int` `[]arr1, ``int` `[]arr2, ``int` `[]arr3, ` `                                    ``int` `[]arr4, ``int` `n, ``int` `x) ` `{ ` `    ``int` `count = 0; ` `  `  `    ``// unordered_map 'um' implemented as hash table ` `    ``// for tuples ` `    ``Dictionary<``int``,``int``> m = ``new` `Dictionary<``int``,``int``>(); ` `      `  `    ``// count frequency of each sum obtained from the ` `    ``// pairs of arr1[] and arr2[] and store them in 'um' ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``for` `(``int` `j = 0; j < n; j++) ` `            ``if``(m.ContainsKey(arr1[i] + arr2[j])){ ` `                ``var` `val = m[arr1[i] + arr2[j]]; ` `                ``m.Remove(arr1[i] + arr2[j]); ` `                ``m.Add((arr1[i] + arr2[j]), val+1); ` `            ``} ` `            ``else` `                ``m.Add((arr1[i] + arr2[j]), 1); ` `                  `  `    ``// generate pair from arr3[] and arr4[] ` `    ``for` `(``int` `k = 0; k < n; k++) ` `        ``for` `(``int` `l = 0; l < n; l++) ` `        ``{ ` `  `  `            ``// calculate the sum of elements in ` `            ``// the pair so generated ` `            ``int` `p_sum = arr3[k] + arr4[l]; ` `  `  `            ``// if 'x-p_sum' is present in 'um' then ` `            ``// add frequency of 'x-p_sum' to 'count' ` `            ``if` `(m.ContainsKey(x - p_sum)) ` `                ``count += m[x - p_sum]; ` `        ``} ` `  `  `    ``// required count of quadruples ` `    ``return` `count; ` `} ` `  `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``// four sorted arrays each of size 'n' ` `    ``int` `[]arr1 = { 1, 4, 5, 6 }; ` `    ``int` `[]arr2 = { 2, 3, 7, 8 }; ` `    ``int` `[]arr3 = { 1, 4, 6, 10 }; ` `    ``int` `[]arr4 = { 2, 4, 7, 8 }; ` `  `  `    ``int` `n = arr1.Length; ` `    ``int` `x = 30; ` `    ``Console.WriteLine(``"Count = "` `        ``+ countQuadruples(arr1, arr2, arr3, arr4, n, x)); ` `} ` `} ` ` `  `// This code has been contributed by 29AjayKumar `

Output:

```Count = 4
```

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

This article is contributed by Ayush Jauhari. 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.
count pairs in the 3rd and 4th sorted array with sum equal to (x – p_sum)