Unique Email Addresses - Practice Coding Problems

Unique Email Addresses - Problem

Ever wonder how Gmail handles email forwarding rules? This problem simulates a simplified version of that system!

You're given an array of email addresses, and you need to determine how many unique destinations they actually represent after applying these forwarding rules:

Dot Rule: In the local part (before @), all dots '.' are ignored
Example: alice.bob@gmail.com → alicebob@gmail.com
Plus Rule: In the local part, everything after the first '+' is ignored
Example: alice+shopping@gmail.com → alice@gmail.com

Important: These rules only apply to the local part (before @), not the domain!

Goal: Return the number of unique email addresses that will actually receive emails.

Input & Output

example_1.py — Basic Example

$ Input: ["test.email+alex@leetcode.com","test.e.mail+bob.cathy@leetcode.com","testemail+david@lee.tcode.com"]

› Output: 2

💡 Note: First email: 'test.email+alex@leetcode.com' becomes 'testemail@leetcode.com' (remove dots and +alex). Second email: 'test.e.mail+bob.cathy@leetcode.com' becomes 'testemail@leetcode.com' (remove dots and +bob.cathy) - same as first! Third email: 'testemail+david@lee.tcode.com' becomes 'testemail@lee.tcode.com' (remove +david) - different domain. Result: 2 unique addresses.

example_2.py — Single Email

$ Input: ["a@leetcode.com"]

› Output: 1

💡 Note: Only one email provided, and it has no dots or plus signs, so it remains 'a@leetcode.com'. Result: 1 unique address.

example_3.py — Multiple Plus Signs

$ Input: ["test+multiple+plus@example.com","test@example.com"]

› Output: 1

💡 Note: First email: 'test+multiple+plus@example.com' becomes 'test@example.com' (only remove everything after the FIRST plus). Second email: 'test@example.com' is already normalized. Both emails resolve to the same address, so result is 1.

Visualization

Tap to expand

Understanding the Visualization

Split at @ symbol

Separate each email into local part (before @) and domain part (after @)

Apply plus rule

Remove everything after the first '+' in the local part

Apply dot rule

Remove all '.' characters from the local part

Reconstruct & store

Combine normalized local part with domain and add to hash set

Count unique

The size of the hash set gives us the number of unique addresses

Key Takeaway

🎯 Key Insight: Use a hash set to automatically handle uniqueness - normalize once and let the data structure do the deduplication work for you!

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process each email exactly once, and hash set operations are O(1) on average

✓ Linear Growth

Space Complexity

O(n)

In worst case, all emails are unique so we store n normalized emails in the hash set

⚡ Linearithmic Space

Constraints

1 ≤ emails.length ≤ 100
1 ≤ emails[i].length ≤ 100
emails[i] consists of lowercase English letters, '+', '.' and '@'
Each emails[i] contains exactly one '@' character
All local and domain names are non-empty
Local names do not start with a '+' character

Asked in

G Google 47 f Meta 23 a Amazon 18 ⊞ Microsoft 12

The optimal solution uses a hash set to normalize each email address by removing dots and plus-suffixes from the local part, then counting unique normalized addresses. This achieves O(n) time complexity with automatic duplicate handling.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Compare All Pairs)	O(n²)	O(n)	Normalize each email and compare with all previously processed emails
One-Pass Hash Set (Optimal)	O(n)	O(n)	Normalize each email and use a hash set to track unique addresses in one pass

Brute Force (Compare All Pairs) — Algorithm Steps

Initialize a list to store normalized unique emails
For each email in the input array:
Split the email into local and domain parts at '@'
Normalize the local part: remove dots and everything after first '+'
Reconstruct the normalized email
Compare with all emails in our unique list
If not found, add to unique list
Return the count of unique emails

Visualization

Tap to expand

Step-by-Step Walkthrough

Process First Email

Normalize 'test.email+tag@example.com' → 'testemail@example.com', add to unique list

Process Second Email

Normalize 'test.e.mail@example.com' → 'testemail@example.com', compare with first - match found!

Process Third Email

Normalize 'different@example.com' → 'different@example.com', compare with all previous - no match, add to list

Code -

solution.c — C

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

#define MAX_EMAILS 1000
#define MAX_EMAIL_LEN 100

char* normalizeEmail(char* email) {
    char* normalized = (char*)malloc(MAX_EMAIL_LEN);
    char* atPos = strchr(email, '@');
    int localLen = atPos - email;
    
    // Copy and normalize local part
    char local[MAX_EMAIL_LEN];
    strncpy(local, email, localLen);
    local[localLen] = '\0';
    
    // Remove everything after first '+'
    char* plusPos = strchr(local, '+');
    if (plusPos != NULL) {
        *plusPos = '\0';
    }
    
    // Remove all dots and build normalized local part
    char normalizedLocal[MAX_EMAIL_LEN];
    int j = 0;
    for (int i = 0; local[i] != '\0'; i++) {
        if (local[i] != '.') {
            normalizedLocal[j++] = local[i];
        }
    }
    normalizedLocal[j] = '\0';
    
    // Combine normalized local with domain
    sprintf(normalized, "%s%s", normalizedLocal, atPos);
    return normalized;
}

int numUniqueEmails(char emails[][MAX_EMAIL_LEN], int emailsSize) {
    char uniqueEmails[MAX_EMAILS][MAX_EMAIL_LEN];
    int uniqueCount = 0;
    
    for (int i = 0; i < emailsSize; i++) {
        char* normalized = normalizeEmail(emails[i]);
        
        // Check if this normalized email already exists
        int found = 0;
        for (int j = 0; j < uniqueCount; j++) {
            if (strcmp(uniqueEmails[j], normalized) == 0) {
                found = 1;
                break;
            }
        }
        
        // If not found, add to unique list
        if (!found) {
            strcpy(uniqueEmails[uniqueCount], normalized);
            uniqueCount++;
        }
        
        free(normalized);
    }
    
    return uniqueCount;
}

int main() {
    char emails[MAX_EMAILS][MAX_EMAIL_LEN];
    int count = 0;
    
    // Simple parsing - read emails line by line
    char line[1000];
    if (fgets(line, sizeof(line), stdin)) {
        char* token = strtok(line, ",");
        while (token != NULL && count < MAX_EMAILS) {
            // Remove quotes and whitespace
            while (*token == ' ' || *token == '"' || *token == '[') token++;
            char* end = token + strlen(token) - 1;
            while (end > token && (*end == ' ' || *end == '"' || *end == ']' || *end == '\n')) {
                *end = '\0';
                end--;
            }
            if (strlen(token) > 0) {
                strcpy(emails[count], token);
                count++;
            }
            token = strtok(NULL, ",");
        }
    }
    
    printf("%d\n", numUniqueEmails(emails, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n emails, we potentially compare with up to n previously processed emails

⚠ Quadratic Growth

Space Complexity

O(n)

In worst case, we store n unique normalized emails

⚡ Linearithmic Space

Constraints

1 ≤ emails.length ≤ 100
1 ≤ emails[i].length ≤ 100
emails[i] consists of lowercase English letters, '+', '.' and '@'
Each emails[i] contains exactly one '@' character
All local and domain names are non-empty
Local names do not start with a '+' character

42.3K Views

Medium 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

Brute Force (Compare All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler