# Count substrings having frequency of a character exceeding that of another character in a string

Given a string **S** of size **N** consisting of characters **a**, **b**, and **c** only, the task is to find the number of substrings of the given string **S** such that the frequency of character **a** is greater than the frequency of character **c**.

**Examples:**

Input:S = “abcc”Output:2Explanation:Below are all the possible substrings of S(= “abcc”) having the frequency of the character greater than the character c:

“a”: The frequency of a and c is 1 and 0 respectively.“ab”: The frequency of a and c is 1 and 0 respectively.

Therefore, the count of such substrings is 2.

abcabcabcaaaaabbbccccc”Input:S = “Output:148

**Naive Approach:** The simplest approach to solve the given problem is to generate all possible substrings of the given string **S** and count those substrings having a count of character **‘a’** greater than the count of character **‘c’**. After checking for all the substrings, print the value of the total count as the result.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the number of` `// substrings having the frequency of` `// 'a' greater than frequency of 'c'` `void` `countSubstrings(string& s)` `{` ` ` `// Stores the size of the string` ` ` `int` `n = s.length();` ` ` `// Stores the resultant` ` ` `// count of substrings` ` ` `int` `ans = 0;` ` ` `// Traverse the given string` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `// Store the difference between` ` ` `// frequency of 'a' and 'c'` ` ` `int` `cnt = 0;` ` ` `// Traverse all substrings` ` ` `// beginning at index i` ` ` `for` `(` `int` `j = i; j < n; j++) {` ` ` `if` `(s[j] == ` `'a'` `)` ` ` `cnt++;` ` ` `else` `if` `(s[j] == ` `'c'` `)` ` ` `cnt--;` ` ` `// If the frequency of 'a'` ` ` `// is greater than 'c'` ` ` `if` `(cnt > 0) {` ` ` `ans++;` ` ` `}` ` ` `}` ` ` `}` ` ` `// Print the answer` ` ` `cout << ans;` `}` `// Drive Code` `int` `main()` `{` ` ` `string S = ` `"abccaab"` `;` ` ` `countSubstrings(S);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `public` `class` `GFG` `{` ` ` `// Function to find the number of` `// substrings having the frequency of` `// 'a' greater than frequency of 'c'` `public` `static` `void` `countSubstrings(String s)` `{` ` ` ` ` `// Stores the size of the string` ` ` `int` `n = s.length();` ` ` `// Stores the resultant` ` ` `// count of substrings` ` ` `int` `ans = ` `0` `;` ` ` `// Traverse the given string` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) {` ` ` `// Store the difference between` ` ` `// frequency of 'a' and 'c'` ` ` `int` `cnt = ` `0` `;` ` ` `// Traverse all substrings` ` ` `// beginning at index i` ` ` `for` `(` `int` `j = i; j < n; j++) {` ` ` `if` `(s.charAt(j) == ` `'a'` `)` ` ` `cnt++;` ` ` `else` `if` `(s.charAt(j) == ` `'c'` `)` ` ` `cnt--;` ` ` `// If the frequency of 'a'` ` ` `// is greater than 'c'` ` ` `if` `(cnt > ` `0` `) {` ` ` `ans++;` ` ` `}` ` ` `}` ` ` `}` ` ` `// Print the answer` ` ` `System.out.println(ans);` `}` `// Drive Code` `public` `static` `void` `main(String args[])` `{` ` ` `String S = ` `"abccaab"` `;` ` ` `countSubstrings(S);` `}` `}` `// This code is contributed by SoumikMondal` |

## Python3

`# python program for the above approach` `# Function to find the number of` `# substrings having the frequency of` `# 'a' greater than frequency of 'c'` `def` `countSubstrings(s):` ` ` ` ` `# Stores the size of the string` ` ` `n ` `=` `len` `(s)` ` ` `# Stores the resultant` ` ` `# count of substrings` ` ` `ans ` `=` `0` ` ` `# Traverse the given string` ` ` `for` `i ` `in` `range` `(n):` ` ` ` ` `# Store the difference between` ` ` `# frequency of 'a' and 'c'` ` ` `cnt ` `=` `0` ` ` `# Traverse all substrings` ` ` `# beginning at index i` ` ` `for` `j ` `in` `range` `(i, n):` ` ` `if` `(s[j] ` `=` `=` `'a'` `):` ` ` `cnt ` `+` `=` `1` ` ` `elif` `(s[j] ` `=` `=` `'c'` `):` ` ` `cnt ` `-` `=` `1` ` ` `# If the frequency of 'a'` ` ` `# is greater than 'c'` ` ` `if` `(cnt > ` `0` `):` ` ` `ans` `+` `=` `1` ` ` `# Prthe answer` ` ` `print` `(ans)` `# Drive Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `S ` `=` `"abccaab"` ` ` `countSubstrings(S)` `# This code is contributed by mohit kumar 29.` |

## Javascript

`<script>` `// Javascript program for the above approach` `// Function to find the number of` `// substrings having the frequency of` `// 'a' greater than frequency of 'c'` `function` `countSubstrings(s)` `{` ` ` `// Stores the size of the string` ` ` `var` `n = s.length;` ` ` `// Stores the resultant` ` ` `// count of substrings` ` ` `var` `ans = 0;` ` ` `var` `i,j;` ` ` `// Traverse the given string` ` ` `for` `(i = 0; i < n; i++) {` ` ` `// Store the difference between` ` ` `// frequency of 'a' and 'c'` ` ` `var` `cnt = 0;` ` ` `// Traverse all substrings` ` ` `// beginning at index i` ` ` `for` `(j = i; j < n; j++) {` ` ` `if` `(s[j] == ` `'a'` `)` ` ` `cnt++;` ` ` `else` `if` `(s[j] == ` `'c'` `)` ` ` `cnt--;` ` ` `// If the frequency of 'a'` ` ` `// is greater than 'c'` ` ` `if` `(cnt > 0) {` ` ` `ans++;` ` ` `}` ` ` `}` ` ` `}` ` ` `// Print the answer` ` ` `document.write(ans);` `}` `// Drive Code` ` ` `var` `S = ` `"abccaab"` `;` ` ` `countSubstrings(S);` `</script>` |

## C#

`// C# program for the above approach` `using` `System;` `public` `class` `GFG {` ` ` `// Function to find the number of` ` ` `// substrings having the frequency of` ` ` `// 'a' greater than frequency of 'c'` ` ` `public` `static` `void` `countSubstrings(` `string` `s)` ` ` `{` ` ` `// Stores the size of the string` ` ` `int` `n = s.Length;` ` ` `// Stores the resultant` ` ` `// count of substrings` ` ` `int` `ans = 0;` ` ` `// Traverse the given string` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `// Store the difference between` ` ` `// frequency of 'a' and 'c'` ` ` `int` `cnt = 0;` ` ` `// Traverse all substrings` ` ` `// beginning at index i` ` ` `for` `(` `int` `j = i; j < n; j++) {` ` ` `if` `(s[j] == ` `'a'` `)` ` ` `cnt++;` ` ` `else` `if` `(s[j] == ` `'c'` `)` ` ` `cnt--;` ` ` `// If the frequency of 'a'` ` ` `// is greater than 'c'` ` ` `if` `(cnt > 0) {` ` ` `ans++;` ` ` `}` ` ` `}` ` ` `}` ` ` `// Print the answer` ` ` `Console.WriteLine(ans);` ` ` `}` ` ` `// Drive Code` ` ` `public` `static` `void` `Main(` `string` `[] args)` ` ` `{` ` ` `string` `S = ` `"abccaab"` `;` ` ` `countSubstrings(S);` ` ` `}` `}` `// This code is contributed by ukasp.` |

**Output:**

11

**Time Complexity:** O(N^{2})**Auxiliary Space:** O(1)

**Efficient Approach:** The above approach can also be optimized by using the Segment Tree. The idea is to store the difference of frequency of characters **‘a’** and **‘c’** for all prefixes of the string **S** in the segment tree node. Follow the steps below to solve the problem:

- Initialize a variable, say
**count**to**0**, to store the difference between the frequency of characters**‘a’**and**‘c’**. - Initialize a variable, say
**ans**to**0**, to store the count of substrings that have the frequency of character**‘a’**greater than**‘c’**. - Initialize the segment tree with all
**0**s, which will be updated while traversing the string. - Since the difference between the frequency of characters
**‘a’**and**‘c’**can be negative as well, all update operations on the segment tree will be done after adding**N**to the index that is to be updated to avoid negative indices. - Update the value of the index
**(0 + N)**in the segment tree as the initial value of the**count**is**0**. - Traverse the given string,
**S**over the range**[0, N – 1]**and perform the following steps:- If the current character is ‘a’, then increment the
**count**by**1**. Otherwise, if the current character is ‘c’, then decrement the**count**by 1. - Perform the query on the segment tree to find the sum of all values less than
**count**, as all these substrings will have the frequency of**‘a’**greater than**‘c’**and store the value returned in a variable say**val**. - Add the value of
**val**to the variable**ans**. - Update the segment tree by incrementing the value at the index
**(count + N)**by**1**.

- If the current character is ‘a’, then increment the
- After completing the above steps, print the value of
**ans**as the resultant count of substrings.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to update the segment Tree` `void` `update(` `int` `ind, vector<` `int` `>& segTree,` ` ` `int` `n)` `{` ` ` `// Update the value of ind` ` ` `ind += n;` ` ` `// Increment the leaf node` ` ` `segTree[ind]++;` ` ` `for` `(; ind > 1; ind >>= 1) {` ` ` `// Update the parent nodes` ` ` `segTree[ind >> 1] = segTree[ind]` ` ` `+ segTree[ind ^ 1];` ` ` `}` `}` `// Function to get the sum of all the` `// elements between low to high - 1` `int` `query(` `int` `low, ` `int` `high,` ` ` `vector<` `int` `>& segTree, ` `int` `n)` `{` ` ` `// Initialize the leaf nodes of` ` ` `// the segment tree` ` ` `low += n;` ` ` `high += n;` ` ` `int` `ans = 0;` ` ` `while` `(low < high) {` ` ` `// Node lies completely in the` ` ` `// range of low to high` ` ` `if` `(low % 2) {` ` ` `ans += segTree[low];` ` ` `low++;` ` ` `}` ` ` `if` `(high % 2) {` ` ` `high--;` ` ` `ans += segTree[high];` ` ` `}` ` ` `// Update the value of nodes` ` ` `low >>= 1;` ` ` `high >>= 1;` ` ` `}` ` ` `return` `ans;` `}` `// Function to count the number of` `// substrings which have frequency of` `// 'a' greater than frequency of 'c'.` `void` `countSubstrings(string& s)` `{` ` ` `// Store the size of the string` ` ` `int` `n = s.length();` ` ` `// Initialize segment tree` ` ` `vector<` `int` `> segTree(4 * n);` ` ` `int` `count = 0;` ` ` `// Update the initial value of` ` ` `// the count` ` ` `update(n, segTree, 2 * n);` ` ` `// Stores the required result` ` ` `int` `ans = 0;` ` ` `// Traverse the given string` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `// Increment count` ` ` `if` `(s[i] == ` `'a'` `)` ` ` `count++;` ` ` `// Decrement count` ` ` `else` `if` `(s[i] == ` `'c'` `)` ` ` `count--;` ` ` `// Query the segment tree to` ` ` `// find the sum of all values` ` ` `// less than count` ` ` `int` `val = query(0, n + count,` ` ` `segTree, 2 * n);` ` ` `ans += val;` ` ` `// Update the current value of` ` ` `// count in the segment tree` ` ` `update(n + count, segTree, 2 * n);` ` ` `}` ` ` `// Print the answer` ` ` `cout << ans;` `}` `// Driver Code` `int` `main()` `{` ` ` `string S = ` `"abccaab"` `;` ` ` `countSubstrings(S);` ` ` `return` `0;` `}` |

**Output:**

11

**Time Complexity:** O(N*log N)**Auxiliary Space:** O(N)

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**.