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
The quadruples are:
(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

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 <bits/stdc++.h>

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[0]);
    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 countquadruples(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 = ", countquadruples(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

<?php
// PHP 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
function countQuadruples(&$arr1, &$arr2,
                         &$arr3, &$arr4,
                          $n, $x)
{
    $count = 0;

    // generate all possible quadruples
    // from the four sorted arrays
    for ($i = 0; $i < $n; $i++)
        for ($j = 0; $j < $n; $j++)
            for ($k = 0; $k < $n; $k++)
                for ($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 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 ita_c
?>

Javascript

<script>
// Javascript 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
    function countQuadruples(arr1,arr2,arr3,arr4,n,x)
    {
        let count = 0;

        // generate all possible quadruples from
        // the four sorted arrays
        for (let i = 0; i < n; i++) {
            for (let j = 0; j < n; j++) {
                for (let k = 0; k < n; k++) {
                    for (let 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
    let arr1=[1, 4, 5, 6];
    let arr2=[2, 3, 7, 8];
    let arr3=[1, 4, 6, 10];
    let arr4=[2, 4, 7, 8];
    let n = arr1.length;
    let x = 30;
    document.write("Count = "
                + countQuadruples(arr1, arr2, arr3,
                        arr4, n, x));

    //This code is contributed by rag2127

</script>

Output:

Count = 4

Time Complexity: O(n⁴) 
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 the 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 <bits/stdc++.h>

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[0]);
    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

Python3

# Python implementation to count quadruples from
# four sorted arrays whose sum is equal to a
# given value x

# find the 'value' in the given array 'arr[]'
# binary search technique is applied
def isPresent(arr,low,high,value):
    while(low<=high):
        mid=(low+high)//2
        # 'value' found
        if(arr[mid]==value):
            return True
        elif(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

def countQuadruples(arr1,arr2,arr3,arr4,n,x):
    count=0

    #generate all triplets from the 1st three arrays
    for i in range(n):
        for j in range(n):
            for k in range(n):
                # 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-1,x-T)):
                    # increment count
                    count=count+1
    # required count of quadruples
    return count

# Driver program to test above

# four sorted arrays each of size 'n'
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 = {}".format(countQuadruples(arr1,arr2,arr3,arr4,n,x)))

# This code is contributed by Pushpesh Raj.

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

<?php
// PHP implementation to count quadruples from
// four sorted arrays whose sum is equal to a
// given value x

// find the 'value' in the given array 'arr[]'
// binary search technique is applied
function isPresent($arr, $low, $high, $value)
{
    while ($low <= $high)
    {
        $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
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
?>

Javascript

<script>
    // Javascript implementation to count quadruples from
    // four sorted arrays whose sum is equal to a
    // given value x

    // find the 'value' in the given array 'arr[]'
    // binary search technique is applied
    function isPresent(arr, low, high, value)
    {
        while (low <= high)
        {
            let mid = parseInt((low + high) / 2, 10);

            // '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
    function countQuadruples(arr1, arr2, arr3, arr4, n, x)
    {
        let count = 0;

        // generate all triplets from the 1st three arrays
        for (let i = 0; i < n; i++)
            for (let j = 0; j < n; j++)
                for (let k = 0; k < n; k++)
                {

                    // calculate the sum of elements in
                    // the triplet so generated
                    let 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;
    }

    // four sorted arrays each of size 'n'
    let arr1 = [ 1, 4, 5, 6 ];
    let arr2 = [ 2, 3, 7, 8 ];
    let arr3 = [ 1, 4, 6, 10 ];
    let arr4 = [ 2, 4, 7, 8 ];
    let n = 4;
    let x = 30;
    document.write( "Count = " + countQuadruples(arr1, arr2, arr3, arr4, n, x));

</script>

Output:

Count = 4

Time Complexity: O(n³logn) 
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 <bits/stdc++.h>

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[0]);
    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

Python3

# Python3 implementation to
# count quadruples from four
# sorted arrays whose sum is
# equal to a given value x
# count pairs from the two
# sorted array whose sum
# is equal to the given 'value'
def countPairs(arr1, arr2,
               n, value):

     count = 0
     l = 0
     r = n - 1

     # traverse 'arr1[]' from
     # left to right
     # traverse 'arr2[]' from
     # right to left
     while (l < n and r >= 0):
          sum = arr1[l] + arr2[r]

          # if the 'sum' is equal
          # to 'value', then
          # increment 'l', decrement
          # 'r' and increment 'count'
          if (sum == value):
               l += 1
               r -= 1
               count += 1

               # if the 'sum' is greater
               # than 'value', then decrement r
          elif (sum > value):
               r -= 1

          # else increment l
          else:
               l += 1

     # required count of pairs
     # print(count)
     return count

# function to count all quadruples
# from four sorted arrays whose sum
# is equal to a given value x
def countQuadruples(arr1, arr2,
                    arr3, arr4,
                    n, x):
     count = 0

     # generate all pairs from
     # arr1[] and arr2[]
     for i in range(0, n):
          for j in range(0, n):

               # calculate the sum of
               # elements in the pair
               # so generated
               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 += int(countPairs(arr3, arr4,
                                       n, x - p_sum))
     # 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 = ", countQuadruples(arr1, arr2,
                                  arr3, arr4,
                                  n, x))

# This code is contributed by Stream_Cipher

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

Javascript

<script>
// Javascript implementation to count quadruples from
// four sorted arrays whose sum is equal to a
// given value x

// count pairs from the two sorted array whose sum
// is equal to the given 'value'
function countPairs(arr1,arr2,n,value)
{
    let count = 0;
    let l = 0, r = n - 1;

    // traverse 'arr1[]' from left to right
    // traverse 'arr2[]' from right to left
    while (l < n & r >= 0) {
        let 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
function countQuadruples(arr1,arr2,arr3,arr4,n,x)
{
    let count = 0;

    // generate all pairs from arr1[] and arr2[]
    for (let i = 0; i < n; i++)
        for (let j = 0; j < n; j++) {
            // calculate the sum of elements in
            // the pair so generated
            let 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
// four sorted arrays each of size 'n'
let arr1=[1, 4, 5, 6];
let arr2=[2, 3, 7, 8];
let arr3=[1, 4, 6, 10];
let arr4=[2, 4, 7, 8];
let n = arr1.length;
let x = 30;
document.write("Count = "
                + countQuadruples(arr1, arr2, arr3, arr4, n, x));

// This code is contributed by ab2127
</script>

Output:

Count = 4

Time Complexity: O(n³) 
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 <bits/stdc++.h>

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 <sum, frequency> 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[0]);
    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 <sum, frequency> tuples
    Map<Integer,Integer> 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

Python3

# Python 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 countQuadruples(arr1, arr2, arr3, arr4, n, x):
    count = 0

    # unordered_map 'um' implemented as hash table
    # for <sum, frequency> tuples
    m = {}

    # count frequency of each sum obtained from the
    # pairs of arr1[] and arr2[] and store them in 'um'
    for i in range(n):
        for j in range(n):
            if (arr1[i] + arr2[j]) in m:
                m[arr1[i] + arr2[j]] += 1
            else:
                m[arr1[i] + arr2[j]] = 1

    # generate pair from arr3[] and arr4[]
    for k in range(n):
        for l in range(n):

            # calculate the sum of elements in
            # the pair so generated
            p_sum = arr3[k] + arr4[l]

            # if 'x-p_sum' is present in 'um' then
            # add frequency of 'x-p_sum' to 'count'
            if (x - p_sum) in m:
                count += m[x - p_sum]

    # required count of quadruples
    return count

# Driver program to test above

# four sorted arrays each of size 'n'
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 =", countQuadruples(arr1, arr2, arr3, arr4, n, x))

# This code is contributed by avanitrachhadiya2155

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 <sum, frequency> 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

Javascript

<script>
// Javascript 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
function countQuadruples(arr1,arr2,arr3,arr4,n,X)
{
    let count = 0;

    // unordered_map 'um' implemented as hash table
    // for <sum, frequency> tuples
    let m = new Map();

    // count frequency of each sum obtained from the
    // pairs of arr1[] and arr2[] and store them in 'um'
    for (let i = 0; i < n; i++)
        for (let j = 0; j < n; j++)
            if(m.has(arr1[i] + arr2[j]))
                m.set((arr1[i] + arr2[j]), m.get((arr1[i] + arr2[j]))+1);
            else
                m.set((arr1[i] + arr2[j]), 1);

    // generate pair from arr3[] and arr4[]
    for (let k = 0; k < n; k++)
        for (let l = 0; l < n; l++)
        {

            // calculate the sum of elements in
            // the pair so generated
            let 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.has(x - p_sum))
                count += m.get(x - p_sum);
        }

    // required count of quadruples
    return count;
}

// Driver program to test above
// four sorted arrays each of size 'n'
let arr1 = [ 1, 4, 5, 6 ];
let arr2 = [ 2, 3, 7, 8 ];
let arr3 = [ 1, 4, 6, 10 ];
let arr4 = [ 2, 4, 7, 8 ];

let n = arr1.length;
let x = 30;
document.write("Count = "
                   + countQuadruples(arr1, arr2, arr3, arr4, n, x));


// This code is contributed by unknown2108
</script>

Output:

Count = 4

Time Complexity: O(n²) 
Auxiliary Space: O(n²) 

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 review-team@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)
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.