# 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

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

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

 `// C++ implementation of the approach ` `#include ` `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 `

## Java

 `// 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)); ` `    ``} ` `} `

## Python3

 `# 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 `

## C#

 `// 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 ` `}  `

## PHP

 `= 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``); ` `?> `

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.