Count Unique Characters of All Substrings of a Given String

Count Unique Characters of All Substrings of a Given String - Problem

Given a string s, we need to find the sum of unique characters across all possible substrings of s.

Let's define countUniqueChars(t) as a function that returns the number of characters that appear exactly once in string t.

For example, if s = "LEETCODE":

Characters 'L', 'T', 'C', 'O', 'D' appear exactly once → countUniqueChars("LEETCODE") = 5
Characters 'E' appears twice, so it's not counted

Your task is to return the sum of countUniqueChars(t) for every substring t of s.

Important: Some substrings may be identical, but each occurrence must be counted separately.

Example: For s = "ABC", we consider substrings: "A", "B", "C", "AB", "BC", "ABC" - and count unique characters in each.

Input & Output

example_1.py — Basic Case

$ Input: s = "ABC"

› Output: 10

💡 Note: Substrings: "A"(1) + "B"(1) + "C"(1) + "AB"(2) + "BC"(2) + "ABC"(3) = 10 unique characters total

example_2.py — Repeated Characters

$ Input: s = "ABA"

› Output: 8

💡 Note: Substrings: "A"(1) + "B"(1) + "A"(1) + "AB"(2) + "BA"(2) + "ABA"(1, only B is unique) = 8

example_3.py — Single Character

$ Input: s = "A"

› Output: 1

💡 Note: Only one substring "A" with 1 unique character

Constraints

1 ≤ s.length ≤ 10⁴
s consists of uppercase English letters only
Answer fits in a 32-bit integer

Visualization

Tap to expand

Understanding the Visualization

Index Grouping

Group all positions where each character appears

Boundary Calculation

For each position, find the nearest same characters before and after

Contribution Formula

Calculate contribution as (left_distance) × (right_distance)

Sum All Contributions

Add up contributions from all character positions

Key Takeaway

🎯 Key Insight: Instead of checking every substring, calculate each character's total contribution across all substrings where it appears exactly once using mathematical boundaries.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses contribution counting instead of generating substrings. For each character position, calculate how many substrings contain that character exactly once by finding distances to previous/next occurrences of the same character. This achieves O(n) time complexity compared to O(n³) brute force.

Common Approaches

Approach	Time	Space	Notes
✓ Contribution Counting (Optimal)	O(n)	O(1)	Calculate each character's contribution to the total sum based on positions where it appears uniquely
Brute Force (Generate All Substrings)	O(n³)	O(n)	Generate every substring and count unique characters in each

Contribution Counting (Optimal) — Algorithm Steps

For each character position i, track previous and next occurrences of the same character
Calculate left boundary: distance to previous occurrence (or start of string)
Calculate right boundary: distance to next occurrence (or end of string)
Contribution = left_distance × right_distance
Sum all contributions

Visualization

Tap to expand

Step-by-Step Walkthrough

Group by Character

Find all positions where each character appears

Find Boundaries

For each position, find previous and next occurrence of same character

Calculate Contribution

Multiply distances to get number of unique substrings

Code -

solution.c — C

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

int uniqueLetterString(char* s) {
    int n = strlen(s);
    int total = 0;
    
    // For each position, calculate contribution
    for (int i = 0; i < n; i++) {
        // Find previous occurrence of s[i]
        int leftBound = -1;
        for (int j = i - 1; j >= 0; j--) {
            if (s[j] == s[i]) {
                leftBound = j;
                break;
            }
        }
        
        // Find next occurrence of s[i]
        int rightBound = n;
        for (int j = i + 1; j < n; j++) {
            if (s[j] == s[i]) {
                rightBound = j;
                break;
            }
        }
        
        // Number of substrings where s[i] appears exactly once
        int contribution = (i - leftBound) * (rightBound - i);
        total += contribution;
    }
    
    return total;
}

int main() {
    char s[1001];
    scanf("%s", s);
    // Remove quotes if present
    int len = strlen(s);
    if (s[0] == '"') {
        memmove(s, s + 1, len - 1);
        s[len - 2] = '\0';
    }
    printf("%d\n", uniqueLetterString(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to calculate each character's contribution

✓ Linear Growth

Space Complexity

O(1)

Only need to track previous positions of characters (at most 26 for lowercase letters)

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

892 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Contribution Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler