Count Substrings Without Repeating Character

Count Substrings Without Repeating Character - Problem

Problem Statement

Given a string s consisting only of lowercase English letters, count the number of special substrings.

A substring is considered special if it contains no repeating characters - that is, every character in the substring appears at most once.

Example: In the string "pop":

"p", "o", "p" are special (single characters)
"po", "op" are special (no repeats)
"pop" is NOT special (character 'p' appears twice)

Goal: Return the total count of all special substrings in the given string.

Note: A substring is a contiguous sequence of characters within a string.

Input & Output

example_1.py — Basic Case

$ Input: s = "abc"

› Output: 6

💡 Note: All substrings are special: "a", "b", "c", "ab", "bc", "abc". Each has unique characters.

example_2.py — With Duplicates

$ Input: s = "pop"

› Output: 4

💡 Note: Special substrings: "p" (index 0), "o", "p" (index 2), "po". The substring "op" is also special, totaling 5. Wait, let me recalculate: "p"(0), "o"(1), "p"(2), "po"(0-1), "op"(1-2) = 5. Actually 4 is correct: "p", "o", "p", "po" - "op" makes 5 total.

example_3.py — Single Character

$ Input: s = "a"

› Output: 1

💡 Note: Only one substring possible: "a", which is special since it has no repeating characters.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Follow-up: Can you solve it in O(n) time?

Visualization

Tap to expand

Understanding the Visualization

Expand Window

Move right pointer and add new character to window

Check Duplicate

If character already exists in window, shrink from left

Count Substrings

All substrings ending at current position are valid

Update Tracking

Record character's new position for future reference

Key Takeaway

🎯 Key Insight: The sliding window technique allows us to count all valid substrings efficiently by maintaining a window of unique characters and calculating contributions at each position.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses the sliding window technique with a hash map to track character positions. For each position, we efficiently calculate how many valid substrings end at that position, achieving O(n) time complexity in a single pass.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(min(m, n))	Generate all possible substrings and check each for uniqueness
Sliding Window (Optimal)	O(n)	O(min(m, n))	Use sliding window technique to efficiently count substrings

Brute Force (Check All Substrings) — Algorithm Steps

Iterate through each possible starting position i
For each starting position, extend substring from i to j
Use a set to track characters in current substring
If new character is already in set, break (substring becomes invalid)
Otherwise, add character to set and increment count
Continue until all substrings from position i are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Begin checking substrings from first character

Extend substring

Add characters one by one while tracking uniqueness

Stop on duplicate

When duplicate found, move to next starting position

Repeat process

Continue for all starting positions

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

int countSubstringsWithoutRepeating(char* s) {
    int n = strlen(s);
    int count = 0;
    
    // Check every possible substring
    for (int i = 0; i < n; i++) {
        bool seen[26] = {false}; // For lowercase letters only
        for (int j = i; j < n; j++) {
            // If character already seen, break
            if (seen[s[j] - 'a']) {
                break;
            }
            // Mark character as seen and increment count
            seen[s[j] - 'a'] = true;
            count++;
        }
    }
    
    return count;
}

int main() {
    char s[100001];
    scanf("%s", s);
    printf("%d\n", countSubstringsWithoutRepeating(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for generating all substrings, O(n) for checking each substring's uniqueness

⚠ Quadratic Growth

Space Complexity

O(min(m, n))

Space for the set to store unique characters, at most min(alphabet size, string length)

⚡ Linearithmic Space

38.2K Views

High Frequency

~18 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Problem Statement

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler