# Count the triplets such that A[i] < B[j] < C[k]

Given three array A[], B[] and C[] of N integers each. The task is to find the count of triplets (A[i], B[j], C[k]) such that A[i] < B[j] < C[k].

Input: A[] = {1, 5}, B[] = {2, 4}, C[] = {3, 6}
Output: 3
Triplets are (1, 2, 3), (1, 4, 6) and (1, 2, 6)

Input: A[] = {1, 1, 1}, B[] = {2, 2, 2}, C[] = {3, 3, 3}
Output: 27

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

Approach: Sort all the given arrays. Now fix an element say X in array B[] and for each X, the answer will be the product of the count of elements in array A[] which are less than X and the count of elements in array C[] which are greater than X. We can compute both of these counts using modified binary search.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the count ` `// of elements in arr[] which are ` `// less than the given key ` `int` `countLessThan(``int` `arr[], ``int` `n, ``int` `key) ` `{ ` `    ``int` `l = 0, r = n - 1; ` `    ``int` `index = -1; ` ` `  `    ``// Modified binary search ` `    ``while` `(l <= r) { ` `        ``int` `m = (l + r) / 2; ` ` `  `        ``if` `(arr[m] < key) { ` `            ``l = m + 1; ` `            ``index = m; ` `        ``} ` `        ``else` `{ ` `            ``r = m - 1; ` `        ``} ` `    ``} ` ` `  `    ``return` `(index + 1); ` `} ` ` `  `// Function to return the count ` `// of elements in arr[] which are ` `// greater than the given key ` `int` `countGreaterThan(``int` `arr[], ``int` `n, ``int` `key) ` `{ ` `    ``int` `l = 0, r = n - 1; ` `    ``int` `index = -1; ` ` `  `    ``// Modified binary search ` `    ``while` `(l <= r) { ` `        ``int` `m = (l + r) / 2; ` ` `  `        ``if` `(arr[m] <= key) { ` `            ``l = m + 1; ` `        ``} ` `        ``else` `{ ` `            ``r = m - 1; ` `            ``index = m; ` `        ``} ` `    ``} ` ` `  `    ``if` `(index == -1) ` `        ``return` `0; ` `    ``return` `(n - index); ` `} ` ` `  `// Function to return the count ` `// of the required triplets ` `int` `countTriplets(``int` `n, ``int``* a, ``int``* b, ``int``* c) ` `{ ` `    ``// Sort all three arrays ` `    ``sort(a, a + n); ` `    ``sort(b, b + n); ` `    ``sort(c, c + n); ` ` `  `    ``int` `count = 0; ` ` `  `    ``// Iterate for all the elements of array B ` `    ``for` `(``int` `i = 0; i < n; ++i) { ` `        ``int` `current = b[i]; ` `        ``int` `a_index = -1, c_index = -1; ` ` `  `        ``// Count of elements in A[] ` `        ``// which are less than the ` `        ``// chosen element from B[] ` `        ``int` `low = countLessThan(a, n, current); ` ` `  `        ``// Count of elements in C[] ` `        ``// which are greater than the ` `        ``// chosen element from B[] ` `        ``int` `high = countGreaterThan(c, n, current); ` ` `  `        ``// Update the count ` `        ``count += (low * high); ` `    ``} ` ` `  `    ``return` `count; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `a[] = { 1, 5 }; ` `    ``int` `b[] = { 2, 4 }; ` `    ``int` `c[] = { 3, 6 }; ` `    ``int` `size = ``sizeof``(a) / ``sizeof``(a); ` ` `  `    ``cout << countTriplets(size, a, b, c); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach  ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{  ` ` `  `    ``// Function to return the count  ` `    ``// of elements in arr[] which are  ` `    ``// less than the given key  ` `    ``static` `int` `countLessThan(``int` `arr[], ``int` `n, ``int` `key)  ` `    ``{  ` `        ``int` `l = ``0``, r = n - ``1``;  ` `        ``int` `index = -``1``;  ` `     `  `        ``// Modified binary search  ` `        ``while` `(l <= r)  ` `        ``{  ` `            ``int` `m = (l + r) / ``2``;  ` `     `  `            ``if` `(arr[m] < key)  ` `            ``{  ` `                ``l = m + ``1``;  ` `                ``index = m;  ` `            ``}  ` `            ``else` `            ``{  ` `                ``r = m - ``1``;  ` `            ``}  ` `        ``}  ` `     `  `        ``return` `(index + ``1``);  ` `    ``}  ` `     `  `    ``// Function to return the count  ` `    ``// of elements in arr[] which are  ` `    ``// greater than the given key  ` `    ``static` `int` `countGreaterThan(``int` `arr[], ``int` `n, ``int` `key)  ` `    ``{  ` `        ``int` `l = ``0``, r = n - ``1``;  ` `        ``int` `index = -``1``;  ` `     `  `        ``// Modified binary search  ` `        ``while` `(l <= r)  ` `        ``{  ` `            ``int` `m = (l + r) / ``2``;  ` `     `  `            ``if` `(arr[m] <= key)  ` `            ``{  ` `                ``l = m + ``1``;  ` `            ``}  ` `            ``else` `            ``{  ` `                ``r = m - ``1``;  ` `                ``index = m;  ` `            ``}  ` `        ``}  ` `     `  `        ``if` `(index == -``1``)  ` `            ``return` `0``;  ` `        ``return` `(n - index);  ` `    ``}  ` `     `  `    ``// Function to return the count  ` `    ``// of the required triplets  ` `    ``static` `int` `countTriplets(``int` `n, ``int` `a[], ``int` `b[], ``int` `c[])  ` `    ``{  ` `        ``// Sort all three arrays  ` `        ``Arrays.sort(a) ;  ` `        ``Arrays.sort(b);  ` `        ``Arrays.sort(c);  ` `     `  `        ``int` `count = ``0``;  ` `     `  `        ``// Iterate for all the elements of array B  ` `        ``for` `(``int` `i = ``0``; i < n; ++i)  ` `        ``{  ` `            ``int` `current = b[i];  ` `         `  `     `  `            ``// Count of elements in A[]  ` `            ``// which are less than the  ` `            ``// chosen element from B[]  ` `            ``int` `low = countLessThan(a, n, current);  ` `     `  `            ``// Count of elements in C[]  ` `            ``// which are greater than the  ` `            ``// chosen element from B[]  ` `            ``int` `high = countGreaterThan(c, n, current);  ` `     `  `            ``// Update the count  ` `            ``count += (low * high);  ` `        ``}  ` `     `  `        ``return` `count;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `main(String args[])  ` `    ``{  ` `        ``int` `a[] = { ``1``, ``5` `};  ` `        ``int` `b[] = { ``2``, ``4` `};  ` `        ``int` `c[] = { ``3``, ``6` `};  ` `        ``int` `size = a.length;  ` `     `  `        ``System.out.println(countTriplets(size, a, b, c));  ` `     `  `    ``}  ` `}  ` `// This code is contributed by Arnab Kundu `

## Python 3

 `# Python 3 implementation of the approach ` ` `  `# Function to return the count ` `# of elements in arr[] which are ` `# less than the given key ` `def` `countLessThan(arr, n, key): ` `    ``l ``=` `0` `    ``r ``=` `n ``-` `1` `    ``index ``=` `-``1` ` `  `    ``# Modified binary search ` `    ``while` `(l <``=` `r): ` `        ``m ``=` `(l ``+` `r) ``/``/` `2` ` `  `        ``if` `(arr[m] < key) : ` `            ``l ``=` `m ``+` `1` `            ``index ``=` `m ` `         `  `        ``else` `: ` `            ``r ``=` `m ``-` `1` `         `  `    ``return` `(index ``+` `1``) ` ` `  `# Function to return the count ` `# of elements in arr[] which are ` `# greater than the given key ` `def` `countGreaterThan(arr, n, key): ` ` `  `    ``l ``=` `0` `    ``r ``=` `n ``-` `1` `    ``index ``=` `-``1` ` `  `    ``# Modified binary search ` `    ``while` `(l <``=` `r) : ` `        ``m ``=` `(l ``+` `r) ``/``/` `2` ` `  `        ``if` `(arr[m] <``=` `key) : ` `            ``l ``=` `m ``+` `1` `        ``else` `: ` `            ``r ``=` `m ``-` `1` `            ``index ``=` `m ` ` `  `    ``if` `(index ``=``=` `-``1``): ` `        ``return` `0` `    ``return` `(n ``-` `index) ` ` `  ` `  `# Function to return the count ` `# of the required triplets ` `def` `countTriplets(n, a, b, c): ` ` `  `    ``# Sort all three arrays ` `    ``a.sort ` `    ``b.sort() ` `    ``c.sort() ` ` `  `    ``count ``=` `0` ` `  `    ``# Iterate for all the elements of array B ` `    ``for` `i ``in` `range``(n): ` `        ``current ``=` `b[i] ` `        ``a_index ``=` `-``1` `        ``c_index ``=` `-``1` ` `  `        ``# Count of elements in A[] ` `        ``# which are less than the ` `        ``# chosen element from B[] ` `        ``low ``=` `countLessThan(a, n, current) ` ` `  `        ``# Count of elements in C[] ` `        ``# which are greater than the ` `        ``# chosen element from B[] ` `        ``high ``=` `countGreaterThan(c, n, current) ` ` `  `        ``# Update the count ` `        ``count ``+``=` `(low ``*` `high) ` ` `  `    ``return` `count ` ` `  ` `  `# Driver code ` `if` `__name__ ``=``=` `"__main__"``: ` ` `  `    ``a ``=` `[ ``1``, ``5` `] ` `    ``b ``=` `[ ``2``, ``4` `] ` `    ``c ``=` `[ ``3``, ``6` `] ` `    ``size ``=` `len``(a) ` ` `  `    ``print``( countTriplets(size, a, b, c)) ` `     `  `# This code is contributed by ChitraNayal `

## C#

 `// C# implementation of the approach  ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `    ``// Function to return the count  ` `    ``// of elements in arr[] which are  ` `    ``// less than the given key  ` `    ``static` `int` `countLessThan(``int` `[]arr, ``int` `n, ``int` `key)  ` `    ``{  ` `        ``int` `l = 0, r = n - 1;  ` `        ``int` `index = -1;  ` `     `  `        ``// Modified binary search  ` `        ``while` `(l <= r) ` `        ``{  ` `            ``int` `m = (l + r) / 2;  ` `     `  `            ``if` `(arr[m] < key)  ` `            ``{  ` `                ``l = m + 1;  ` `                ``index = m;  ` `            ``}  ` `            ``else`  `            ``{  ` `                ``r = m - 1;  ` `            ``}  ` `        ``}  ` `     `  `        ``return` `(index + 1);  ` `    ``}  ` `     `  `    ``// Function to return the count  ` `    ``// of elements in arr[] which are  ` `    ``// greater than the given key  ` `    ``static` `int` `countGreaterThan(``int` `[]arr, ``int` `n, ``int` `key)  ` `    ``{  ` `        ``int` `l = 0, r = n - 1;  ` `        ``int` `index = -1;  ` `     `  `        ``// Modified binary search  ` `        ``while` `(l <= r) ` `        ``{  ` `            ``int` `m = (l + r) / 2;  ` `     `  `            ``if` `(arr[m] <= key)  ` `            ``{  ` `                ``l = m + 1;  ` `            ``}  ` `            ``else` `            ``{  ` `                ``r = m - 1;  ` `                ``index = m;  ` `            ``}  ` `        ``}  ` `     `  `        ``if` `(index == -1)  ` `            ``return` `0;  ` `        ``return` `(n - index);  ` `    ``}  ` `     `  `    ``// Function to return the count  ` `    ``// of the required triplets  ` `    ``static` `int` `countTriplets(``int` `n, ``int` `[]a, ``int` `[]b, ``int` `[]c)  ` `    ``{  ` `        ``// Sort all three arrays  ` `        ``Array.Sort(a) ;  ` `        ``Array.Sort(b);  ` `        ``Array.Sort(c);  ` `     `  `        ``int` `count = 0;  ` `     `  `        ``// Iterate for all the elements of array B  ` `        ``for` `(``int` `i = 0; i < n; ++i) ` `        ``{  ` `            ``int` `current = b[i];  ` `         `  `     `  `            ``// Count of elements in A[]  ` `            ``// which are less than the  ` `            ``// chosen element from B[]  ` `            ``int` `low = countLessThan(a, n, current);  ` `     `  `            ``// Count of elements in C[]  ` `            ``// which are greater than the  ` `            ``// chosen element from B[]  ` `            ``int` `high = countGreaterThan(c, n, current);  ` `     `  `            ``// Update the count  ` `            ``count += (low * high);  ` `        ``}  ` `     `  `        ``return` `count;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main()  ` `    ``{  ` `        ``int` `[]a = { 1, 5 };  ` `        ``int` `[]b = { 2, 4 };  ` `        ``int` `[]c = { 3, 6 };  ` `        ``int` `size = a.Length;  ` `     `  `        ``Console.WriteLine(countTriplets(size, a, b, c));  ` `     `  `    ``}  ` `} ` ` `  `// This code is contributed by AnkitRai01 `

## PHP

 ` `

Output:

```3
```

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.