Greatest English Letter in Upper and Lower Case

Greatest English Letter in Upper and Lower Case - Problem

You're given a string s containing English letters (both uppercase and lowercase). Your task is to find the greatest English letter that appears in both uppercase and lowercase forms within the string.

The "greatest" letter means the one that comes latest in the alphabet (e.g., 'Z' > 'Y' > 'X'). If you find such a letter, return it in uppercase. If no letter exists in both forms, return an empty string.

Example: In the string "lEeTcOdE", both 'E' and 'e' are present, so we return "E" (since E is the greatest qualifying letter).

Input & Output

example_1.py — Basic Case

$ Input: s = "lEeTcOdE"

› Output: "E"

💡 Note: The string contains both 'E' and 'e'. While other letters like 'l', 'T', 'c', 'O', 'd' exist, they don't have both cases present. 'E' is the greatest letter that appears in both uppercase and lowercase.

example_2.py — Multiple Pairs

$ Input: s = "arRAzFif"

› Output: "R"

💡 Note: Both 'A'/'a' and 'R'/'r' appear in both cases. Since 'R' comes after 'A' in the alphabet, 'R' is the greatest letter that satisfies the condition.

example_3.py — No Valid Pairs

$ Input: s = "AbCdEfGhIjK"

› Output: ""

💡 Note: Each letter appears in only one case (either uppercase or lowercase), but never both. Therefore, no letter satisfies the condition and we return an empty string.

Visualization

Tap to expand

Understanding the Visualization

Scan the Evidence

Go through each character in the string, keeping track of what you've seen

Look for Pairs

When you see a character, check if you've already seen its opposite case

Track the VIP

Keep updating your answer to always point to the most important (greatest) valid pair

Present Findings

Return the most important witness, or empty string if no pairs exist

Key Takeaway

🎯 Key Insight: We don't need to search the entire alphabet - just process characters as we encounter them and immediately check for their case partner. This gives us O(n) time complexity with early detection of valid pairs!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each character processed in O(1) time

✓ Linear Growth

Space Complexity

O(1)

Set can contain at most 52 characters (26 uppercase + 26 lowercase), which is constant space

✓ Linear Space

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase and uppercase English letters only
Return the result in uppercase format

Asked in

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

The optimal solution uses a one-pass hash table approach with O(n) time and O(1) space complexity. As we iterate through the string, we maintain a set of seen characters and immediately check if we've completed a letter pair (both uppercase and lowercase). We track the greatest valid letter found so far, updating it whenever we discover a new pair with a letter that comes later in the alphabet.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(1)	Build character set while tracking the greatest valid letter in one pass
Two-Pass Hash Table	O(n + 26) = O(n)	O(k) where k ≤ 52	First pass builds character frequency map, second pass finds greatest match
Brute Force (Nested Loops)	O(26 × n) = O(n)	O(1)	For each letter, scan entire string to check if both cases exist

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize a set to track seen characters and a variable for the result
Iterate through the string once
For each character, add it to the set
Check if we've now completed a pair (both cases of a letter)
If so, update our result if this letter is greater than current best
Return the result after the single pass

Visualization

Tap to expand

Step-by-Step Walkthrough

Process 'l'

Add 'l' to seen set, no uppercase 'L' yet

Process 'E'

Add 'E' to seen set, no lowercase 'e' yet

Process 'e'

Add 'e' to seen set, found 'E' already! Update result = 'E'

Continue...

Keep processing, updating result when finding greater pairs

Code -

solution.c — C

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

char* greatestLetter(char* s) {
    static char result_str[2];
    bool seen[256] = {false};
    char result = 0;
    
    for (int i = 0; i < strlen(s); i++) {
        char c = s[i];
        seen[(unsigned char)c] = true;
        
        // Check if we have both cases of this letter
        if (isupper(c)) {
            char lower = tolower(c);
            if (seen[(unsigned char)lower]) {
                if (result == 0 || c > result) {
                    result = c;
                }
            }
        } else if (islower(c)) {
            char upper = toupper(c);
            if (seen[(unsigned char)upper]) {
                if (result == 0 || upper > result) {
                    result = upper;
                }
            }
        }
    }
    
    if (result == 0) {
        result_str[0] = '\0';
    } else {
        result_str[0] = result;
        result_str[1] = '\0';
    }
    return result_str;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each character processed in O(1) time

✓ Linear Growth

Space Complexity

O(1)

Set can contain at most 52 characters (26 uppercase + 26 lowercase), which is constant space

✓ Linear Space

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase and uppercase English letters only
Return the result in uppercase format

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler