Count the Number of Special Characters II

Count the Number of Special Characters II - Problem

You are given a string word. Your task is to find special characters that follow a very specific pattern.

A letter c is considered special if it meets both of these conditions:

It appears in both lowercase and uppercase forms in the string
Every lowercase occurrence of c appears before the first uppercase occurrence of c

For example, in the string "aaAbcBC":

Letter 'a' is special: lowercase 'a' appears at indices 0,1 and uppercase 'A' appears at index 2 ✅
Letter 'b' is NOT special: uppercase 'B' appears at index 4, but lowercase 'b' appears at index 5 (after the uppercase) ❌
Letter 'c' is special: lowercase 'c' appears at index 6 and uppercase 'C' appears at index 7 ✅

Return the count of such special letters.

Input & Output

example_1.py — Basic case with mixed ordering

$ Input: word = "aaAbcBC"

› Output: 2

💡 Note: Letters 'a' and 'c' are special. For 'a': lowercase at positions 0,1 come before uppercase at position 2. For 'c': lowercase at position 4 comes before uppercase at position 6. Letter 'b' is not special because lowercase 'b' at position 3 comes after uppercase 'B' at position 5.

example_2.py — All lowercase before uppercase

$ Input: word = "abc"

› Output: 0

💡 Note: No special characters because there are no uppercase letters in the string. For a character to be special, it must appear in both lowercase and uppercase forms.

example_3.py — Perfect special characters

$ Input: word = "abcdefABCDEF"

› Output: 6

💡 Note: All letters a-f are special because all lowercase letters appear first (positions 0-5) followed by all uppercase letters (positions 6-11). This satisfies the ordering condition for all 6 letters.

Constraints

1 ≤ word.length ≤ 10⁴
word consists of only English letters (both lowercase and uppercase)
Follow-up: Can you solve this in O(n) time and O(1) extra space?

Visualization

Tap to expand

Understanding the Visualization

Scan the String

Track positions of each character as we encounter them

Update Positions

Maintain last lowercase and first uppercase positions for each letter

Validate Ordering

Check if all lowercase positions come before first uppercase position

Count Special Letters

Sum up letters that satisfy both existence and ordering conditions

Key Takeaway

🎯 Key Insight: We only need to track the last lowercase position and first uppercase position for each letter. If last_lowercase < first_uppercase, the letter is special!

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 19

The optimal solution uses a one-pass hash table approach to track the last lowercase and first uppercase positions for each letter. A character is special if it appears in both forms and all lowercase occurrences come before the first uppercase occurrence. The key insight is that we only need to compare the last lowercase position with the first uppercase position to validate the ordering condition.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n)	O(26) = O(1)	First pass records positions, second pass validates the ordering condition
Brute Force (Nested Character Checks)	O(26*n) = O(n)	O(1)	For each letter, scan the string multiple times to check lowercase/uppercase positions
One-Pass Hash Table (Optimal)	O(n)	O(26) = O(1)	Track both positions simultaneously while scanning the string once

Two-Pass Hash Table — Algorithm Steps

First pass: iterate through the string and record first uppercase and last lowercase positions for each letter
Second pass: for each letter that has both forms, check if last lowercase position < first uppercase position
Count letters that satisfy both conditions

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass - Record Uppercase

Find first occurrence of each uppercase letter

Second Pass - Record Lowercase

Find last occurrence of each lowercase letter

Validation

Check if last lowercase < first uppercase for each letter

Code -

solution.c — C

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

int numberOfSpecialChars(char* word) {
    int firstUpper[26];
    int lastLower[26];
    
    // Initialize arrays (-1 means not found)
    for (int i = 0; i < 26; i++) {
        firstUpper[i] = -1;
        lastLower[i] = -1;
    }
    
    int len = strlen(word);
    
    // First pass: record first uppercase positions
    for (int i = 0; i < len; i++) {
        if (isupper(word[i])) {
            int idx = word[i] - 'A';
            if (firstUpper[idx] == -1) {
                firstUpper[idx] = i;
            }
        }
    }
    
    // Second pass: record last lowercase positions
    for (int i = 0; i < len; i++) {
        if (islower(word[i])) {
            int idx = word[i] - 'a';
            lastLower[idx] = i;
        }
    }
    
    // Count special characters
    int count = 0;
    for (int i = 0; i < 26; i++) {
        if (lastLower[i] != -1 && firstUpper[i] != -1 && 
            lastLower[i] < firstUpper[i]) {
            count++;
        }
    }
    
    return count;
}

int main() {
    char word[1001];
    fgets(word, sizeof(word), stdin);
    word[strcspn(word, "\n")] = 0;
    if (word[0] == '"') {
        int len = strlen(word);
        memmove(word, word + 1, len - 2);
        word[len - 2] = '\0';
    }
    printf("%d\n", numberOfSpecialChars(word));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the string of length n, plus O(26) to check all letters

✓ Linear Growth

Space Complexity

O(26) = O(1)

Two hash tables storing at most 26 entries each (one for each letter)

✓ Linear Space

18.4K Views

Medium Frequency

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

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler