# Count of quadruplets with given sum | Set 3

• Last Updated : 27 Feb, 2023

Given four arrays containing integer elements and an integer sum, the task is to count the quadruplets such that each element is chosen from a different array and the sum of all the four elements is equal to the given sum. Examples:

Input: P[] = {0, 2}, Q[] = {-1, -2}, R[] = {2, 1}, S[] = {2, -1}, sum = 0 Output: 2 (0, -1, 2, -1) and (2, -2, 1, -1) are the required quadruplets. Input: P[] = {1, -1, 2, 3, 4}, Q[] = {3, 2, 4}, R[] = {-2, -1, 2, 1}, S[] = {4, -1}, sum = 3 Output: 10

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: Two different approaches to solve this problem has been discussed in Set 1 and Set 2 of this article. Here, an approach using the binary search will be discussed. Pick any two arrays and calculate all the possible pair sums and store them in a vector. Now, pick the other two arrays and calculate all possible sums and for every sum say tempSum, check whether sum – temp exists in the vector created earlier (after sorting it) using the binary search. Below is the implementation of the above approach:

## CPP

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return the count``// of the required quadruplets``int` `countQuadruplets(``int` `arr1[], ``int` `n1, ``int` `arr2[],``                     ``int` `n2, ``int` `arr3[], ``int` `n3,``                     ``int` `arr4[], ``int` `n4, ``int` `value)` `{``    ``vector<``int``> sum1;``    ``vector<``int``>::iterator it;``    ``vector<``int``>::iterator it2;``    ``int` `cnt = 0;` `    ``// Take every possible pair sum``    ``// from the two arrays``    ``for` `(``int` `i = 0; i < n1; i++) {``        ``for` `(``int` `j = 0; j < n2; j++) {` `            ``// Push the sum to a vector``            ``sum1.push_back(arr1[i] + arr2[j]);``        ``}``    ``}` `    ``// Sort the sum vector``    ``sort(sum1.begin(), sum1.end());` `    ``// Calculate the pair sums from``    ``// the other two arrays``    ``for` `(``int` `i = 0; i < n3; i++) {``        ``for` `(``int` `j = 0; j < n4; j++) {` `            ``// Calculate the sum``            ``int` `temp = arr3[i] + arr4[j];` `            ``// Check whether temp can be added to any``            ``// sum stored in the sum1 vector such that``            ``// the result is the required sum``            ``if` `(binary_search(sum1.begin(), sum1.end(), value - temp)) {` `                ``// Add the count of such values from the sum1 vector``                ``it = lower_bound(sum1.begin(), sum1.end(), value - temp);``                ``it2 = upper_bound(sum1.begin(), sum1.end(), value - temp);``                ``cnt = cnt + ((it2 - sum1.begin()) - (it - sum1.begin()));``            ``}``        ``}``    ``}` `    ``return` `cnt;``}` `// Driver code``int` `main()``{``    ``int` `arr1[] = { 0, 2 };``    ``int` `n1 = ``sizeof``(arr1) / ``sizeof``(arr1[0]);` `    ``int` `arr2[] = { -1, -2 };``    ``int` `n2 = ``sizeof``(arr2) / ``sizeof``(arr2[0]);` `    ``int` `arr3[] = { 2, 1 };``    ``int` `n3 = ``sizeof``(arr3) / ``sizeof``(arr3[0]);` `    ``int` `arr4[] = { 2, -1 };``    ``int` `n4 = ``sizeof``(arr4) / ``sizeof``(arr4[0]);` `    ``int` `sum = 0;` `    ``cout << countQuadruplets(arr1, n1, arr2, n2,``                             ``arr3, n3, arr4, n4, sum);` `    ``return` `0;``}`

## Java

 `import` `java.util.Arrays;``import` `java.util.Vector;``import` `java.util.*;` `// Function to return the count``// of the required quadruplets``class` `Main{``public` `static` `int` `countQuadruplets(``int``[] arr1, ``int` `n1, ``int``[] arr2,``                ``int` `n2, ``int``[] arr3, ``int` `n3,``                 ``int``[] arr4, ``int` `n4, ``int` `value)``{``    ``Vector sum1 = ``new` `Vector<>();``    ``int` `cnt = ``0``;` `    ``// Take every possible pair sum``    ``// from the two arrays``    ``for` `(``int` `i = ``0``; i < n1; i++) {``        ``for` `(``int` `j = ``0``; j < n2; j++) {` `            ``// Push the sum to a vector``            ``sum1.add(arr1[i] + arr2[j]);``        ``}``    ``}` `    ``// Sort the sum vector``    ``sum1.sort(``null``);` `    ``// Calculate the pair sums from``    ``// the other two arrays``    ``for` `(``int` `i = ``0``; i < n3; i++) {``        ``for` `(``int` `j = ``0``; j < n4; j++) {` `            ``// Calculate the sum``            ``int` `temp = arr3[i] + arr4[j];` `            ``// Check whether temp can be added to any``            ``// sum stored in the sum1 vector such that``            ``// the result is the required sum``            ``if` `(Collections.binarySearch(sum1, value - temp) >= ``0``) {` `                ``// Add the count of such values from the sum1 vector``                ``int` `it = Collections.binarySearch(sum1, value - temp);``                ``int` `it2 = it + ``1``;``                ``while` `(it2 < sum1.size() && sum1.get(it2).equals(value - temp)) {``                    ``it2++;``                ``}``                ``cnt = cnt + (it2 - it);``            ``}``        ``}``    ``}` `    ``return` `cnt;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int``[] arr1 = { ``0``, ``2` `};``    ``int` `n1 = arr1.length;` `    ``int``[] arr2 = { -``1``, -``2` `};``    ``int` `n2 = arr2.length;` `    ``int``[] arr3 = { ``2``, ``1` `};``    ``int` `n3 = arr3.length;` `    ``int``[] arr4 = { ``2``, -``1` `};``    ``int` `n4 = arr4.length;` `    ``int` `sum = ``0``;` `    ``System.out.println(countQuadruplets(arr1, n1, arr2, n2,``                     ``arr3, n3, arr4, n4, sum));``}``}`

## Python3

 `from` `typing ``import` `List``import` `bisect` `def` `countQuadruplets(arr1: ``List``[``int``], n1: ``int``, arr2: ``List``[``int``], n2: ``int``,``                ``arr3: ``List``[``int``], n3: ``int``, arr4: ``List``[``int``], n4: ``int``, value: ``int``) ``-``> ``int``:` `    ``sum1 ``=` `[]` `    ``# Take every possible pair sum from the two arrays``    ``for` `i ``in` `range``(n1):``        ``for` `j ``in` `range``(n2):``            ``# Append the sum to the list``            ``sum1.append(arr1[i] ``+` `arr2[j])` `    ``# Sort the sum list``    ``sum1.sort()` `    ``cnt ``=` `0` `    ``# Calculate the pair sums from the other two arrays``    ``for` `i ``in` `range``(n3):``        ``for` `j ``in` `range``(n4):``            ``# Calculate the sum``            ``temp ``=` `arr3[i] ``+` `arr4[j]` `            ``# Check whether temp can be added to any sum stored in the sum1``            ``# list such that the result is the required sum``            ``index ``=` `bisect.bisect_left(sum1, value ``-` `temp)` `            ``if` `index !``=` `len``(sum1) ``and` `sum1[index] ``=``=` `value ``-` `temp:``                ``# Add the count of such values from the sum1 list``                ``it ``=` `index``                ``it2 ``=` `it ``+` `1``                ``while` `it2 < ``len``(sum1) ``and` `sum1[it2] ``=``=` `value ``-` `temp:``                    ``it2 ``+``=` `1``                ``cnt ``+``=` `(it2 ``-` `it)` `    ``return` `cnt` `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ``arr1 ``=` `[``0``, ``2``]``    ``n1 ``=` `len``(arr1)` `    ``arr2 ``=` `[``-``1``, ``-``2``]``    ``n2 ``=` `len``(arr2)` `    ``arr3 ``=` `[``2``, ``1``]``    ``n3 ``=` `len``(arr3)` `    ``arr4 ``=` `[``2``, ``-``1``]``    ``n4 ``=` `len``(arr4)` `    ``sum` `=` `0` `    ``print``(countQuadruplets(arr1, n1, arr2, n2, arr3, n3, arr4, n4, ``sum``))``    ` ` ``# This code is contributed by Prince Kumar`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG``{``  ``// Function to return the count``  ``// of the required quadruplets``  ``public` `static` `int` `CountQuadruplets(``int``[] arr1, ``int` `n1, ``int``[] arr2,``                                     ``int` `n2, ``int``[] arr3, ``int` `n3,``                                     ``int``[] arr4, ``int` `n4, ``int` `value)``  ``{``    ``List<``int``> sum1 = ``new` `List<``int``>();``    ``int` `cnt = 0;` `    ``// Take every possible pair sum``    ``// from the two arrays``    ``for` `(``int` `i = 0; i < n1; i++)``    ``{``      ``for` `(``int` `j = 0; j < n2; j++)``      ``{``        ``// Push the sum to a vector``        ``sum1.Add(arr1[i] + arr2[j]);``      ``}``    ``}` `    ``// Sort the sum vector``    ``sum1.Sort();` `    ``// Calculate the pair sums from``    ``// the other two arrays``    ``for` `(``int` `i = 0; i < n3; i++)``    ``{``      ``for` `(``int` `j = 0; j < n4; j++)``      ``{``        ``// Calculate the sum``        ``int` `temp = arr3[i] + arr4[j];` `        ``// Check whether temp can be added to any``        ``// sum stored in the sum1 vector such that``        ``// the result is the required sum``        ``if` `(sum1.BinarySearch(value - temp) >= 0)``        ``{``          ``// Add the count of such values from the sum1 vector``          ``int` `it = sum1.BinarySearch(value - temp);``          ``int` `it2 = it + 1;``          ``while` `(it2 < sum1.Count && sum1[it2] == (value - temp))``          ``{``            ``it2++;``          ``}``          ``cnt = cnt + (it2 - it);``        ``}``      ``}``    ``}` `    ``return` `cnt;``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int``[] arr1 = { 0, 2 };``    ``int` `n1 = arr1.Length;` `    ``int``[] arr2 = { -1, -2 };``    ``int` `n2 = arr2.Length;` `    ``int``[] arr3 = { 2, 1 };``    ``int` `n3 = arr3.Length;` `    ``int``[] arr4 = { 2, -1 };``    ``int` `n4 = arr4.Length;` `    ``int` `sum = 0;` `    ``Console.WriteLine(CountQuadruplets(arr1, n1, arr2, n2,``                                       ``arr3, n3, arr4, n4, sum));``  ``}``}` `// This code is contributed by Aman Kumar.`

## Javascript

 `// Function to return the count``// of the required quadruplets``function` `countQuadruplets(arr1, n1, arr2, n2, arr3, n3, arr4, n4, value) {``  ``let sum1 = [];` `  ``// Take every possible pair sum``  ``// from the two arrays``  ``for` `(let i = 0; i < n1; i++) {``    ``for` `(let j = 0; j < n2; j++) {` `      ``// Push the sum to an array``      ``sum1.push(arr1[i] + arr2[j]);``    ``}``  ``}` `  ``// Sort the sum array``  ``sum1.sort((a, b) => a - b);` `  ``let cnt = 0;` `  ``// Calculate the pair sums from``  ``// the other two arrays``  ``for` `(let i = 0; i < n3; i++) {``    ``for` `(let j = 0; j < n4; j++) {` `      ``// Calculate the sum``      ``let temp = arr3[i] + arr4[j];` `      ``// Check whether temp can be added to any``      ``// sum stored in the sum1 array such that``      ``// the result is the required sum``      ``if` `(binarySearch(sum1, value - temp) >= 0) {` `        ``// Add the count of such values from the sum1 array``        ``let it = binarySearch(sum1, value - temp);``        ``let it2 = it + 1;``        ``while` `(it2 < sum1.length && sum1[it2] === value - temp) {``          ``it2++;``        ``}``        ``cnt = cnt + (it2 - it);``      ``}``    ``}``  ``}` `  ``return` `cnt;``}` `// Binary search function to search for an element in the array``function` `binarySearch(arr, x) {``  ``let l = 0, r = arr.length - 1;``  ``while` `(l <= r) {``    ``let m = Math.floor((l + r) / 2);``    ``if` `(arr[m] === x) {``      ``return` `m;``    ``} ``else` `if` `(arr[m] < x) {``      ``l = m + 1;``    ``} ``else` `{``      ``r = m - 1;``    ``}``  ``}``  ``return` `-1;``}` `// Driver code``let arr1 = [0, 2];``let n1 = arr1.length;` `let arr2 = [-1, -2];``let n2 = arr2.length;` `let arr3 = [2, 1];``let n3 = arr3.length;` `let arr4 = [2, -1];``let n4 = arr4.length;` `let sum = 0;` `console.log(countQuadruplets(arr1, n1, arr2, n2, arr3, n3, arr4, n4, sum));`

Output:

`2`

Time Complexity: O(n*log(n)+m*log(n)) where n=n1*n2 and m=n3*n4

Auxiliary Space: O(n)

My Personal Notes arrow_drop_up