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++ implementation to count quadruples from four sorted arrays // whose sum is equal to a given value x #include <bits/stdc++.h> using namespace std;
// function to count all quadruples from // four sorted arrays whose sum is equal // to a given value x int countQuadruples( int arr1[], int arr2[],
int arr3[], int arr4[], int n, int x)
{ int count = 0;
// generate all possible quadruples from
// the four sorted arrays
for ( int i = 0; i < n; i++)
for ( int j = 0; j < n; j++)
for ( int k = 0; k < n; k++)
for ( int l = 0; l < n; l++)
// check whether elements of
// quadruple sum up to x or not
if ((arr1[i] + arr2[j] + arr3[k] + arr4[l]) == x)
count++;
// required count of quadruples
return count;
} // Driver program to test above int main()
{ // four sorted arrays each of size 'n'
int arr1[] = { 1, 4, 5, 6 };
int arr2[] = { 2, 3, 7, 8 };
int arr3[] = { 1, 4, 6, 10 };
int arr4[] = { 2, 4, 7, 8 };
int n = sizeof (arr1) / sizeof (arr1[0]);
int x = 30;
cout << "Count = "
<< countQuadruples(arr1, arr2, arr3,
arr4, n, x);
return 0;
} |
// Java 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 |
# A Python3 implementation to count # quadruples from four sorted arrays # whose sum is equal to a given value x # function to count all quadruples # from four sorted arrays whose sum # is equal to a given value x def countquadruples(arr1, arr2,
arr3, arr4, n, x):
count = 0
# generate all possible
# quadruples from the four
# sorted arrays
for i in range (n):
for j in range (n):
for k in range (n):
for l in range (n):
# check whether elements of
# quadruple sum up to x or not
if (arr1[i] + arr2[j] +
arr3[k] + arr4[l] = = x):
count + = 1
# required count of quadruples
return count
# Driver Code arr1 = [ 1 , 4 , 5 , 6 ]
arr2 = [ 2 , 3 , 7 , 8 ]
arr3 = [ 1 , 4 , 6 , 10 ]
arr4 = [ 2 , 4 , 7 , 8 ]
n = len (arr1)
x = 30
print ( "Count = " , countquadruples(arr1, arr2,
arr3, arr4, n, x))
# This code is contributed # by Shrikant13 |
// C# implementation to count quadruples from four sorted arrays // whose sum is equal to a given value x using System;
public class GFG {
// function to count all quadruples from // four sorted arrays whose sum is equal // to a given value x static int countQuadruples( int []arr1, int []arr2,
int []arr3, int []arr4, int n, int x) {
int count = 0;
// generate all possible quadruples from
// the four sorted arrays
for ( int i = 0; i < n; i++) {
for ( int j = 0; j < n; j++) {
for ( int k = 0; k < n; k++) {
for ( int l = 0; l < n; l++) // check whether elements of
// quadruple sum up to x or not
{
if ((arr1[i] + arr2[j] + arr3[k] + arr4[l]) == x) {
count++;
}
}
}
}
}
// required count of quadruples
return count;
}
// Driver program to test above public static void Main() {
// four sorted arrays each of size 'n'
int []arr1 = {1, 4, 5, 6};
int []arr2 = {2, 3, 7, 8};
int []arr3 = {1, 4, 6, 10};
int []arr4 = {2, 4, 7, 8};
int n = arr1.Length;
int x = 30;
Console.Write( "Count = "
+ countQuadruples(arr1, arr2, arr3,
arr4, n, x));
}
} // This code is contributed by PrinciRaj19992 |
<?php // PHP 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 ?> |
<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++ implementation to count quadruples from // four sorted arrays whose sum is equal to a // given value x #include <bits/stdc++.h> using namespace std;
// find the 'value' in the given array 'arr[]' // binary search technique is applied bool isPresent( int arr[], int low, int high, int value)
{ while (low <= high) {
int mid = (low + high) / 2;
// 'value' found
if (arr[mid] == value)
return true ;
else if (arr[mid] > value)
high = mid - 1;
else
low = mid + 1;
}
// 'value' not found
return false ;
} // function to count all quadruples from four // sorted arrays whose sum is equal to a given value x int countQuadruples( int arr1[], int arr2[], int arr3[],
int arr4[], int n, int x)
{ int count = 0;
// generate all triplets from the 1st three arrays
for ( int i = 0; i < n; i++)
for ( int j = 0; j < n; j++)
for ( int k = 0; k < n; k++) {
// calculate the sum of elements in
// the triplet so generated
int T = arr1[i] + arr2[j] + arr3[k];
// check if 'x-T' is present in 4th
// array or not
if (isPresent(arr4, 0, n, x - T))
// increment count
count++;
}
// required count of quadruples
return count;
} // Driver program to test above int main()
{ // four sorted arrays each of size 'n'
int arr1[] = { 1, 4, 5, 6 };
int arr2[] = { 2, 3, 7, 8 };
int arr3[] = { 1, 4, 6, 10 };
int arr4[] = { 2, 4, 7, 8 };
int n = sizeof (arr1) / sizeof (arr1[0]);
int x = 30;
cout << "Count = "
<< countQuadruples(arr1, arr2, arr3, arr4, n, x);
return 0;
} |
// Java 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 |
# Python implementation to count quadruples from # four sorted arrays whose sum is equal to a # given value x # find the 'value' in the given array 'arr[]' # binary search technique is applied def isPresent(arr,low,high,value):
while (low< = high):
mid = (low + high) / / 2
# 'value' found
if (arr[mid] = = value):
return True
elif (arr[mid]>value):
high = mid - 1
else :
low = mid + 1
# 'value' not found
return False
# function to count all quadruples from four # sorted arrays whose sum is equal to a given value x def countQuadruples(arr1,arr2,arr3,arr4,n,x):
count = 0
#generate all triplets from the 1st three arrays
for i in range (n):
for j in range (n):
for k in range (n):
# calculate the sum of elements in
# the triplet so generated
T = arr1[i] + arr2[j] + arr3[k]
# check if 'x-T' is present in 4th
# array or not
if (isPresent(arr4, 0 ,n - 1 ,x - T)):
# increment count
count = count + 1
# required count of quadruples
return count
# Driver program to test above # four sorted arrays each of size 'n' arr1 = [ 1 , 4 , 5 , 6 ]
arr2 = [ 2 , 3 , 7 , 8 ]
arr3 = [ 1 , 4 , 6 , 10 ]
arr4 = [ 2 , 4 , 7 , 8 ]
n = len (arr1)
x = 30
print ( "Count = {}" . format (countQuadruples(arr1,arr2,arr3,arr4,n,x)))
# This code is contributed by Pushpesh Raj. |
// C# implementation to count quadruples from // four sorted arrays whose sum is equal to a // given value x using System;
class GFG
{ // find the 'value' in the given array 'arr[]'
// binary search technique is applied
static bool isPresent( int [] arr, int low,
int high, int value)
{
while (low <= high)
{
int mid = (low + high) / 2;
// 'value' found
if (arr[mid] == value)
return true ;
else if (arr[mid] > value)
high = mid - 1;
else
low = mid + 1;
}
// 'value' not found
return false ;
}
// function to count all quadruples from four
// sorted arrays whose sum is equal to a given value x
static int countQuadruples( int [] arr1, int [] arr2,
int [] arr3, int [] arr4,
int n, int x)
{
int count = 0;
// generate all triplets from the 1st three arrays
for ( int i = 0; i < n; i++)
for ( int j = 0; j < n; j++)
for ( int k = 0; k < n; k++)
{
// calculate the sum of elements in
// the triplet so generated
int T = arr1[i] + arr2[j] + arr3[k];
// check if 'x-T' is present in 4th
// array or not
if (isPresent(arr4, 0, n-1, x - T))
// increment count
count++;
}
// required count of quadruples
return count;
}
// Driver code
public static void Main(String[] args)
{
// four sorted arrays each of size 'n'
int [] arr1 = { 1, 4, 5, 6 };
int [] arr2 = { 2, 3, 7, 8 };
int [] arr3 = { 1, 4, 6, 10 };
int [] arr4 = { 2, 4, 7, 8 };
int n = 4;
int x = 30;
Console.WriteLine( "Count = "
+ countQuadruples(arr1, arr2, arr3, arr4, n, x));
}
} // This code has been contributed by 29AjayKumar |
<?php // PHP 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 ?> |
<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++ implementation to count quadruples from // four sorted arrays whose sum is equal to a // given value x #include <bits/stdc++.h> using namespace std;
// count pairs from the two sorted array whose sum // is equal to the given 'value' int countPairs( int arr1[], int arr2[], int n, int value)
{ int count = 0;
int l = 0, r = n - 1;
// traverse 'arr1[]' from left to right
// traverse 'arr2[]' from right to left
while (l < n & amp; &r >= 0) {
int sum = arr1[l] + arr2[r];
// if the 'sum' is equal to 'value', then
// increment 'l', decrement 'r' and
// increment 'count'
if (sum == value) {
l++, r--;
count++;
}
// if the 'sum' is greater than 'value', then
// decrement r
else if (sum > value)
r--;
// else increment l
else
l++;
}
// required count of pairs
return count;
} // function to count all quadruples from four sorted arrays // whose sum is equal to a given value x int countQuadruples( int arr1[], int arr2[], int arr3[],
int arr4[], int n, int x)
{ int count = 0;
// generate all pairs from arr1[] and arr2[]
for ( int i = 0; i < n; i++)
for ( int j = 0; j < n; j++) {
// calculate the sum of elements in
// the pair so generated
int p_sum = arr1[i] + arr2[j];
// count pairs in the 3rd and 4th array
// having value 'x-p_sum' and then
// accumulate it to 'count'
count += countPairs(arr3, arr4, n, x - p_sum);
}
// required count of quadruples
return count;
} // Driver program to test above int main()
{ // four sorted arrays each of size 'n'
int arr1[] = { 1, 4, 5, 6 };
int arr2[] = { 2, 3, 7, 8 };
int arr3[] = { 1, 4, 6, 10 };
int arr4[] = { 2, 4, 7, 8 };
int n = sizeof (arr1) / sizeof (arr1[0]);
int x = 30;
cout << "Count = "
<< countQuadruples(arr1, arr2, arr3,
arr4, n, x);
return 0;
} |
// Java 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 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# 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 x function countQuadruples(arr1,arr2,arr3,arr4,n,x)
{ let count = 0;
// generate all pairs from arr1[] and arr2[]
for (let i = 0; i < n; i++)
for (let j = 0; j < n; j++) {
// calculate the sum of elements in
// the pair so generated
let p_sum = arr1[i] + arr2[j];
// count pairs in the 3rd and 4th array
// having value 'x-p_sum' and then
// accumulate it to 'count'
count += countPairs(arr3, arr4, n, x - p_sum);
}
// required count of quadruples
return count;
} // Driver program to test above // four sorted arrays each of size 'n' let arr1=[1, 4, 5, 6]; let arr2=[2, 3, 7, 8]; let arr3=[1, 4, 6, 10]; let arr4=[2, 4, 7, 8]; let n = arr1.length; let x = 30; document.write( "Count = "
+ countQuadruples(arr1, arr2, arr3, arr4, n, x));
// This code is contributed by ab2127 </script> |
Output:
Count = 4
Time Complexity: O(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++ implementation to count quadruples from // four sorted arrays whose sum is equal to a // given value x #include <bits/stdc++.h> using namespace std;
// function to count all quadruples from four sorted // arrays whose sum is equal to a given value x int countQuadruples( int arr1[], int arr2[], int arr3[],
int arr4[], int n, int x)
{ int count = 0;
// unordered_map 'um' implemented as hash table
// for <sum, frequency> tuples
unordered_map< int , int > um;
// count frequency of each sum obtained from the
// pairs of arr1[] and arr2[] and store them in 'um'
for ( int i = 0; i < n; i++)
for ( int j = 0; j < n; j++)
um[arr1[i] + arr2[j]]++;
// generate pair from arr3[] and arr4[]
for ( int k = 0; k < n; k++)
for ( int l = 0; l < n; l++) {
// calculate the sum of elements in
// the pair so generated
int p_sum = arr3[k] + arr4[l];
// if 'x-p_sum' is present in 'um' then
// add frequency of 'x-p_sum' to 'count'
if (um.find(x - p_sum) != um.end())
count += um[x - p_sum];
}
// required count of quadruples
return count;
} // Driver program to test above int main()
{ // four sorted arrays each of size 'n'
int arr1[] = { 1, 4, 5, 6 };
int arr2[] = { 2, 3, 7, 8 };
int arr3[] = { 1, 4, 6, 10 };
int arr4[] = { 2, 4, 7, 8 };
int n = sizeof (arr1) / sizeof (arr1[0]);
int x = 30;
cout << "Count = "
<< countQuadruples(arr1, arr2, arr3, arr4, n, x);
return 0;
} |
// Java 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 |
# Python implementation to count quadruples from # four sorted arrays whose sum is equal to a # given value x # function to count all quadruples from four sorted # arrays whose sum is equal to a given value x def countQuadruples(arr1, arr2, arr3, arr4, n, x):
count = 0
# unordered_map 'um' implemented as hash table
# for <sum, frequency> tuples
m = {}
# count frequency of each sum obtained from the
# pairs of arr1[] and arr2[] and store them in 'um'
for i in range (n):
for j in range (n):
if (arr1[i] + arr2[j]) in m:
m[arr1[i] + arr2[j]] + = 1
else :
m[arr1[i] + arr2[j]] = 1
# generate pair from arr3[] and arr4[]
for k in range (n):
for l in range (n):
# calculate the sum of elements in
# the pair so generated
p_sum = arr3[k] + arr4[l]
# if 'x-p_sum' is present in 'um' then
# add frequency of 'x-p_sum' to 'count'
if (x - p_sum) in m:
count + = m[x - p_sum]
# required count of quadruples
return count
# Driver program to test above # four sorted arrays each of size 'n' arr1 = [ 1 , 4 , 5 , 6 ]
arr2 = [ 2 , 3 , 7 , 8 ]
arr3 = [ 1 , 4 , 6 , 10 ]
arr4 = [ 2 , 4 , 7 , 8 ]
n = len (arr1)
x = 30
print ( "Count =" , countQuadruples(arr1, arr2, arr3, arr4, n, x))
# This code is contributed by avanitrachhadiya2155 |
// C# 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 |
<script> // Javascript implementation to count quadruples from // four sorted arrays whose sum is equal to a // given value x // function to count all quadruples from four sorted // arrays whose sum is equal to a given value x function countQuadruples(arr1,arr2,arr3,arr4,n,X)
{ let count = 0;
// unordered_map 'um' implemented as hash table
// for <sum, frequency> tuples
let m = new Map();
// count frequency of each sum obtained from the
// pairs of arr1[] and arr2[] and store them in 'um'
for (let i = 0; i < n; i++)
for (let j = 0; j < n; j++)
if (m.has(arr1[i] + arr2[j]))
m.set((arr1[i] + arr2[j]), m.get((arr1[i] + arr2[j]))+1);
else
m.set((arr1[i] + arr2[j]), 1);
// generate pair from arr3[] and arr4[]
for (let k = 0; k < n; k++)
for (let l = 0; l < n; l++)
{
// calculate the sum of elements in
// the pair so generated
let p_sum = arr3[k] + arr4[l];
// if 'x-p_sum' is present in 'um' then
// add frequency of 'x-p_sum' to 'count'
if (m.has(x - p_sum))
count += m.get(x - p_sum);
}
// required count of quadruples
return count;
} // Driver program to test above // four sorted arrays each of size 'n' let arr1 = [ 1, 4, 5, 6 ]; let arr2 = [ 2, 3, 7, 8 ]; let arr3 = [ 1, 4, 6, 10 ]; let arr4 = [ 2, 4, 7, 8 ]; let n = arr1.length; let x = 30; document.write( "Count = "
+ countQuadruples(arr1, arr2, arr3, arr4, n, x));
// This code is contributed by unknown2108 </script> |
Output:
Count = 4
Time Complexity: O(n2)
Auxiliary Space: O(n2)
count pairs in the 3rd and 4th sorted array with sum equal to (x – p_sum)