Related Articles

# Count of triplets of numbers 1 to N such that middle element is always largest

• Last Updated : 07 Sep, 2021

Given an integer N, the task is to count the number of ways to arrange triplets (a, b, c) within [1, N] in such a way such that the middle element is always greater than left and right elements.

Example:
Input: N = 4
Output:
Explaination
For the given input N = 4 number of possible triplets are:{1, 3, 2}, {2, 3, 1}, {2, 4, 3}, {3, 4, 2}, {1, 4, 3}, {3, 4, 1}, {2, 4, 1}, {1, 4, 2}.
Input: 10
Output: 240

Naive Approach: Check for all triplets whether it satisfies the given condition using three nested loops and keep incrementing their count every time a triplet satisfies the condition.
Time Complexity: O( N3
Auxiliary Space: O( 1 )
Efficient Approach:

1. Check all the possibilities for middle element and try to find the number of possible arrangements keeping each of them fixed one by one.
2. We can observe that all the numbers between [3, N] can occupy the middle slot.

Possible arrangements for every middle element:
On placing 3 at the middle, only 2 ( = 2 * 1) possible arrangements exist {1, 3, 2} and {2, 3, 1}.
On placing 4 at the middle, 6 ( = 3 * 2) possible arrangements exist {1, 4, 3}, {1, 4, 2}, {2, 4, 1}, {2, 4, 3}, {3, 4, 1} and {3, 4, 2}.
On placing 5 at the middle, 12 ( = 4 * 3) possible arrangements exist.

On placing N – 1 at the middle, (N-2) * (N-3) possible arrangements exist.
On placing N at the middle, (N-1) * (N-2) possible arrangements exist.
Thus, Total possible arrangements = ( N * (N-1) * (N-2)) / 3

Below is the implementation of the above approach.

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to find Number of triplets``// for given Number N such that``// middle element is always greater``// than left and right side element.``int` `findArrangement(``int` `N)``{``    ``// check if arrangement is``    ``// possible or Not``    ``if` `(N < 3)``        ``return` `0;` `    ``// else return total ways``    ``return` `((N) * (N - 1) * (N - 2)) / 3;``}` `// Driver code.``int` `main()``{``    ``int` `N = 10;``    ``cout << findArrangement(N);``    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG{``    ` `// Function to find number of triplets``// for given number N such that middle``// element is always greater than left ``// and right side element.``static` `int` `findArrangement(``int` `N)``{``    ` `    ``// Check if arrangement``    ``// is possible or not``    ``if` `(N < ``3``)``        ``return` `0``;` `    ``// Else return total ways``    ``return` `((N) * (N - ``1``) * (N - ``2``)) / ``3``;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``10``;``    ` `    ``System.out.println(findArrangement(N));``}``}` `// This code is contributed by coder001`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to find Number of triplets``# for given Number N such that middle``# element is always greater than left ``# and right side element.``def` `findArrangement(N):` `    ``# Check if arrangement is``    ``# possible or Not``    ``if` `(N < ``3``):``        ``return` `0``;` `    ``# Else return total ways``    ``return` `((N) ``*` `(N ``-` `1``) ``*` `(N ``-` `2``)) ``/``/` `3``;` `# Driver code.``N ``=` `10``;` `print``(findArrangement(N));` `# This code is contributed by Akanksha_Rai`

## C#

 `// C# program to implement``// the above approach``using` `System;``class` `GFG{``    ` `// Function to find number of triplets``// for given number N such that middle``// element is always greater than left``// and right side element.``static` `int` `findArrangement(``int` `N)``{``    ` `    ``// Check if arrangement``    ``// is possible or not``    ``if` `(N < 3)``        ``return` `0;` `    ``// Else return total ways``    ``return` `((N) * (N - 1) * (N - 2)) / 3;``}` `// Driver code``public` `static` `void` `Main()``{``    ``int` `N = 10;``    ` `    ``Console.Write(findArrangement(N));``}``}` `// This code is contributed by Code_Mech`

## Javascript

 ``
Output:
`240`

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up