# Count of all possible bitonic subarrays

• Last Updated : 20 May, 2021

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

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`

## Javascript

 ``

Output:

`15`

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

My Personal Notes arrow_drop_up