Count of index triplets (i, j, k) in given Array such that i<j<k and a[j]<a[k]<a[i]

Given an array arr[], the task is to count the number of triplets such that i < j <k and a[ j ]< a[ k ]< a[ i ]. 

Examples:

Input:  arr[] = {1, 2, 3, 4, 5}
Output: -1
Explanation: There is no triplets of required type.

Input:  arr[] = {4, 1, 3, 5}
Output: 1
Explanation: There is a  triplet in array a[]: {4, 1, 3 }.

Input:  arr[] = {2, 1, -3, -2, 5}
Output: 2
Explanation: There are  two triplets of required type: {2, 1, -3}, {1, -3, -2}

Naive Approach: Use three loops to check for all the possible triplets in a[] and count the number of triplets in arr[] such that i<j<k and a[ j ]< a[ k ]< a[ i ]. Below is the implementation of the above approach. 

C++

// C++ code for the above approach
#include <bits/stdc++.h>
using namespace std;

int findTriplets(int a[], int n)
{

    // To count desired triplets
    int cnt = 0;

    // Three loops to find triplets
    for (int i = 0; i < n; i++)
    {
        for (int j = i + 1; j < n; j++)
        {
            for (int k = j + 1; k < n; k++)
            {

                if (a[j] < a[k] && a[k] < a[i])
                    cnt++;
            }
        }
    }

    // Return the number of triplets found
    return cnt;
}

// Driver code
int main()
{
    int a[] = {2, 1, -3, -2, 5};
    int n = sizeof(a) / sizeof(a[0]);

    cout << (findTriplets(a, n));
    return 0;
}

// This code is contributed by Potta Lokesh

Java

// Java Program for above approach
import java.io.*;

class GFG {

    public static int findTriplets(int[] a)
    {

        // To count desired triplets
        int cnt = 0;

        // Three loops to find triplets
        for (int i = 0; i < a.length; i++) {
            for (int j = i + 1; j < a.length; j++) {
                for (int k = j + 1; k < a.length; k++) {

                    if (a[j] < a[k] && a[k] < a[i])
                        cnt++;
                }
            }
        }

        // Return the number of triplets found
        return cnt;
    }

    // Driver code
    public static void main(String[] args)
    {
        int a[] = { 2, 1, -3, -2, 5 };

        System.out.println(findTriplets(a));
    }
}

Python3

# Python Program for above approach
def findTriplets(a):

  # To count desired triplets
  cnt = 0;

  # Three loops to find triplets
  for i in range(len(a)):
    for j in range(i + 1, len(a)):
      for k in range(j + 1, len(a)):
        if (a[j] < a[k] and a[k] < a[i]):
          cnt += 1

  # Return the number of triplets found
  return cnt;

# Driver code
a = [2, 1, -3, -2, 5];
print(findTriplets(a));

# This code is contributed by Saurabh Jaiswal

C#

// C# Program for above approach
using System;
public class GFG {

  public static int findTriplets(int[] a)
  {

    // To count desired triplets
    int cnt = 0;

    // Three loops to find triplets
    for (int i = 0; i < a.Length; i++) {
      for (int j = i + 1; j < a.Length; j++) {
        for (int k = j + 1; k < a.Length; k++) {

          if (a[j] < a[k] && a[k] < a[i])
            cnt++;
        }
      }
    }

    // Return the number of triplets found
    return cnt;
  }

  // Driver code
  public static void Main(String[] args)
  {
    int []a = { 2, 1, -3, -2, 5 };

    Console.WriteLine(findTriplets(a));
  }
}

// This code is contributed by 29AjayKumar

Javascript

<script>
// Javascript Program for above approach
function findTriplets(a) {

  // To count desired triplets
  let cnt = 0;

  // Three loops to find triplets
  for (let i = 0; i < a.length; i++) {
    for (let j = i + 1; j < a.length; j++) {
      for (let k = j + 1; k < a.length; k++) {

        if (a[j] < a[k] && a[k] < a[i])
          cnt++;
      }
    }
  }

  // Return the number of triplets found
  return cnt;
}

// Driver code

let a = [2, 1, -3, -2, 5];

document.write(findTriplets(a));

// This code is contributed by gfgking.
</script>

Output

2

Time Complexity: O(N³)
Auxiliary Space: O(1)

Efficient Approach: A Stack can be used to optimize the above solution. The stack will keep track of the next smaller and second smaller element on the right side. 

Follow the steps below to solve the given problem. 

• Create a stack and variable say secondMin = INT_MAX.
• Declare a variable say cnt = 0, to store the number of desired triplets.
• Start traversing from the end of the array a[].
  • Check if the current element is greater than the secondMin, if it is that means, the required triplet is found because the stack is keeping track of the next smaller and second smaller elements and the current element satisfies the type. Then, set cnt = cnt + 1.
  • If the above condition is not satisfied, update the minimum value in the stack, keep popping until stack is not empty or the current element is not smaller than the top of the stack.
  • Push current element in the stack
• At last return cnt as the number of triplets found.

Below is the implementation of the above approach:

C++

// C++ program for above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find desired triplets
int findTriplets(vector<int>& a)
{

    // To store the number of triplets found
    int cnt = 0;

    stack<int> st;

    // Keep track of second minimum element
    int secondMin = INT_MAX;

    for (int i = a.size() - 1; i >= 0; i--) {

        // If required triplet is found
        if (a[i] > secondMin)
            cnt++;

        while (!st.empty() && st.top() > a[i]) {

            secondMin = st.top();
            st.pop();
        }
        st.push(a[i]);
    }

    // Return the number of triplets found
    return cnt;
}

// Driver code
int main()
{
    vector<int> a = { 2, 1, -3, -2, 5 };

    // Print the required result
    cout << findTriplets(a);
    return 0;
}

    // This code is contributed by rakeshsahni

Java

// Java program for above approach
import java.io.*;
import java.util.*;

class GFG {

    // Function to find desired triplets
    public static int findTriplets(int[] a)
    {

        // To store the number of triplets found
        int cnt = 0;

        Stack<Integer> stack = new Stack<>();

        // Keep track of second minimum element
        int secondMin = Integer.MAX_VALUE;

        for (int i = a.length - 1; i >= 0; i--) {

            // If required triplet is found
            if (a[i] > secondMin)
                cnt++;

            while (!stack.isEmpty()
                   && stack.peek() > a[i]) {

                secondMin = stack.pop();
            }
            stack.push(a[i]);
        }

        // Return the number of triplets found
        return cnt;
    }

    // Driver code
    public static void main(String[] args)
    {
        int a[] = { 2, 1, -3, -2, 5 };

        // Print the required result
        System.out.println(findTriplets(a));
    }
}

Python3

# Python 3 program for above approach
import sys

# Function to find desired triplets
def findTriplets(a):

    # To store the number of triplets found
    cnt = 0
    st = []

    # Keep track of second minimum element
    secondMin = sys.maxsize
    for i in range(len(a) - 1, -1, -1):

        # If required triplet is found
        if (a[i] > secondMin):
            cnt += 1

        while (not len(st) == 0 and st[-1] > a[i]):

            secondMin = st[-1]
            st.pop()

        st.append(a[i])

    # Return the number of triplets found
    return cnt

# Driver code
if __name__ == "__main__":
    a = [2, 1, -3, -2, 5]

    # Print the required result
    print(findTriplets(a))

    # This code is contributed by ukasp.

C#

// C# program for above approach

using System;
using System.Collections.Generic;

public class GFG {

    // Function to find desired triplets
    public static int findTriplets(int[] a)
    {

        // To store the number of triplets found
        int cnt = 0;

        Stack<int> stack = new Stack<int>();

        // Keep track of second minimum element
        int secondMin = int.MaxValue;

        for (int i = a.Length - 1; i >= 0; i--) {

            // If required triplet is found
            if (a[i] > secondMin)
                cnt++;

            while (stack.Count!=0
                   && stack.Peek() > a[i]) {

                secondMin = stack.Pop();
            }
            stack.Push(a[i]);
        }

        // Return the number of triplets found
        return cnt;
    }

    // Driver code
    public static void Main(String[] args)
    {
        int []a = { 2, 1, -3, -2, 5 };

        // Print the required result
        Console.WriteLine(findTriplets(a));
    }
}

// This code is contributed by shikhasingrajput

Javascript

<script>
// javascript program for above approach
// Function to find desired triplets
    function findTriplets(a)
    {

        // To store the number of triplets found
        var cnt = 0;

        var stack = [];

        // Keep track of second minimum element
        var secondMin = Number.MAX_VALUE;

        for (var i = a.length - 1; i >= 0; i--) {

            // If required triplet is found
            if (a[i] > secondMin)
                cnt++;

            while (stack.length!=0
                   && stack[0] > a[i]) {

                secondMin = stack.pop();
            }
            stack.push(a[i]);
        }

        // Return the number of triplets found
        return cnt;
    }

// Driver code
var a = [ 2, 1, -3, -2, 5 ];

// Print the required result
document.write(findTriplets(a));

// This code is contributed by shikhasingrajput
</script>

Output

2

Time Complexity: O(N)
Auxiliary Space: O(N)