Related Articles
Count of all possible bitonic subarrays
• Last Updated : 19 Jun, 2020

Given an array arr[] consisting of N integers, the task is to count all the subarrays which are Bitonic in nature.

A bitonic subarray is a subarray in which elements are either strictly increasing or strictly decreasing, or are first increasing and then decreasing.

Examples:

Input: arr[] = {2, 1, 4, 5}
Output: 8
Explanation:
All subarray which are bitonic in subarray are : {2}, {2, 1}, {1}, {1, 4}, {1, 4, 5}, {4}, {4, 5} and {5}.

Input: arr[] = {1, 2, 3, 4}
Output:10

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:
Follow the steps below to solve the problems:

1. Generate all possible subarrays.
2. For each subarray, check if it is bitonic or not. If the subarray is Bitonic then increment count for answer.

Below is the implementation of the above approach :

## C++

 `// C++ program to count the``// number of possible``// bitonic subarrays``#include ``using` `namespace` `std;`` ` `// Function to return the count``// of bitonic subarrays``void` `countbitonic(``int` `arr[], ``int` `n)``{``    ``int` `c = 0;``    ``// Starting element of subarray``    ``for` `(``int` `i = 0; i < n; i++) {``        ``// Ending element of subarray``        ``for` `(``int` `j = i; j < n; j++) {`` ` `            ``int` `temp = arr[i], f = 0;`` ` `            ``// for 1 length``            ``if` `(j == i) {``                ``c++;``                ``continue``;``            ``}`` ` `            ``int` `k = i + 1;`` ` `            ``// For increasing sequence``            ``while` `(temp < arr[k] && k <= j) {``                ``temp = arr[k];``                ``k++;``            ``}`` ` `            ``// If strictly increasing``            ``if` `(k > j) {``                ``c++;``                ``f = 2;``            ``}`` ` `            ``// For decreasing sequence``            ``while` `(temp > arr[k]``                   ``&& k <= j``                   ``&& f != 2) {``                ``temp = arr[k];``                ``k++;``            ``}`` ` `            ``if` `(k > j && f != 2) {``                ``c++;``                ``f = 0;``            ``}``        ``}``    ``}`` ` `    ``cout << c << endl;``}``// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 4, 3, 6, 5 };``    ``int` `N = 6;`` ` `    ``countbitonic(arr, N);``}`

## Java

 `// Java program to count the number ``// of possible bitonic subarrays``import` `java.io.*; ``import` `java.util.*; `` ` `class` `GFG{ ``     ` `// Function to return the count ``// of bitonic subarrays ``public` `static` `void` `countbitonic(``int` `arr[], ``int` `n)``{``    ``int` `c = ``0``;``     ` `    ``// Starting element of subarray``    ``for``(``int` `i = ``0``; i < n; i++) ``    ``{``         ` `       ``// Ending element of subarray``       ``for``(``int` `j = i; j < n; j++) ``       ``{``          ``int` `temp = arr[i], f = ``0``;``           ` `          ``// For 1 length``          ``if` `(j == i)``          ``{``              ``c++;``              ``continue``;``          ``}``          ``int` `k = i + ``1``;``           ` `          ``// For increasing sequence``          ``while` `(temp < arr[k] && k <= j)``          ``{``              ``temp = arr[k];``              ``k++;``          ``}``           ` `          ``// If strictly increasing``          ``if` `(k > j) ``          ``{``              ``c++;``              ``f = ``2``;``          ``}``           ` `          ``// For decreasing sequence``          ``while` `( k <= j && temp > arr[k] && f != ``2``) ``          ``{``              ``temp = arr[k];``              ``k++;``          ``}``          ``if` `(k > j && f != ``2``)``          ``{``              ``c++;``              ``f = ``0``;``          ``}``       ``}``    ``}``    ``System.out.println(c);``}`` ` `// Driver code``public` `static` `void` `main(String[] args) ``{ ``    ``int` `arr[] = { ``1``, ``2``, ``4``, ``3``, ``6``, ``5` `};``    ``int` `N = ``6``;``     ` `    ``countbitonic(arr, N);``} ``} `` ` `// This code is contributed by grand_master`

## Python3

 `# Python3 program to count the number ``# of possible bitonic subarrays`` ` `# Function to return the count ``# of bitonic subarrays ``def` `countbitonic(arr, n):`` ` `    ``c ``=` `0``;``     ` `    ``# Starting element of subarray``    ``for` `i ``in` `range``(n):``         ` `        ``# Ending element of subarray``        ``for` `j ``in` `range``(i, n): ``            ``temp ``=` `arr[i]``            ``f ``=` `0``;`` ` `            ``# For 1 length``            ``if` `(j ``=``=` `i) :``                ``c ``+``=` `1``                ``continue``;``            ``k ``=` `i ``+` `1``;`` ` `            ``# For increasing sequence``            ``while` `(temp < arr[k] ``and` `k <``=` `j):``                ``temp ``=` `arr[k];``                ``k ``+``=` `1``                 ` `            ``# If strictly increasing``            ``if` `(k > j) :``                ``c ``+``=` `1``                ``f ``=` `2``;``                 ` `            ``# For decreasing sequence``            ``while` `(k <``=` `j ``and` `temp > arr[k] ``and` `f !``=` `2``):``                ``temp ``=` `arr[k];``                ``k ``+``=` `1``;``                 ` `            ``if` `(k > j ``and` `f !``=` `2``):``                ``c ``+``=` `1``;``                ``f ``=` `0``;            ``    ``print``(c)``     ` `# Driver Code``arr ``=` `[ ``1``, ``2``, ``4``, ``3``, ``6``, ``5` `];``N ``=` `6``;`` ` `countbitonic(arr, N);`` ` `# This code is contributed by grand_master`

## C#

 `// C# program to count the number ``// of possible bitonic subarrays ``using` `System;`` ` `class` `GFG{ `` ` `// Function to return the count ``// of bitonic subarrays     ``public` `static` `void` `countbitonic(``int` `[]arr, ``int` `n)``{``    ``int` `c = 0;``     ` `    ``// Starting element of subarray``    ``for``(``int` `i = 0; i < n; i++) ``    ``{``         ` `       ``// Ending element of subarray``       ``for``(``int` `j = i; j < n; j++)``       ``{``          ``int` `temp = arr[i], f = 0;``           ` `          ``// for 1 length``          ``if` `(j == i)``          ``{``              ``c++;``              ``continue``;``          ``}``          ``int` `k = i + 1;``           ` `          ``// For increasing sequence``          ``while` `(temp < arr[k] && k <= j)``          ``{``              ``temp = arr[k];``              ``k++;``          ``}``           ` `          ``// If strictly increasing``          ``if` `(k > j)``          ``{``              ``c++;``              ``f = 2;``          ``}``           ` `          ``// For decreasing sequence``          ``while` `( k <= j && temp > arr[k] && f != 2)``          ``{``              ``temp = arr[k];``              ``k++;``          ``}``          ``if` `(k > j && f != 2)``          ``{``              ``c++;``              ``f = 0;``          ``} ``       ``}``    ``}``    ``Console.Write(c);``}`` ` `// Driver code ``public` `static` `void` `Main() ``{ ``    ``int``[] arr = { 1, 2, 4, 3, 6, 5 };``    ``int` `N = 6;``     ` `    ``countbitonic(arr, N);``} ``} `` ` `// This code is contributed by grand_master`
Output:
```15
```

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

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.  Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up