First Letter to Appear Twice - Practice Coding Problems

First Letter to Appear Twice - Problem

Given a string s consisting of lowercase English letters, return the first letter to appear twice.

The twist here is in understanding what "first" means: A letter a appears twice before another letter b if the second occurrence of a comes before the second occurrence of b.

Example: In the string "abccba", both 'c' and 'b' appear twice, but 'c' completes its second occurrence at index 3, while 'b' completes its second occurrence at index 4. Therefore, 'c' is the answer.

You are guaranteed that the input string contains at least one letter that appears twice.

Input & Output

example_1.py — Basic Case

$ Input: s = "abccba"

› Output: "c"

💡 Note: The letter 'c' appears at indices 2 and 3. The letter 'b' appears at indices 1 and 4. The letter 'a' appears at indices 0 and 5. Since 'c' completes its second occurrence first (at index 3), it is the first letter to appear twice.

example_2.py — Early Duplicate

$ Input: s = "abcdd"

› Output: "d"

💡 Note: The letter 'd' appears at indices 3 and 4, making it the first (and only) letter to appear twice in this string.

example_3.py — Multiple Duplicates

$ Input: s = "abcabc"

› Output: "a"

💡 Note: Letters 'a', 'b', and 'c' all appear twice. 'a' completes its second occurrence at index 3, 'b' at index 4, and 'c' at index 5. Therefore, 'a' is the first to appear twice.

Constraints

2 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
s has at least one repeated letter

Visualization

Tap to expand

Understanding the Visualization

Setup Guest List

Prepare an empty attendance sheet (hash set)

Check Each Guest

As each guest arrives, check if they're already on the list

Spot the Duplicate

The first guest already on the list is your answer!

Key Takeaway

🎯 Key Insight: Just like a bouncer at a party instantly recognizes repeat visitors, our hash set gives us instant O(1) lookup to detect the first character attempting a 'second entry' into our string!

Asked in

G Google 28 a Amazon 23 f Meta 19 ⊞ Microsoft 15

The optimal solution uses a hash set to track seen characters in a single pass through the string. As we encounter each character, we check if it's already in our set - if yes, we've found our answer. This achieves O(n) time complexity and O(k) space complexity where k is the number of unique characters before finding the duplicate (at most 26 for lowercase letters).

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Set (Optimal)	O(n)	O(k)	Track seen characters in a set and return first duplicate immediately
Brute Force (Nested Loops)	O(n²)	O(1)	For each character, search backwards to see if it appeared before

One-Pass Hash Set (Optimal) — Algorithm Steps

Initialize an empty hash set to track seen characters
Iterate through each character in the string from left to right
For each character, check if it's already in the set
If yes, return this character (it's the first repeat)
If no, add the character to the set and continue

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize empty set

Start with empty set to track seen characters

Check and add

For each character, check if seen before, if not add to set

Found duplicate

When character already in set, we found our answer

Code -

solution.c — C

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

char repeatedCharacter(char* s) {
    bool seen[26] = {false};
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        int index = s[i] - 'a';
        if (seen[index]) {
            return s[i];
        }
        seen[index] = true;
    }
    return ' ';
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each character at most once, and set operations (add/contains) are O(1) on average

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of unique characters before finding the first duplicate (at most 26 for lowercase letters)

✓ Linear Space

23.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

One-Pass Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler