Related Articles

# Count of Reverse Bitonic Substrings in a given String

• Last Updated : 25 Aug, 2021

Given a string S, the task is to count the number of Reverse Bitonic Substrings in the given string.

Reverse bitonic substring: A string in which the ASCII values of the characters of the string follow any of the following patterns:

• Strictly Increasing
• Strictly decreasing
• Decreasing and then increasing

Examples:

Output: 10
Explanation:
All possible substrings of length 1, {“b”, “a”, “d”, “e”} are always reverse  bitonic.
Substrings of length 2 which are reverse bitonic are {“ba”, “ad”, “de”}.
Substrings of length 3 which are reverse bitonic are {“bad “, “ade”}.
Only substring of length 4 which is reverse bitonic is “bade”.
Therefore, the count of reverse bitonic substrings is 10.

Input: S = “abc”
Output: 6

Approach :
The approach is to generate all possible substrings of the given string and follow the steps below for each substring to solve the problem:

• Traverse the string and for each character, check if the ASCII value of the next character is smaller than the ASCII value of the current character or not.
• If at any point, the ASCII value of the next character is greater than the ASCII value of the current character, traverse from that index and for each character from now onwards, check if the ASCII value of the next character is greater than the ASCII value of the current character or not.
• If at any point, the ASCII value of the next character is smaller than the ASCII value of the current character before the end of the substring is reached, then ignore the substring.
• If the end of the substring is reached, increase count.
• After completing all the above steps for all substrings, print the final value of count.

Below is the implementation of the above approach :

## C++

 `// C++ Program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to calculate the number``// of reverse bitonic substrings``int` `CountsubString(``char` `str[], ``int` `n)``{``    ``// Stores the count``    ``int` `c = 0;` `    ``// All possible lengths of substrings``    ``for` `(``int` `len = 1; len <= n; len++) {` `        ``// Starting point of a substring``        ``for` `(``int` `i = 0; i <= n - len; i++) {` `            ``// Ending point of a substring``            ``int` `j = i + len - 1;` `            ``char` `temp = str[i], f = 0;` `            ``// Condition for reverse``            ``// bitonic substrings of``            ``// length 1``            ``if` `(j == i) {` `                ``c++;``                ``continue``;``            ``}` `            ``int` `k = i + 1;` `            ``// Check for decreasing sequence``            ``while` `(temp > str[k] && k <= j) {` `                ``temp = str[k];` `                ``k++;``            ``}` `            ``// If end of substring``            ``// is reached``            ``if` `(k > j) {``                ``c++;``                ``f = 2;``            ``}` `            ``// For increasing sequence``            ``while` `(temp < str[k] && k <= j``                ``&& f != 2) {` `                ``temp = str[k];` `                ``k++;``            ``}` `            ``// If end of substring``            ``// is reached``            ``if` `(k > j && f != 2) {``                ``c++;``                ``f = 0;``            ``}``        ``}``    ``}` `    ``// Return the number``    ``// of bitonic substrings``    ``return` `c;``}` `// Driver Code``int` `main()``{``    ``char` `str[] = ``"bade"``;``    ``cout << CountsubString(str, ``strlen``(str));` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``class` `GFG{``    ` `// Function to calculate the number``// of reverse bitonic substrings``public` `static` `int` `CountsubString(``char``[] str,``                                 ``int` `n)``{``    ` `    ``// Stores the count``    ``int` `c = ``0``;` `    ``// All possible lengths of substrings``    ``for``(``int` `len = ``1``; len <= n; len++)``    ``{``        ` `        ``// Starting point of a substring``        ``for``(``int` `i = ``0``; i <= n - len; i++)``        ``{``            ` `            ``// Ending point of a substring``            ``int` `j = i + len - ``1``;` `            ``char` `temp = str[i], f = ``0``;` `            ``// Condition for reverse``            ``// bitonic substrings of``            ``// length 1``            ``if` `(j == i)``            ``{``                ``c++;``                ``continue``;``            ``}` `            ``int` `k = i + ``1``;` `            ``// Check for decreasing sequence``            ``while` `(temp > str[k] && k <= j)``            ``{``                ``temp = str[k];``                ``k++;``            ``}` `            ``// If end of substring``            ``// is reached``            ``if` `(k > j)``            ``{``                ``c++;``                ``f = ``2``;``            ``}` `            ``// For increasing sequence``            ``while` `(k <= j && temp < str[k] &&``                   ``f != ``2``)``            ``{``                ``temp = str[k];``                ``k++;``            ``}` `            ``// If end of substring``            ``// is reached``            ``if` `(k > j && f != ``2``)``            ``{``                ``c++;``                ``f = ``0``;``            ``}``        ``}``    ``}` `    ``// Return the number``    ``// of bitonic substrings``    ``return` `c;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``char` `str[] = { ``'b'``, ``'a'``, ``'d'``, ``'e'` `};``    ` `    ``System.out.println(CountsubString(``                       ``str, str.length));``}``}` `// This cdoe is contributed by divyeshrabadiya07`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to calculate the number``# of reverse bitonic substrings``def` `CountsubString(strr, n):``    ` `    ``# Stores the count``    ``c ``=` `0` `    ``# All possible lengths of substrings``    ``for` `len` `in` `range``(n ``+` `1``):` `        ``# Starting poof a substring``        ``for` `i ``in` `range``(n ``-` `len``):` `            ``# Ending poof a substring``            ``j ``=` `i ``+` `len` `-` `1` `            ``temp ``=` `strr[i]``            ``f ``=` `0` `            ``# Condition for reverse``            ``# bitonic substrings of``            ``# length 1``            ``if` `(j ``=``=` `i):``                ``c ``+``=` `1``                ``continue` `            ``k ``=` `i ``+` `1` `            ``# Check for decreasing sequence``            ``while` `(k <``=` `j ``and` `temp > strr[k]):``                ``temp ``=` `strr[k]``                ``k ``+``=` `1` `            ``# If end of substring``            ``# is reache``            ``if` `(k > j):``                ``c ``+``=` `1``                ``f ``=` `2` `            ``# For increasing sequence``            ``while` `(k <``=` `j ``and` `f !``=` `2` `and``                ``temp < strr[k]):``                ``temp ``=` `strr[k]``                ``k ``+``=` `1` `            ``# If end of substring``            ``# is reached``            ``if` `(k > j ``and` `f !``=` `2``):``                ``c ``+``=` `1``                ``f ``=` `0` `    ``# Return the number``    ``# of bitonic substrings``    ``return` `c` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``strr ``=` `"bade"``    ``print``(CountsubString(strr, ``len``(strr)))``    ` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG{``    ` `// Function to calculate the number``// of reverse bitonic substrings``public` `static` `int` `CountsubString(``char``[] str,``                                 ``int` `n)``{``    ` `    ``// Stores the count``    ``int` `c = 0;` `    ``// All possible lengths of substrings``    ``for``(``int` `len = 1; len <= n; len++)``    ``{``      ` `        ``// Starting point of a substring``        ``for``(``int` `i = 0; i <= n - len; i++)``        ``{``            ` `            ``// Ending point of a substring``            ``int` `j = i + len - 1;` `            ``char` `temp = str[i], f = ``'0'``;` `            ``// Condition for reverse``            ``// bitonic substrings of``            ``// length 1``            ``if` `(j == i)``            ``{``                ``c++;``                ``continue``;``            ``}` `            ``int` `k = i + 1;` `            ``// Check for decreasing sequence``            ``while` `(temp > str[k] && k <= j)``            ``{``                ``temp = str[k];``                ``k++;``            ``}` `            ``// If end of substring``            ``// is reached``            ``if` `(k > j)``            ``{``                ``c++;``                ``f = ``'2'``;``            ``}` `            ``// For increasing sequence``            ``while` `(k <= j && temp < str[k] &&``                   ``f != ``'2'``)``            ``{``                ``temp = str[k];``                ``k++;``            ``}` `            ``// If end of substring``            ``// is reached``            ``if` `(k > j && f != 2)``            ``{``                ``c++;``                ``f = ``'0'``;``            ``}``        ``}``    ``}` `    ``// Return the number``    ``// of bitonic substrings``    ``return` `c;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``char` `[]str = { ``'b'``, ``'a'``, ``'d'``, ``'e'` `};``    ` `    ``Console.WriteLine(CountsubString(``                      ``str, str.Length) - 1);``}``}` `// This code is contributed by amal kumar choubey`

## Javascript

 ``

Output:

`10`

Time Complexity: O(N)
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up