从四个排序数组中计算四倍，其总和等于给定值x

给定四个排序的数组，每个数组的大小为n个不同的元素。给定值x 。问题是要计算和等于x的所有四个数组中的所有四倍(四个数字组成的组)。
注意：四元组有四个数组中的每个数组中的一个元素。
例子：

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

方法1(天真方法)：使用四个嵌套循环生成所有四倍体，并检查四倍体中的元素之和是否等于x 。

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

输出：

Count = 4

时间复杂度： O(n ⁴ )
辅助空间： O(1)
方法2(二进制搜索)：从第三个数组中生成所有三元组。对于这样生成的每个三元组，找到三元组中元素的总和。设为T。现在，在第4个数组中搜索值(x – T) 。如果在第4个数组中找到值，则递增count 。对于从前三个数组生成的所有三元组重复此过程。

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

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

输出：

Count = 4

时间复杂度： O(n ³ logn)
辅助空间： O(1)
方法3(使用两个指针)：从第一个两个数组生成所有对。对于这样生成的每个对，找到该对中元素的总和。设为p_sum 。对于每个p_sum ，对来自第3和第4个排序数组的总和等于(x – p_sum)的对进行计数。将这些计数累积到四倍的total_count中。

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

输出：

Count = 4

时间复杂度： O(n ³ )
辅助空间： O(1)
方法4：有效方法(哈希)：创建一个哈希表，其中(键，值)元组表示为(和，频率)元组。在这里，总和是从第一对数组和第二对数组中获得的，它们的频率计数保存在哈希表中。哈希表是使用C++中的unordered_map实现的。现在，从第3个和第4个数组生成所有对。对于这样生成的每个对，找到该对中元素的总和。设为p_sum 。对于每个p_sum ，检查哈希表中是否存在(x – p_sum) 。如果存在，则将(x – p_sum)的频率加到四倍的计数。

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

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  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  tuples
    Dictionary m = new Dictionary();
      
    // 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

输出：

Count = 4