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



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

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
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[0]);
  
    cout << countTriplets(size, a, b, c);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of the approach
  
// Function to return the count
// of elements in arr[] which are
// less than the given key
function countLessThan(&$arr, $n, $key)
{
    $l = 0;
    $r = $n - 1;
    $index = -1;
  
    // Modified binary search
    while ($l <= $r
    {
        $m = intval(($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
function countGreaterThan(&$arr, $n, $key)
{
    $l = 0;
    $r = $n - 1;
    $index = -1;
  
    // Modified binary search
    while ($l <= $r)
    {
        $m = intval(($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
function countTriplets($n, &$a, &$b, &$c)
{
    // Sort all three arrays
    sort($a);
    sort($b);
    sort($c);
  
    $count = 0;
  
    // Iterate for all the elements of array B
    for ($i = 0; $i < $n; ++$i
    {
        $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
$a = array( 1, 5 );
$b = array( 2, 4 );
$c = array( 3, 6 );
$size = sizeof($a);
  
echo countTriplets($size, $a, $b, $c);
  
// This code is contributed by ChitraNayal
?>

chevron_right


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.