Related Articles

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

• Difficulty Level : Medium
• Last Updated : 01 Jun, 2021

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`

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up