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

filter_none

edit
close

play_arrow

link
brightness_4
code

    
// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right



Output:

Count = 4

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

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

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right



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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output:

Count = 4

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

This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
count pairs in the 3rd and 4th sorted array with sum equal to (x – p_sum)

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up