First Unique Character in a String - Practice Coding Problems

First Unique Character in a String - Problem

You are given a string s consisting of lowercase English letters. Your task is to find the first character that appears exactly once in the string and return its index position.

If no such unique character exists, return -1.

Example: In the string "leetcode", the character 'l' appears once at index 0, but 'e' appears multiple times. The first unique character is 't' at index 2.

This is a classic string processing problem that tests your ability to efficiently track character frequencies and find the optimal solution using hash tables.

Input & Output

example_1.py — Basic case with unique character

$ Input: s = "leetcode"

› Output: 0

💡 Note: The character 'l' appears only once in the string at index 0, making it the first unique character.

example_2.py — First unique not at beginning

$ Input: s = "loveleetcode"

› Output: 2

💡 Note: The characters 'l', 'o', and 'e' appear multiple times. The first character that appears exactly once is 'v' at index 2.

example_3.py — No unique characters

$ Input: s = "aabb"

› Output: -1

💡 Note: All characters appear more than once, so there is no unique character. Return -1.

Visualization

Tap to expand

Understanding the Visualization

Survey the Queue

Walk through once and record how many times each badge number appears

Find the First Unique

Walk through again from the front, checking your records to find the first person with a unique badge

Report Position

Return the position of that person, or -1 if everyone has duplicate badges

Key Takeaway

🎯 Key Insight: By building a frequency map first, we can efficiently identify unique characters without redundant counting, making this a classic two-pass optimization pattern.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the string, O(n) + O(n) = O(n)

✓ Linear Growth

Space Complexity

O(k)

Hash table stores at most k unique characters (26 for lowercase letters)

✓ Linear Space

Constraints

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

Asked in

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

The optimal solution uses a two-pass hash table approach with O(n) time and O(k) space complexity. First pass builds a frequency map, second pass finds the first character with frequency 1. This efficiently solves the problem without redundant character counting.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n)	O(k)	Build frequency map first, then find first unique character
Brute Force (Nested Loops)	O(n²)	O(1)	For each character, scan the entire string to count its frequency

Two-Pass Hash Table — Algorithm Steps

First pass: Build a hash table counting frequency of each character
Second pass: Iterate through string and check frequency in hash table
Return index of first character with frequency 1
If no unique character found, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass: Count Frequencies

Build hash table with character counts

Second Pass: Find First Unique

Scan string and check frequency map

Return Result

Return index of first character with count 1

Code -

solution.c — C

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

int firstUniqChar(char* s) {
    // First pass: count frequencies (assuming lowercase letters)
    int charCount[26] = {0};
    int n = strlen(s);
    
    for (int i = 0; i < n; i++) {
        charCount[s[i] - 'a']++;
    }
    
    // Second pass: find first unique
    for (int i = 0; i < n; i++) {
        if (charCount[s[i] - 'a'] == 1) {
            return i;
        }
    }
    
    return -1;
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = 0;
    }
    printf("%d\n", firstUniqChar(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the string, O(n) + O(n) = O(n)

✓ Linear Growth

Space Complexity

O(k)

Hash table stores at most k unique characters (26 for lowercase letters)

✓ Linear Space

Constraints

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

68.4K Views

High Frequency

~15 min Avg. Time

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

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler