Count the Number of Special Characters I - Practice Coding Problems

Count the Number of Special Characters I - Problem

You are given a string word. Your task is to find all the special characters in this string.

A character is considered special if it appears in both lowercase and uppercase forms within the same string. For example, if a string contains both 'a' and 'A', then the character 'a'/'A' is special.

Goal: Return the total count of special characters found in the string.

Example: In the string "AbBcC", we have:

'A' and 'a' - not both present
'B' and 'b' - both present ✓
'C' and 'c' - not both present

So the answer is 1 (only 'B'/'b' qualifies as special).

Input & Output

example_1.py — Basic Case

$ Input: word = "aaAbcBC"

› Output: 3

💡 Note: The special characters are 'a'/'A', 'b'/'B', and 'c'/'C'. All three appear in both lowercase and uppercase forms, so we return 3.

example_2.py — Partial Matches

$ Input: word = "abc"

› Output: 0

💡 Note: None of the characters 'a', 'b', 'c' have their uppercase counterparts 'A', 'B', 'C' in the string, so no characters are special.

example_3.py — Mixed Case

$ Input: word = "AbBcC"

› Output: 2

💡 Note: The characters 'b'/'B' and 'c'/'C' both appear in lowercase and uppercase forms. Character 'a'/'A' only appears as 'A' (uppercase), so it's not special. Result: 2.

Constraints

1 ≤ word.length ≤ 1000
word consists of only English letters (both lowercase and uppercase)
Characters can repeat multiple times in the string
Empty string is not a valid input

Visualization

Tap to expand

Understanding the Visualization

Meet each person

As you encounter each character, note them down in your detective notebook (hash set)

Look for their twin

For each new person, immediately check if their twin (opposite case) is already in your notebook

Mark the pair

When you find a complete twin pair, mark it as 'found' and increment your counter

Avoid double counting

Make sure you don't count the same twin pair twice by keeping track of already counted pairs

Key Takeaway

🎯 Key Insight: Like a detective tracking twin pairs, we use a hash set to remember who we've met and immediately check for their twins (opposite case). The moment we find both twins, we've discovered a special character pair!

Asked in

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

The optimal solution uses a one-pass hash table approach with O(n) time complexity. We maintain a set to track seen characters and immediately check for opposite case pairs as we traverse the string. Key insight: we only need to track character presence, not frequency, making this a straightforward set membership problem.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(n)	For each character, scan the entire string to find its opposite case
Two-Pass Hash Table	O(n)	O(1)	First pass to collect all characters, second pass to count special pairs
One-Pass Hash Table (Optimal)	O(n)	O(1)	Track both cases in single pass and count pairs immediately

Brute Force (Nested Loops) — Algorithm Steps

Initialize a counter and a set to track processed characters
For each character in the string, determine its opposite case
Scan the entire string to see if the opposite case exists
If found and not already counted, increment counter and mark as processed
Return the final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first character

Begin scanning from the first character 'A'

Look for opposite case

Search entire string for lowercase 'a'

Continue with next character

Move to 'b' and search for 'B'

Count special pairs

Increment counter when both cases found

Code -

solution.c — C

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

int numberOfSpecialChars(char* word) {
    int count = 0;
    bool processed[26] = {false};
    int len = strlen(word);
    
    for (int i = 0; i < len; i++) {
        char c = word[i];
        int index = tolower(c) - 'a';
        
        // Skip if already processed this character pair
        if (processed[index]) {
            continue;
        }
        
        // Check if opposite case exists
        char opposite = islower(c) ? toupper(c) : tolower(c);
        
        for (int j = 0; j < len; j++) {
            if (word[j] == opposite) {
                count++;
                processed[index] = true;
                break;
            }
        }
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n characters, we potentially scan the entire string of length n

⚠ Quadratic Growth

Space Complexity

O(n)

We use a set to track processed characters, which can grow up to n in the worst case

⚡ Linearithmic Space

25.8K Views

Medium Frequency

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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler