Total Appeal of A String - Practice Coding Problems

Total Appeal of A String - Problem

The appeal of a string is defined as the number of distinct characters found in that string. Think of it as measuring how "diverse" a string is in terms of its character variety.

For example:

The appeal of "abbca" is 3 because it contains 3 distinct characters: 'a', 'b', and 'c'
The appeal of "aaa" is 1 because it only contains the character 'a'
The appeal of "abc" is 3 because all characters are distinct

Your task is to find the total appeal of all possible substrings of a given string s. A substring is any contiguous sequence of characters within the original string.

This means you need to:

Generate all possible substrings of the input string
Calculate the appeal (distinct character count) for each substring
Sum up all these appeal values

Goal: Return the sum of appeals of all substrings of the given string.

Input & Output

example_1.py — Basic Case

$ Input: s = "abbca"

› Output: 28

💡 Note: The string 'abbca' has substrings like 'a'(1), 'ab'(2), 'abb'(2), 'abbc'(3), 'abbca'(3), 'b'(1), 'bb'(1), 'bbc'(2), 'bbca'(3), etc. When we sum the appeal (distinct character count) of all 15 substrings, we get 28.

example_2.py — Single Character

$ Input: s = "abc"

› Output: 10

💡 Note: Substrings: 'a'(1), 'ab'(2), 'abc'(3), 'b'(1), 'bc'(2), 'c'(1). Total appeal = 1+2+3+1+2+1 = 10.

example_3.py — Repeated Characters

$ Input: s = "aaaa"

› Output: 10

💡 Note: All substrings contain only the character 'a', so each has appeal 1. There are 10 total substrings: 4 of length 1, 3 of length 2, 2 of length 3, and 1 of length 4. Total = 4×1 + 3×1 + 2×1 + 1×1 = 10.

Visualization

Tap to expand

Understanding the Visualization

Initialize tracking variables

Set up total_appeal=0, current_appeal=0, and last_occurrence map

Process each character

For each position, calculate how many new substrings this character contributes to

Calculate contribution

contribution = current_index - last_occurrence_index

Update running totals

Add contribution to current_appeal, then add current_appeal to total

Key Takeaway

🎯 Key Insight: Instead of generating O(n²) substrings, we calculate how each character contributes to all substrings ending at each position. This transforms the problem from O(n³) brute force to O(n) optimal solution by leveraging the mathematical relationship between character positions and their contributions.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, constant time operations for each character

✓ Linear Growth

Space Complexity

O(k)

O(k) where k is the number of distinct characters (at most 26 for lowercase letters)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Time limit: The solution must run efficiently for large inputs

Asked in

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

The optimal solution uses dynamic programming with contribution counting to achieve O(n) time complexity. Instead of generating all substrings, we calculate how many substrings each character contributes to as a distinct element. The key insight is that when processing character at position i, it contributes to (i - last_occurrence + 1) substrings ending at position i. This elegant approach transforms a potentially cubic problem into a linear one.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Contribution Counting (Optimal)	O(n)	O(k)	Count how many substrings each character contributes to as a distinct element
Brute Force (Generate All Substrings)	O(n³)	O(n)	Generate all possible substrings and count distinct characters in each

Dynamic Programming with Contribution Counting (Optimal) — Algorithm Steps

Initialize variables to track total appeal and current substring appeal ending at each position
Maintain a hash map to store the last occurrence index of each character
For each character at position i, calculate its contribution to all substrings ending at i
A character contributes to (last_index + 1) substrings, where last_index is its previous occurrence
Update the current appeal and add it to the total sum
Update the last occurrence of the current character

Visualization

Tap to expand

Step-by-Step Walkthrough

Process 'a' at index 0

Contributes to 1 substring: 'a'. Current appeal = 1, Total = 1

Process 'b' at index 1

Contributes to 2 substrings: 'ab', 'b'. Current appeal = 3, Total = 4

Process 'c' at index 2

Contributes to 3 substrings: 'abc', 'bc', 'c'. Current appeal = 6, Total = 10

Mathematical insight

Each character contributes based on distance from its last occurrence

Code -

solution.c — C

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

long long totalAppealOfAString(char* s) {
    int n = strlen(s);
    long long totalAppeal = 0;
    long long currentAppeal = 0;
    int lastOccurrence[256]; // ASCII characters
    
    // Initialize last occurrence to -1
    for (int i = 0; i < 256; i++) {
        lastOccurrence[i] = -1;
    }
    
    for (int i = 0; i < n; i++) {
        unsigned char c = (unsigned char)s[i];
        
        // Calculate contribution of current character
        long long contribution = i - lastOccurrence[c];
        
        // Update current appeal
        currentAppeal += contribution;
        
        // Add to total appeal
        totalAppeal += currentAppeal;
        
        // Update last occurrence
        lastOccurrence[c] = i;
    }
    
    return totalAppeal;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline and quotes
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"' && s[strlen(s)-1] == '"') {
        s[strlen(s)-1] = '\0';
        memmove(s, s+1, strlen(s));
    }
    
    printf("%lld\n", totalAppealOfAString(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, constant time operations for each character

✓ Linear Growth

Space Complexity

O(k)

O(k) where k is the number of distinct characters (at most 26 for lowercase letters)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Time limit: The solution must run efficiently for large inputs

43.6K Views

Medium Frequency

~25 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Contribution Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler