Sub-strings that start and end with one character and have at least one other

Given a string str which contains only the characters x and y, the task is to count all the sub-strings that start and end with an x and have at least a single y.

Examples:

Input: str = “xyyxx”
Output: 2
“xyyx” and “xyyxx” are the only valid sub-strings.

Input: str = “xyy”
Output: 0



Approach:

  • Create an array countX[] where countX[i] stores the total x from i to n – 1.
  • Now, for every x in the string, find the first y that appears after this x.
  • And update count = count + countX[indexOf(y)] because with this x as the starting index, all sub-strings will be valid that will end at any x after the found y.
  • Return the count in the end.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include<bits/stdc++.h>
using namespace std;
  
// Function that returns the index of next occurrence
// of the character c in string str starting from index start
int nextIndex(string str, int start, char c)
{
  
    // Starting from start
    for (int i = start; i < str.length(); i++) {
  
        // If current character = c
        if (str[i] == c)
            return i;
    }
  
    // Not found
    return -1;
}
  
// Function to return the count of required sub-strings
int countSubStrings(string str)
{
    int i, n = str.length();
  
    // Stores running count of 'x' starting from the end
    int countX[n];
  
    int count = 0;
    for (i = n - 1; i >= 0; i--) {
        if (str[i] == 'x')
            count++;
        countX[i] = count;
    }
  
    // Next index of 'x' starting from index 0
    int nextIndexX = nextIndex(str, 0, 'x');
  
    // Next index of 'y' starting from index 0
    int nextIndexY = nextIndex(str, 0, 'y');
  
    // To store the count of required sub-strings
    count = 0;
    while (nextIndexX != -1 && nextIndexY != -1) {
  
        // If 'y' appears before 'x'
        // it won't contribute to a valid sub-string
        if (nextIndexX > nextIndexY) {
  
            // Find next occurrence of 'y'
            nextIndexY = nextIndex(str, nextIndexY + 1, 'y');
            continue;
        }
  
        // If 'y' appears after 'x'
        // every sub-string ending at an 'x' appearing after this 'y'
        // and starting with the current 'x' is a valid sub-string
        else {
            count += countX[nextIndexY];
  
            // Find next occurrence of 'x'
            nextIndexX = nextIndex(str, nextIndexX + 1, 'x');
        }
    }
  
    // Return the count
    return count;
}
  
// Driver code
int main()
{
  
    string s = "xyyxx";
  
    cout << countSubStrings(s);
}
  
// This code is contributed by ihritik

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
public class GFG {
  
    // Function that returns the index of next occurrence
    // of the character c in string str starting from index start
    static int nextIndex(String str, int start, char c)
    {
  
        // Starting from start
        for (int i = start; i < str.length(); i++) {
  
            // If current character = c
            if (str.charAt(i) == c)
                return i;
        }
  
        // Not found
        return -1;
    }
  
    // Function to return the count of required sub-strings
    static int countSubStrings(String str)
    {
        int i, n = str.length();
  
        // Stores running count of 'x' starting from the end
        int countX[] = new int[n];
  
        int count = 0;
        for (i = n - 1; i >= 0; i--) {
            if (str.charAt(i) == 'x')
                count++;
            countX[i] = count;
        }
  
        // Next index of 'x' starting from index 0
        int nextIndexX = nextIndex(str, 0, 'x');
  
        // Next index of 'y' starting from index 0
        int nextIndexY = nextIndex(str, 0, 'y');
  
        // To store the count of required sub-strings
        count = 0;
        while (nextIndexX != -1 && nextIndexY != -1) {
  
            // If 'y' appears before 'x'
            // it won't contribute to a valid sub-string
            if (nextIndexX > nextIndexY) {
  
                // Find next occurrence of 'y'
                nextIndexY = nextIndex(str, nextIndexY + 1, 'y');
                continue;
            }
  
            // If 'y' appears after 'x'
            // every sub-string ending at an 'x' appearing after this 'y'
            // and starting with the current 'x' is a valid sub-string
            else {
                count += countX[nextIndexY];
  
                // Find next occurrence of 'x'
                nextIndexX = nextIndex(str, nextIndexX + 1, 'x');
            }
        }
  
        // Return the count
        return count;
    }
  
    // Driver code
    public static void main(String[] args)
    {
  
        String s = "xyyxx";
  
        System.out.println(countSubStrings(s));
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach
  
# Function that returns the index of next occurrence
# of the character c in string str starting from index start
def nextIndex(str, start, c):
  
  
    # Starting from start
    for i in range(start,len(str)): 
  
        # If current character = c
        if (str[i] == c):
            return i;
      
  
    # Not found
    return -1;
  
  
# Function to return the count of required sub-strings
def countSubStrings(str):
  
    n = len(str)
  
    # Stores running count of 'x' starting from the end
    countX=[0]*n;
  
    count = 0;
    for i in range(n-1,-1,-1): 
        if (str[i] == 'x'):
            count=count+1
        countX[i] = count
      
  
    # Next index of 'x' starting from index 0
    nextIndexX = nextIndex(str, 0, 'x')
  
    # Next index of 'y' starting from index 0
    nextIndexY = nextIndex(str, 0, 'y')
  
    # To store the count of required sub-strings
    count = 0;
    while (nextIndexX != -1 and nextIndexY != -1):
  
        # If 'y' appears before 'x'
        # it won't contribute to a valid sub-string
        if (nextIndexX > nextIndexY):
  
            # Find next occurrence of 'y'
            nextIndexY = nextIndex(str, nextIndexY + 1, 'y')
            continue
          
  
        # If 'y' appears after 'x'
        # every sub-string ending at an 'x' appearing after this 'y'
        # and starting with the current 'x' is a valid sub-string
        else :
            count += countX[nextIndexY]
  
            # Find next occurrence of 'x'
            nextIndexX = nextIndex(str, nextIndexX + 1, 'x');
          
      
  
    # Return the count
    return count
  
  
# Driver code
  
  
s = "xyyxx";
  
print(countSubStrings(s));
  
  
# This code is contributed by ihritik

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach 
  
using System;
  
public class GFG { 
  
    // Function that returns the index of next occurrence 
    // of the character c in string str starting from index start 
    static int nextIndex(string str, int start, char c) 
    
  
        // Starting from start 
        for (int i = start; i < str.Length; i++) { 
  
            // If current character = c 
            if (str[i] == c) 
                return i; 
        
  
        // Not found 
        return -1; 
    
  
    // Function to return the count of required sub-strings 
    static int countSubStrings(string str) 
    
        int i, n = str.Length ; 
  
        // Stores running count of 'x' starting from the end 
        int []countX = new int[n]; 
  
        int count = 0; 
        for (i = n - 1; i >= 0; i--) { 
            if (str[i] == 'x'
                count++; 
            countX[i] = count; 
        
  
        // Next index of 'x' starting from index 0 
        int nextIndexX = nextIndex(str, 0, 'x'); 
  
        // Next index of 'y' starting from index 0 
        int nextIndexY = nextIndex(str, 0, 'y'); 
  
        // To store the count of required sub-strings 
        count = 0; 
        while (nextIndexX != -1 && nextIndexY != -1) { 
  
            // If 'y' appears before 'x' 
            // it won't contribute to a valid sub-string 
            if (nextIndexX > nextIndexY) { 
  
                // Find next occurrence of 'y' 
                nextIndexY = nextIndex(str, nextIndexY + 1, 'y'); 
                continue
            
  
            // If 'y' appears after 'x' 
            // every sub-string ending at an 'x' appearing after this 'y' 
            // and starting with the current 'x' is a valid sub-string 
            else
                count += countX[nextIndexY]; 
  
                // Find next occurrence of 'x' 
                nextIndexX = nextIndex(str, nextIndexX + 1, 'x'); 
            
        
  
        // Return the count 
        return count; 
    
  
    // Driver code 
    public static void Main() 
    
  
        string s = "xyyxx"
  
        Console.WriteLine(countSubStrings(s)); 
    
    // This code is contributed by Ryuga

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php 
// PHP implementation of the approach
   
// Function that returns the index of next occurrence
// of the character c in string str starting from index start
function nextIndex($str, $start, $c)
{
   
    // Starting from start
    for ($i = $start; $i < strlen($str); $i++) {
   
        // If current character = c
        if ($str[$i] == $c)
            return $i;
    }
   
    // Not found
    return -1;
}
   
// Function to return the count of required sub-strings
function countSubStrings($str)
{
    $n = strlen($str);
   
    // Stores running count of 'x' starting from the end
    $countX = array(0,$n,NULL);
   
    $count = 0;
    for ($i = $n - 1; $i >= 0; $i--) {
        if ($str[$i] == 'x')
            $count++;
        $countX[$i] = $count;
    }
   
    // Next index of 'x' starting from index 0
    $nextIndexX = nextIndex($str, 0, 'x');
   
    // Next index of 'y' starting from index 0
    $nextIndexY = nextIndex($str, 0, 'y');
   
    // To store the count of required sub-strings
    $count = 0;
    while ($nextIndexX != -1 && $nextIndexY != -1) {
   
        // If 'y' appears before 'x'
        // it won't contribute to a valid sub-string
        if ($nextIndexX > $nextIndexY) {
   
            // Find next occurrence of 'y'
            $nextIndexY = nextIndex($str, $nextIndexY + 1, 'y');
            continue;
        }
   
        // If 'y' appears after 'x'
        // every sub-string ending at an 'x' appearing after this 'y'
        // and starting with the current 'x' is a valid sub-string
        else {
            $count += $countX[$nextIndexY];
   
            // Find next occurrence of 'x'
            $nextIndexX = nextIndex($str, $nextIndexX + 1, 'x');
        }
    }
   
    // Return the count
    return $count;
}
   
// Driver code
  
$s = "xyyxx";
echo countSubStrings($s);
?>

chevron_right


Output:

2


My Personal Notes arrow_drop_up

pawanasipugmailcom

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : Ryuga, ihritik, Ita_c