Given a string **str** and a list of characters **L**, the task is to count total numbers of substrings of the string **str** without using characters given in the list **L**.

**Examples:**

Input:str = “abcd”, L[] = {‘a’, ‘b’, ‘t’, ‘q’}Output:3Explanation:

On ignoring characters ‘a’ and ‘b’ from the given string, substring “cd” is left.

Therefore, the total number of substrings formed with “cd” are:

(2 * (2 + 1)) / 2 = 3

Input:str = “abcpxyz”, L[] = {‘a’, ‘p’, ‘q’}Output:9Explanation:

On ignoring characters ‘a’ and ‘p’ from the given string, substrings “bc” and “xyz” are left.

Therefore, total number of substrings formed with the substrings are:

(2*(2+1))/2 + (3*(3+1))/2 = 3 + 6 = 9

**Approach:** The total number of substrings for a given string of length N is given by the formula

(N * (N + 1)) / 2

The idea is to use the above formula and follow the below steps to compute the answer:

- Traverse the string
**str**character by character. - Count the number of characters till which a character from list L is not found. Let the count be
**N** - Once a character from
**L**is encountered, compute**(N * (N + 1) / 2)**and add it to the**answer**and reset count N to zero.

Below is the implementation of the above approach:

`// C++ implementation of the above approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; `
` ` `// Function to find the Number of sub-strings ` `// without using given character ` `int` `countSubstring(string& S, ` `char` `L[], ` `int` `& n) `
`{ ` ` ` `int` `freq[26] = { 0 }, ans = 0; `
` ` ` ` `// Mark the given characters in `
` ` `// the freq array `
` ` `for` `(` `int` `i = 0; i < n; i++) { `
` ` `freq[(` `int` `)(L[i] - ` `'a'` `)] = 1; `
` ` `} `
` ` ` ` `// Count variable to store the count `
` ` `// of the characters until a character `
` ` `// from given L is encountered `
` ` `int` `count = 0; `
` ` ` ` `for` `(` `auto` `x : S) { `
` ` ` ` `// If a character from L is encountered, `
` ` `// then the answer variable is incremented by `
` ` `// the value obtained by using `
` ` `// the mentioned formula and count is set to 0 `
` ` `if` `(freq[(` `int` `)(x - ` `'a'` `)]) { `
` ` `ans += (count * count + count) / 2; `
` ` `count = 0; `
` ` `} `
` ` `else`
` ` `count++; `
` ` `} `
` ` ` ` `// For last remaining characters `
` ` `ans += (count * count + count) / 2; `
` ` ` ` `return` `ans; `
`} ` ` ` `// Driver code ` `int` `main() `
`{ ` ` ` ` ` `string S = ` `"abcpxyz"` `; `
` ` `char` `L[] = { ` `'a'` `, ` `'p'` `, ` `'q'` `}; `
` ` `int` `n = ` `sizeof` `(L) / ` `sizeof` `(L[0]); `
` ` ` ` `cout << countSubstring(S, L, n); `
` ` ` ` `return` `0; `
`} ` |

*chevron_right*

*filter_none*

`// Java implementation of the above approach ` `import` `java.util.*; `
` ` `class` `GFG `
`{ ` ` ` `// Function to find the Number of sub-Strings ` `// without using given character ` `static` `int` `countSubString(` `char` `[]S, ` `char` `L[], ` `int` `n) `
`{ ` ` ` `int` `[]freq = ` `new` `int` `[` `26` `]; `
` ` `int` `ans = ` `0` `; `
` ` ` ` `// Mark the given characters in `
` ` `// the freq array `
` ` `for` `(` `int` `i = ` `0` `; i < n; i++) `
` ` `{ `
` ` `freq[(` `int` `)(L[i] - ` `'a'` `)] = ` `1` `; `
` ` `} `
` ` ` ` `// Count variable to store the count `
` ` `// of the characters until a character `
` ` `// from given L is encountered `
` ` `int` `count = ` `0` `; `
` ` ` ` `for` `(` `int` `x : S) `
` ` `{ `
` ` ` ` `// If a character from L is encountered, `
` ` `// then the answer variable is incremented by `
` ` `// the value obtained by using `
` ` `// the mentioned formula and count is set to 0 `
` ` `if` `(freq[(` `int` `)(x - ` `'a'` `)] > ` `0` `) `
` ` `{ `
` ` `ans += (count * count + count) / ` `2` `; `
` ` `count = ` `0` `; `
` ` `} `
` ` `else`
` ` `count++; `
` ` `} `
` ` ` ` `// For last remaining characters `
` ` `ans += (count * count + count) / ` `2` `; `
` ` ` ` `return` `ans; `
`} ` ` ` `// Driver code ` `public` `static` `void` `main(String[] args) `
`{ ` ` ` `String S = ` `"abcpxyz"` `; `
` ` `char` `L[] = { ` `'a'` `, ` `'p'` `, ` `'q'` `}; `
` ` `int` `n = L.length; `
` ` ` ` `System.out.print(countSubString(S.toCharArray(), L, n)); `
`} ` `} ` ` ` `// This code is contributed by Rajput-Ji ` |

*chevron_right*

*filter_none*

`# Python3 implementation of the above approach ` ` ` `# Function to find the Number of sub-strings ` `# without using given character ` `def` `countSubstring(S, L,n): `
` ` `freq ` `=` `[` `0` `for` `i ` `in` `range` `(` `26` `)] `
` ` ` ` `# the freq array `
` ` `for` `i ` `in` `range` `(n): `
` ` `freq[(` `ord` `(L[i]) ` `-` `ord` `(` `'a'` `))] ` `=` `1`
` ` ` ` `# Count variable to store the count `
` ` `# of the characters until a character `
` ` `# from given L is encountered `
` ` `count,ans ` `=` `0` `,` `0`
` ` ` ` `for` `x ` `in` `S: `
` ` ` ` `# If a character from L is encountered, `
` ` `# then the answer variable is incremented by `
` ` `# the value obtained by using `
` ` `# the mentioned formula and count is set to 0 `
` ` `if` `(freq[` `ord` `(x) ` `-` `ord` `(` `'a'` `)]): `
` ` `ans ` `+` `=` `(count ` `*` `count ` `+` `count) ` `/` `/` `2`
` ` `count ` `=` `0`
` ` `else` `: `
` ` `count ` `+` `=` `1`
` ` ` ` `# For last remaining characters `
` ` `ans ` `+` `=` `(count ` `*` `count ` `+` `count) ` `/` `/` `2`
` ` ` ` `return` `ans `
` ` `# Driver code ` ` ` `S ` `=` `"abcpxyz"`
`L ` `=` `[` `'a'` `, ` `'p'` `, ` `'q'` `] `
`n ` `=` `len` `(L) `
` ` `print` `(countSubstring(S, L, n)) `
` ` `# This code is contributed by mohit kumar 29 ` |

*chevron_right*

*filter_none*

`// C# implementation of the above approach ` `using` `System; `
` ` `class` `GFG `
`{ ` ` ` ` ` `// Function to find the Number of sub-Strings `
` ` `// without using given character `
` ` `static` `int` `countSubString(` `char` `[]S, ` `char` `[]L, ` `int` `n) `
` ` `{ `
` ` `int` `[]freq = ` `new` `int` `[26]; `
` ` `int` `ans = 0; `
` ` ` ` `// Mark the given characters in `
` ` `// the freq array `
` ` `for` `(` `int` `i = 0; i < n; i++) `
` ` `{ `
` ` `freq[(` `int` `)(L[i] - ` `'a'` `)] = 1; `
` ` `} `
` ` ` ` `// Count variable to store the count `
` ` `// of the characters until a character `
` ` `// from given L is encountered `
` ` `int` `count = 0; `
` ` ` ` `foreach` `(` `int` `x ` `in` `S) `
` ` `{ `
` ` ` ` `// If a character from L is encountered, `
` ` `// then the answer variable is incremented by `
` ` `// the value obtained by using `
` ` `// the mentioned formula and count is set to 0 `
` ` `if` `(freq[(` `int` `)(x - ` `'a'` `)] > 0) `
` ` `{ `
` ` `ans += (count * count + count) / 2; `
` ` `count = 0; `
` ` `} `
` ` `else`
` ` `count++; `
` ` `} `
` ` ` ` `// For last remaining characters `
` ` `ans += (count * count + count) / 2; `
` ` ` ` `return` `ans; `
` ` `} `
` ` ` ` `// Driver code `
` ` `public` `static` `void` `Main() `
` ` `{ `
` ` `string` `S = ` `"abcpxyz"` `; `
` ` `char` `[]L = { ` `'a'` `, ` `'p'` `, ` `'q'` `}; `
` ` `int` `n = L.Length; `
` ` ` ` `Console.WriteLine(countSubString(S.ToCharArray(), L, n)); `
` ` `} `
`} ` ` ` `// This code is contributed by Yash_R ` |

*chevron_right*

*filter_none*

**Output:**

9

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.

## Recommended Posts:

- Count of substrings formed using a given set of characters only
- Strings formed from given characters without any consecutive repeating characters
- K length words that can be formed from given characters without repetition
- Check if a Palindromic String can be formed by concatenating Substrings of two given Strings
- Check if a given string can be formed using characters of adjacent cells of a Matrix
- Count of times second string can be formed from the characters of first string
- Number of ways in which the substring in range [L, R] can be formed using characters out of the range
- Check if a string can be split into substrings starting with N followed by N characters
- Count of substrings of a given Binary string with all characters same
- Count of strings that can be formed using a, b and c under given constraints
- Count of numbers upto N digits formed using digits 0 to K-1 without any adjacent 0s
- Check whether second string can be formed from characters of first string
- Count number of substrings with exactly k distinct characters
- Count substrings with same first and last characters
- Recursive solution to count substrings with same first and last characters
- Count distinct substrings that contain some characters at most k times
- Count number of substrings of a string consisting of same characters
- Count of all unique substrings with non-repeating characters
- Count of substrings of length K with exactly K distinct characters
- Count of Substrings with at least K pairwise Distinct Characters having same Frequency

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.