Count quadruples from four sorted arrays whose sum is equal to a given value x
Last Updated :
27 Sep, 2022
Given four sorted arrays each of size n of distinct elements. Given a value x. The problem is to count all quadruples(group of four numbers) from all the four arrays whose sum is equal to x.
Note: The quadruple has an element from each of the four arrays.
Examples:
Input : arr1 = {1, 4, 5, 6},
arr2 = {2, 3, 7, 8},
arr3 = {1, 4, 6, 10},
arr4 = {2, 4, 7, 8}
n = 4, x = 30
Output : 4
The quadruples are:
(4, 8, 10, 8), (5, 7, 10, 8),
(5, 8, 10, 7), (6, 7, 10, 7)
Input : For the same above given fours arrays
x = 25
Output : 14
Method 1 (Naive Approach):
Using four nested loops generate all quadruples and check whether elements in the quadruple sum up to x or not.
C++
// C++ implementation to count quadruples from four sorted arrays
// whose sum is equal to a given value x
#include <bits/stdc++.h>
using namespace std;
// function to count all quadruples from
// four sorted arrays whose sum is equal
// to a given value x
int countQuadruples(int arr1[], int arr2[],
int arr3[], int arr4[], int n, int x)
{
int count = 0;
// generate all possible quadruples from
// the four sorted arrays
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
for (int l = 0; l < n; l++)
// check whether elements of
// quadruple sum up to x or not
if ((arr1[i] + arr2[j] + arr3[k] + arr4[l]) == x)
count++;
// required count of quadruples
return count;
}
// Driver program to test above
int main()
{
// four sorted arrays each of size 'n'
int arr1[] = { 1, 4, 5, 6 };
int arr2[] = { 2, 3, 7, 8 };
int arr3[] = { 1, 4, 6, 10 };
int arr4[] = { 2, 4, 7, 8 };
int n = sizeof(arr1) / sizeof(arr1[0]);
int x = 30;
cout << "Count = "
<< countQuadruples(arr1, arr2, arr3,
arr4, n, x);
return 0;
}
// Java 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++
// 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++
// 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++
// 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)
Similar Reads
Hashing in Data Structure
Hashing is a technique used in data structures that efficiently stores and retrieves data in a way that allows for quick access. Hashing involves mapping data to a specific index in a hash table (an array of items) using a hash function. It enables fast retrieval of information based on its key. The
3 min read
Introduction to Hashing
Hashing refers to the process of generating a small sized output (that can be used as index in a table) from an input of typically large and variable size. Hashing uses mathematical formulas known as hash functions to do the transformation. This technique determines an index or location for the stor
7 min read
What is Hashing?
Hashing refers to the process of generating a fixed-size output from an input of variable size using the mathematical formulas known as hash functions. This technique determines an index or location for the storage of an item in a data structure. Need for Hash data structureThe amount of data on the
3 min read
Index Mapping (or Trivial Hashing) with negatives allowed
Index Mapping (also known as Trivial Hashing) is a simple form of hashing where the data is directly mapped to an index in a hash table. The hash function used in this method is typically the identity function, which maps the input data to itself. In this case, the key of the data is used as the ind
7 min read
Separate Chaining Collision Handling Technique in Hashing
Separate Chaining is a collision handling technique. Separate chaining is one of the most popular and commonly used techniques in order to handle collisions. In this article, we will discuss about what is Separate Chain collision handling technique, its advantages, disadvantages, etc.There are mainl
3 min read
Open Addressing Collision Handling technique in Hashing
Open Addressing is a method for handling collisions. In Open Addressing, all elements are stored in the hash table itself. So at any point, the size of the table must be greater than or equal to the total number of keys (Note that we can increase table size by copying old data if needed). This appro
7 min read
Double Hashing
Double hashing is a collision resolution technique used in hash tables. It works by using two hash functions to compute two different hash values for a given key. The first hash function is used to compute the initial hash value, and the second hash function is used to compute the step size for the
15+ min read
Load Factor and Rehashing
Prerequisites: Hashing Introduction and Collision handling by separate chaining How hashing works: For insertion of a key(K) - value(V) pair into a hash map, 2 steps are required: K is converted into a small integer (called its hash code) using a hash function.The hash code is used to find an index
15+ min read
Easy problems on Hashing
Check if an array is subset of another array
Given two arrays a[] and b[] of size m and n respectively, the task is to determine whether b[] is a subset of a[]. Both arrays are not sorted, and elements are distinct.Examples: Input: a[] = [11, 1, 13, 21, 3, 7], b[] = [11, 3, 7, 1] Output: trueInput: a[]= [1, 2, 3, 4, 5, 6], b = [1, 2, 4] Output
13 min read
Union and Intersection of two Linked List using Hashing
Given two singly Linked Lists, create union and intersection lists that contain the union and intersection of the elements present in the given lists. Each of the two linked lists contains distinct node values.Note: The order of elements in output lists doesn’t matter. Examples:Input:head1 : 10 -
10 min read
Two Sum - Pair with given Sum
Given an array arr[] of n integers and a target value, the task is to find whether there is a pair of elements in the array whose sum is equal to target. This problem is a variation of 2Sum problem.Examples: Input: arr[] = [0, -1, 2, -3, 1], target = -2Output: trueExplanation: There is a pair (1, -3
15+ min read
Max Distance Between Two Occurrences
Given an array arr[], the task is to find the maximum distance between two occurrences of any element. If no element occurs twice, return 0.Examples: Input: arr = [1, 1, 2, 2, 2, 1]Output: 5Explanation: distance for 1 is: 5-0 = 5, distance for 2 is: 4-2 = 2, So max distance is 5.Input : arr[] = [3,
8 min read
Most frequent element in an array
Given an array, the task is to find the most frequent element in it. If there are multiple elements that appear a maximum number of times, return the maximum element.Examples: Input : arr[] = [1, 3, 2, 1, 4, 1]Output : 1Explanation: 1 appears three times in array which is maximum frequency.Input : a
10 min read
Only Repeating From 1 To n-1
Given an array arr[] of size n filled with numbers from 1 to n-1 in random order. The array has only one repetitive element. The task is to find the repetitive element.Examples:Input: arr[] = [1, 3, 2, 3, 4]Output: 3Explanation: The number 3 is the only repeating element.Input: arr[] = [1, 5, 1, 2,
15+ min read
Check for Disjoint Arrays or Sets
Given two arrays a and b, check if they are disjoint, i.e., there is no element common between both the arrays.Examples: Input: a[] = {12, 34, 11, 9, 3}, b[] = {2, 1, 3, 5} Output: FalseExplanation: 3 is common in both the arrays.Input: a[] = {12, 34, 11, 9, 3}, b[] = {7, 2, 1, 5} Output: True Expla
11 min read
Non-overlapping sum of two sets
Given two arrays A[] and B[] of size n. It is given that both array individually contains distinct elements. We need to find the sum of all elements that are not common.Examples: Input : A[] = {1, 5, 3, 8} B[] = {5, 4, 6, 7}Output : 291 + 3 + 4 + 6 + 7 + 8 = 29Input : A[] = {1, 5, 3, 8} B[] = {5, 1,
9 min read
Check if two arrays are equal or not
Given two arrays, a and b of equal length. The task is to determine if the given arrays are equal or not. Two arrays are considered equal if:Both arrays contain the same set of elements.The arrangements (or permutations) of elements may be different.If there are repeated elements, the counts of each
6 min read
Find missing elements of a range
Given an array, arr[0..n-1] of distinct elements and a range [low, high], find all numbers that are in a range, but not the array. The missing elements should be printed in sorted order.Examples: Input: arr[] = {10, 12, 11, 15}, low = 10, high = 15Output: 13, 14Input: arr[] = {1, 14, 11, 51, 15}, lo
15+ min read
Minimum Subsets with Distinct Elements
You are given an array of n-element. You have to make subsets from the array such that no subset contain duplicate elements. Find out minimum number of subset possible.Examples : Input : arr[] = {1, 2, 3, 4}Output :1Explanation : A single subset can contains all values and all values are distinct.In
9 min read
Remove minimum elements such that no common elements exist in two arrays
Given two arrays arr1[] and arr2[] consisting of n and m elements respectively. The task is to find the minimum number of elements to remove from each array such that intersection of both arrays becomes empty and both arrays become mutually exclusive.Examples: Input: arr[] = { 1, 2, 3, 4}, arr2[] =
8 min read
2 Sum - Count pairs with given sum
Given an array arr[] of n integers and a target value, the task is to find the number of pairs of integers in the array whose sum is equal to target.Examples: Input: arr[] = {1, 5, 7, -1, 5}, target = 6Output: 3Explanation: Pairs with sum 6 are (1, 5), (7, -1) & (1, 5). Input: arr[] = {1, 1, 1,
9 min read
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 =
15+ min read
Sort elements by frequency | Set 4 (Efficient approach using hash)
Print the elements of an array in the decreasing frequency if 2 numbers have the same frequency then print the one which came first. Examples: Input : arr[] = {2, 5, 2, 8, 5, 6, 8, 8} Output : arr[] = {8, 8, 8, 2, 2, 5, 5, 6} Input : arr[] = {2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8} Output : arr[] = {8,
12 min read
Find all pairs (a, b) in an array such that a % b = k
Given an array with distinct elements, the task is to find the pairs in the array such that a % b = k, where k is a given integer. You may assume that a and b are in small range Examples : Input : arr[] = {2, 3, 5, 4, 7} k = 3Output : (7, 4), (3, 4), (3, 5), (3, 7)7 % 4 = 33 % 4 = 33 % 5 = 33 % 7 =
15 min read
Group words with same set of characters
Given a list of words with lower cases. Implement a function to find all Words that have the same unique character set. Example: Input: words[] = { "may", "student", "students", "dog", "studentssess", "god", "cat", "act", "tab", "bat", "flow", "wolf", "lambs", "amy", "yam", "balms", "looped", "poodl
8 min read
k-th distinct (or non-repeating) element among unique elements in an array.
Given an integer array arr[], print kth distinct element in this array. The given array may contain duplicates and the output should print the k-th element among all unique elements. If k is more than the number of distinct elements, print -1.Examples:Input: arr[] = {1, 2, 1, 3, 4, 2}, k = 2Output:
7 min read
Intermediate problems on Hashing
Find Itinerary from a given list of tickets
Given a list of tickets, find the itinerary in order using the given list.Note: It may be assumed that the input list of tickets is not cyclic and there is one ticket from every city except the final destination.Examples:Input: "Chennai" -> "Bangalore" "Bombay" -> "Delhi" "Goa" -> "Chennai"
11 min read
Find number of Employees Under every Manager
Given a 2d matrix of strings arr[][] of order n * 2, where each array arr[i] contains two strings, where the first string arr[i][0] is the employee and arr[i][1] is his manager. The task is to find the count of the number of employees under each manager in the hierarchy and not just their direct rep
9 min read
Longest Subarray With Sum Divisible By K
Given an arr[] containing n integers and a positive integer k, he problem is to find the longest subarray's length with the sum of the elements divisible by k.Examples:Input: arr[] = [2, 7, 6, 1, 4, 5], k = 3Output: 4Explanation: The subarray [7, 6, 1, 4] has sum = 18, which is divisible by 3.Input:
10 min read
Longest Subarray with 0 Sum
Given an array arr[] of size n, the task is to find the length of the longest subarray with sum equal to 0.Examples:Input: arr[] = {15, -2, 2, -8, 1, 7, 10, 23}Output: 5Explanation: The longest subarray with sum equals to 0 is {-2, 2, -8, 1, 7}Input: arr[] = {1, 2, 3}Output: 0Explanation: There is n
10 min read
Longest Increasing consecutive subsequence
Given N elements, write a program that prints the length of the longest increasing consecutive subsequence. Examples: Input : a[] = {3, 10, 3, 11, 4, 5, 6, 7, 8, 12} Output : 6 Explanation: 3, 4, 5, 6, 7, 8 is the longest increasing subsequence whose adjacent element differs by one. Input : a[] = {6
10 min read
Count Distinct Elements In Every Window of Size K
Given an array arr[] of size n and an integer k, return the count of distinct numbers in all windows of size k. Examples: Input: arr[] = [1, 2, 1, 3, 4, 2, 3], k = 4Output: [3, 4, 4, 3]Explanation: First window is [1, 2, 1, 3], count of distinct numbers is 3. Second window is [2, 1, 3, 4] count of d
10 min read
Design a data structure that supports insert, delete, search and getRandom in constant time
Design a data structure that supports the following operations in O(1) time.insert(x): Inserts an item x to the data structure if not already present.remove(x): Removes item x from the data structure if present. search(x): Searches an item x in the data structure.getRandom(): Returns a random elemen
5 min read
Subarray with Given Sum - Handles Negative Numbers
Given an unsorted array of integers, find a subarray that adds to a given number. If there is more than one subarray with the sum of the given number, print any of them.Examples: Input: arr[] = {1, 4, 20, 3, 10, 5}, sum = 33Output: Sum found between indexes 2 and 4Explanation: Sum of elements betwee
13 min read
Implementing our Own Hash Table with Separate Chaining in Java
All data structure has their own special characteristics, for example, a BST is used when quick searching of an element (in log(n)) is required. A heap or a priority queue is used when the minimum or maximum element needs to be fetched in constant time. Similarly, a hash table is used to fetch, add
10 min read
Implementing own Hash Table with Open Addressing Linear Probing
In Open Addressing, all elements are stored in the hash table itself. So at any point, size of table must be greater than or equal to total number of keys (Note that we can increase table size by copying old data if needed).Insert(k) - Keep probing until an empty slot is found. Once an empty slot is
13 min read
Maximum possible difference of two subsets of an array
Given an array of n-integers. The array may contain repetitive elements but the highest frequency of any element must not exceed two. You have to make two subsets such that the difference of the sum of their elements is maximum and both of them jointly contain all elements of the given array along w
15+ min read
Sorting using trivial hash function
We have read about various sorting algorithms such as heap sort, bubble sort, merge sort and others. Here we will see how can we sort N elements using a hash array. But this algorithm has a limitation. We can sort only those N elements, where the value of elements is not large (typically not above 1
15+ min read
Smallest subarray with k distinct numbers
We are given an array consisting of n integers and an integer k. We need to find the smallest subarray [l, r] (both l and r are inclusive) such that there are exactly k different numbers. If no such subarray exists, print -1 and If multiple subarrays meet the criteria, return the one with the smalle
14 min read