Count of Reverse Bitonic Substrings in a given String

Last Updated : 07 Jul, 2023

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:

Input: S = "bade"
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 <bits/stdc++.h> 
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 code 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 point of a substring 
        for i in range(n - len): 

            # Ending point of 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# 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

<script>

// Javascript Program to implement 
// the above approach 

// Function to calculate the number 
// of reverse bitonic substrings 
function CountsubString(str, n) 
{ 
    // Stores the count 
    var c = 0; 

    // All possible lengths of substrings 
    for (var len = 1; len <= n; len++) { 

        // Starting point of a substring 
        for (var i = 0; i <= n - len; i++) { 

            // Ending point of a substring 
            var j = i + len - 1; 

            var temp = str[i], f = 0; 

            // Condition for reverse 
            // bitonic substrings of 
            // length 1 
            if (j == i) { 

                c++; 
                continue; 
            } 

            var 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 
var str = "bade".split(''); 
document.write( CountsubString(str, str.length)); 

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

Output:

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

Count of substrings of a binary string containing K ones

grand_master

Improve

Article Tags :

Practice Tags :

Count of Reverse Bitonic Substrings in a given String

Similar Reads

Thank You!

What kind of Experience do you want to share?