Unique Email Addresses - Problem

Every valid email consists of a local name and a domain name, separated by the '@' sign. Besides lowercase letters, the email may contain one or more '.' or '+'.

For example, in "[email protected]", "alice" is the local name, and "leetcode.com" is the domain name.

If you add periods '.' between some characters in the local name part of an email address, mail sent there will be forwarded to the same address without dots in the local name. Note that this rule does not apply to domain names.

For example, "[email protected]" and "[email protected]" forward to the same email address.

If you add a plus '+' in the local name, everything after the first plus sign will be ignored. This allows certain emails to be filtered. Note that this rule does not apply to domain names.

For example, "[email protected]" will be forwarded to "[email protected]".

It is possible to use both of these rules at the same time. Given an array of strings emails where we send one email to each emails[i], return the number of different addresses that actually receive mails.

Input & Output

Example 1 — Multiple Normalization Rules

$ Input: emails = ["[email protected]","[email protected]","[email protected]"]

› Output: 2

💡 Note: After normalization: "[email protected]" becomes "[email protected]", "[email protected]" becomes "[email protected]" (same as first), and "[email protected]" becomes "[email protected]". So 2 unique addresses.

Example 2 — Only Dot Normalization

$ Input: emails = ["[email protected]","[email protected]","[email protected]"]

› Output: 3

💡 Note: No dots or plus signs to normalize, so all three emails remain unique: "[email protected]", "[email protected]", "[email protected]".

Example 3 — Plus Sign Filtering

$ Input: emails = ["[email protected]","[email protected]","[email protected]"]

› Output: 1

💡 Note: All emails normalize to "[email protected]" because everything after the plus sign in the local part is ignored.

Constraints

1 ≤ emails.length ≤ 100
1 ≤ emails[i].length ≤ 100
emails[i] consist 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
Domain names end with the ".com" suffix

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 32 🍎 Apple 28 M Microsoft 25

The key insight is to normalize emails by removing dots from local names and ignoring text after plus signs, then use a hash set to count unique addresses. Best approach uses a hash set for O(1) uniqueness checking. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force Comparison

⏱️ Time: O(n²) Space: O(n)

For each email, normalize it and compare with all previously processed normalized emails to check if it's unique. This requires nested loops and doesn't use any efficient data structure.

Hash Set for Unique Tracking

⏱️ Time: O(n) Space: O(n)

Normalize each email by removing dots from local part and handling plus signs, then add to a hash set. The set automatically handles uniqueness, so we just return its size.

Brute Force Comparison — Algorithm Steps

Normalize each email by removing dots and handling plus signs
Compare each normalized email with all previous ones
Count unique addresses

Visualization

Tap to expand

Step-by-Step Walkthrough

Normalize Email

Remove dots and handle plus signs in local part

Compare

Check if normalized email exists in previous results

Count Unique

Add to list if unique, return final count

Code -

solution.c — C

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

char* normalize(char* email) {
    char* result = malloc(strlen(email) + 1);
    char* atPos = strchr(email, '@');
    int localLen = atPos - email;
    
    char local[localLen + 1];
    strncpy(local, email, localLen);
    local[localLen] = '\0';
    
    char* plusPos = strchr(local, '+');
    if (plusPos) {
        *plusPos = '\0';
    }
    
    char normalizedLocal[strlen(local) + 1];
    int j = 0;
    for (int i = 0; local[i]; i++) {
        if (local[i] != '.') {
            normalizedLocal[j++] = local[i];
        }
    }
    normalizedLocal[j] = '\0';
    
    sprintf(result, "%s%s", normalizedLocal, atPos);
    return result;
}

int solution(char emails[][100], int emailCount) {
    char normalized[1000][100];
    int count = 0;
    
    for (int i = 0; i < emailCount; i++) {
        char* norm = normalize(emails[i]);
        int found = 0;
        
        for (int j = 0; j < count; j++) {
            if (strcmp(normalized[j], norm) == 0) {
                found = 1;
                break;
            }
        }
        
        if (!found) {
            strcpy(normalized[count], norm);
            count++;
        }
        
        free(norm);
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char emails[1000][100];
    int emailCount = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token) {
        while (*token == ' ' || *token == '"') token++;
        char* end = token + strlen(token) - 1;
        while (end > token && (*end == ' ' || *end == '"' || *end == '\n')) end--;
        *(end + 1) = '\0';
        
        strcpy(emails[emailCount], token);
        emailCount++;
        
        token = strtok(NULL, ",]");
    }
    
    int result = solution(emails, emailCount);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops comparing each email with all previous emails

⚠ Quadratic Growth

Space Complexity

O(n)

Store normalized emails for comparison

⚡ Linearithmic Space

189.0K Views

High Frequency

~15 min Avg. Time

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

Unique Email Addresses - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler