Count Substrings with Only One Distinct Letter

Count Substrings with Only One Distinct Letter - Problem

Math String Easy

Count Substrings with Only One Distinct Letter

Given a string s, you need to find the total number of substrings where all characters in the substring are exactly the same.

A substring is a contiguous sequence of characters within a string. For example, in the string "aaabb", valid single-character substrings include "a", "aa", "aaa", "b", and "bb".

Goal: Return the count of all possible substrings that contain only one distinct character.

Example: For s = "aaaba", the answer is 8 because we can form: "a" (4 times), "aa" (2 times), "aaa" (1 time), and "b" (1 time).

Input & Output

example_1.py — Basic case with mixed characters

$ Input: s = "aaaba"

› Output: 8

💡 Note: The substrings with one distinct letter are: "a" (appears 4 times), "aa" (appears 2 times), "aaa" (appears 1 time), "b" (appears 1 time). Total: 4 + 2 + 1 + 1 = 8.

example_2.py — All same characters

$ Input: s = "aaaa"

› Output: 10

💡 Note: With 4 consecutive 'a's, we get: "a" (4 times), "aa" (3 times), "aaa" (2 times), "aaaa" (1 time). Total: 4 + 3 + 2 + 1 = 10. This follows the formula n*(n+1)/2 = 4*5/2 = 10.

example_3.py — Single character edge case

$ Input: s = "a"

› Output: 1

💡 Note: Only one possible substring: "a" itself, which contains exactly one distinct character.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only lowercase English letters
String is guaranteed to be non-empty

Visualization

Tap to expand

Understanding the Visualization

Walk the Orchard

Move through the orchard identifying groups of same trees

Count Sections

For each group of n same trees, count n*(n+1)/2 continuous sections

Sum Results

Add up all section counts from different tree groups

Key Takeaway

🎯 Key Insight: Instead of checking every possible section individually, we group consecutive identical items and use the mathematical formula n×(n+1)/2 to instantly calculate how many continuous sections each group contributes.

Asked in

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

The optimal solution uses a mathematical approach with O(n) time complexity. Key insight: for any group of n consecutive identical characters, the number of valid substrings is n×(n+1)/2. We traverse the string once, identify groups of consecutive characters, apply this formula to each group, and sum the results.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n³)	O(1)	Check every possible substring to see if it contains only one distinct character
One-Pass Optimal (Mathematical)	O(n)	O(1)	Use mathematical formula to count substrings for each group of consecutive identical characters

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each possible starting position i
For each starting position, iterate through each ending position j >= i
Check if substring s[i:j+1] has only one distinct character
If yes, increment the counter
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Outer Loop

Start from each position i

Inner Loop

Extend to each position j >= i

Validation

Check if substring has one distinct character

Code -

solution.c — C

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

int countLetters(char* s) {
    int count = 0;
    int n = strlen(s);
    
    // Check every possible substring
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Check if substring s[i:j+1] has only one distinct character
            char firstChar = s[i];
            bool isValid = true;
            
            for (int k = i; k <= j; k++) {
                if (s[k] != firstChar) {
                    isValid = false;
                    break;
                }
            }
            
            if (isValid) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char input[1001];
    fgets(input, sizeof(input), stdin);
    
    // Remove quotes and newline
    int len = strlen(input);
    if (input[len-1] == '\n') input[len-1] = '\0';
    char* s = input + 1; // Skip first quote
    s[strlen(s)-1] = '\0'; // Remove last quote
    
    printf("%d\n", countLetters(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for generating all substrings and O(n) for checking each substring

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting and iteration

✓ Linear Space

42.8K Views

Medium Frequency

~15 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler