1class Solution {
2    public int uniqueEmailGroups(String[] emails) {
3        // Use a set to store the normalized email addresses,
4        // since a set automatically discards duplicates.
5        Set<String> uniqueEmails = new HashSet<>();
6
7        for (String email : emails) {
8            // Split each email into the local name and the domain name
9            // using '@' as the separator.
10            String[] parts = email.split("@");
11            String localName = parts[0];
12            String domainName = parts[1];
13
14            // If a '+' appears in the local name, everything after it
15            // (including the '+') is ignored.
16            int plusIndex = localName.indexOf('+');
17            if (plusIndex != -1) {
18                localName = localName.substring(0, plusIndex);
19            }
20
21            // Remove all dots from the local name, as they are ignored,
22            // and convert it to lower case to make the comparison case-insensitive.
23            localName = localName.replace(".", "").toLowerCase();
24
25            // Normalize the domain name to lower case as well.
26            domainName = domainName.toLowerCase();
27
28            // Combine the processed local name and domain name to form the
29            // canonical email, then add it to the set.
30            String normalizedEmail = localName + "@" + domainName;
31            uniqueEmails.add(normalizedEmail);
32        }
33
34        // The size of the set is the number of distinct email addresses.
35        return uniqueEmails.size();
36    }
37}
38

1class Solution {
2public:
3    int uniqueEmailGroups(vector<string>& emails) {
4        // Set to store the normalized form of each email; duplicates are ignored.
5        unordered_set<string> uniqueAddresses;
6
7        for (const auto& email : emails) {
8            // Split the email into local and domain parts at the '@' separator.
9            size_t atPos = email.find('@');
10            string localPart = email.substr(0, atPos);
11            string domainPart = email.substr(atPos + 1);
12
13            // In the local part, anything after a '+' is ignored.
14            size_t plusPos = localPart.find('+');
15            if (plusPos != string::npos) {
16                localPart = localPart.substr(0, plusPos);
17            }
18
19            // Build the cleaned local part: drop '.' characters and lowercase the rest.
20            string cleanedLocal;
21            for (char c : localPart) {
22                if (c != '.') {
23                    cleanedLocal += static_cast<char>(tolower(c));
24                }
25            }
26
27            // Lowercase the domain part for case-insensitive comparison.
28            for (char& c : domainPart) {
29                c = static_cast<char>(tolower(c));
30            }
31
32            // Insert the normalized "local@domain" form into the set.
33            uniqueAddresses.insert(cleanedLocal + "@" + domainPart);
34        }
35
36        // The number of distinct entries equals the number of unique email groups.
37        return static_cast<int>(uniqueAddresses.size());
38    }
39};
40

1/**
2 * Counts the number of unique email groups after normalization.
3 *
4 * Normalization rules for each email (split into local and domain by '@'):
5 *  - Local part: ignore everything after a '+', remove all '.' characters,
6 *    and convert to lowercase.
7 *  - Domain part: convert to lowercase.
8 *
9 * Two emails belong to the same group if their normalized forms are identical.
10 *
11 * @param emails - The list of email addresses to process.
12 * @returns The count of distinct normalized emails.
13 */
14function uniqueEmailGroups(emails: string[]): number {
15    // Stores each normalized email; duplicates are automatically discarded.
16    const uniqueEmails: Set<string> = new Set<string>();
17
18    for (const email of emails) {
19        // Separate the email into its local and domain components.
20        let [localPart, domainPart] = email.split('@');
21
22        // Normalize the local part:
23        //  1. Drop any characters after the first '+'.
24        //  2. Remove all '.' characters.
25        //  3. Convert to lowercase.
26        localPart = localPart
27            .split('+')[0]
28            .replace(/\./g, '')
29            .toLowerCase();
30
31        // Normalize the domain part by lowercasing it.
32        domainPart = domainPart.toLowerCase();
33
34        // Combine the normalized parts into a single canonical key.
35        const normalizedEmail: string = localPart + domainPart;
36
37        // Record the canonical form; the Set ignores repeats.
38        uniqueEmails.add(normalizedEmail);
39    }
40
41    // The size of the Set equals the number of unique email groups.
42    return uniqueEmails.size;
43}
44