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

• Difficulty Level : Medium
• Last Updated : 21 Jun, 2022

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

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

 ``

## Javascript

 ``

Output:

`3`

Time Complexity: O(nlog(n))
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up