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

28 Jun, 2021
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++
Java
Python3
C#
PHP
Javascript
   // 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 xint 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 aboveint 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 implementation to count quadruples from four sorted arrays// whose sum is equal to a given value xclass 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
# 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 xdef 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 Codearr1 = [1, 4, 5, 6]arr2 = [2, 3, 7, 8]arr3 = [1, 4, 6, 10]arr4 = [2, 4, 7, 8 ]n = len(arr1)x = 30print("Count = ", countQuuadruples(arr1, arr2,                                   arr3, arr4, n, x)) # This code is contributed# by Shrikant13
// C# implementation to count quadruples from four sorted arrays// whose sum is equal to a given value xusing 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 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 xfunction 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?>
<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(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 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++
Java
C#
PHP
Javascript
// 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 appliedbool 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 xint 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 aboveint 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 implementation to count quadruples from// four sorted arrays whose sum is equal to a// given value xclass 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# implementation to count quadruples from// four sorted arrays whose sum is equal to a// given value xusing 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 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 appliedfunction 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 xfunction 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?>
<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(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++
Java
Python3
C#
Javascript
// 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 xint 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 aboveint 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 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 xstatic 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 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 xdef 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 codearr1 = [1, 4, 5, 6]arr2 = [2, 3, 7, 8]arr3 = [1, 4, 6, 10]arr4 = [2, 4, 7, 8]n = len(arr1)x = 30print("Count = ", countQuadruples(arr1, arr2,                                  arr3, arr4,                                  n, x)) # This code is contributed by Stream_Cipher
     // 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
<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 xfunction 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(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++
Java
Python3
C#
Javascript
// 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 xint 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 aboveint 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 implementation to count quadruples from// four sorted arrays whose sum is equal to a// given value ximport java.util.*; class GFG{ // function to count all quadruples from four sorted// arrays whose sum is equal to a given value xstatic 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 abovepublic 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
# 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 xdef 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 = 30print("Count =", countQuadruples(arr1, arr2, arr3, arr4, n, x)) # This code is contributed by avanitrachhadiya2155
// C# implementation to count quadruples from// four sorted arrays whose sum is equal to a// given value xusing System;using System.Collections.Generic; class GFG{  // function to count all quadruples from four sorted// arrays whose sum is equal to a given value xstatic 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 codepublic 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
<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 xfunction 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(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 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. 
shrikanth13
princiraj1992
ukasp
Akanksha_Rai
Rajput-Ji
29AjayKumar
Stream_Cipher
avanitrachhadiya2155
rag2127
decode2207
ab2127
unknown2108
Binary Search
Hash
Searching
Sorting
Searching
Hash
Sorting
Binary Search
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Quadratic Probing in Hashing
Rearrange an array such that arr[i] = i
Hashing in Java
Non-Repeating Element
What are Hash Functions and How to choose a good Hash Function?
Binary Search
Maximum and minimum of an array using minimum number of comparisons
Linear Search
Find the Missing Number
K'th Smallest/Largest Element in Unsorted Array | Set 1