Accounts Merge - Practice Coding Problems

Accounts Merge - Problem

Imagine you're working at a tech company where employees can have multiple email accounts, but sometimes they create duplicate profiles in your system. Your task is to merge accounts that belong to the same person by identifying shared email addresses.

Given a list of accounts where each account contains:

First element: name (string)
Remaining elements: emails associated with that account

The Challenge: Two accounts belong to the same person if they share at least one email address. Even accounts with the same name might belong to different people, but accounts belonging to the same person will always have the same name.

Your Goal: Return merged accounts where:

First element is the person's name
Remaining elements are all their emails in sorted order
No duplicate emails within each account

Example:
[["John", "a@gmail.com", "b@gmail.com"], ["John", "c@gmail.com"], ["John", "a@gmail.com", "d@gmail.com"]]
→ [["John", "a@gmail.com", "b@gmail.com", "c@gmail.com", "d@gmail.com"]]

The first and third accounts share a@gmail.com, so all three accounts belong to the same John!

Input & Output

Basic Account Merging

$ Input: accounts = [["John","johnsmith@mail.com","john_newyork@mail.com"],["John","johnsmith@mail.com","john00@mail.com"],["Mary","mary@mail.com"],["John","johnnybravo@mail.com"]]

› Output: [["John","john00@mail.com","john_newyork@mail.com","johnsmith@mail.com"],["Mary","mary@mail.com"],["John","johnnybravo@mail.com"]]

💡 Note: The first and second John accounts share 'johnsmith@mail.com', so they merge. The third John has no shared emails with others, so stays separate. Mary remains unchanged.

Transitive Merging

$ Input: accounts = [["Gabe","Gabe0@m.co","Gabe3@m.co","Gabe1@m.co"],["Kevin","Kevin3@m.co","Kevin5@m.co","Kevin0@m.co"],["Ethan","Ethan5@m.co","Ethan4@m.co","Ethan0@m.co"],["Hanzo","Hanzo3@m.co","Hanzo1@m.co","Hanzo0@m.co"],["Fern","Fern5@m.co","Fern1@m.co","Fern0@m.co"]]

› Output: [["Ethan","Ethan0@m.co","Ethan4@m.co","Ethan5@m.co"],["Gabe","Gabe0@m.co","Gabe1@m.co","Gabe3@m.co"],["Hanzo","Hanzo0@m.co","Hanzo1@m.co","Hanzo3@m.co"],["Fern","Fern0@m.co","Fern1@m.co","Fern5@m.co"],["Kevin","Kevin0@m.co","Kevin3@m.co","Kevin5@m.co"]]

💡 Note: No accounts share emails, so each person remains as a separate account with their emails sorted.

Single Account

$ Input: accounts = [["David","David0@m.co","David1@m.co"]]

› Output: [["David","David0@m.co","David1@m.co"]]

💡 Note: Edge case with only one account - return it with emails in sorted order.

Visualization

Tap to expand

Understanding the Visualization

Evidence Catalog

Create a master catalog where each piece of evidence (email) points to the first case file (account) that contained it

Connect the Dots

When you find the same evidence in multiple files, connect those files using Union-Find - they belong to the same person

Group Files

Find all connected case files by checking which files have the same root connection in your Union-Find structure

Consolidate Evidence

For each group, collect all unique evidence (emails) and organize them alphabetically

File Reports

Create final consolidated case files with the person's name and all their evidence sorted

Key Takeaway

🎯 Key Insight: This is fundamentally a graph connectivity problem! Accounts are nodes, shared emails create edges, and Union-Find efficiently finds connected components (people) in nearly linear time.

Time & Space Complexity

Time Complexity

⏱️

O(n × m × α(n))

n accounts, m emails per account, α is inverse Ackermann function (nearly constant)

✓ Linear Growth

Space Complexity

O(n × m)

Email to account mapping and Union-Find parent array

⚡ Linearithmic Space

Constraints

1 ≤ accounts.length ≤ 1000
2 ≤ accounts[i].length ≤ 10
1 ≤ accounts[i][j].length ≤ 30
accounts[i][0] consists of English letters
accounts[i][j] (for j > 0) is a valid email address
All emails within the same account are unique

Asked in

f Facebook 45 G Google 38 a Amazon 32 ⊞ Microsoft 28 Apple 15

The optimal solution uses Union-Find (Disjoint Set Union) to efficiently group accounts that share emails. We map each email to its first occurrence, then union accounts that share emails. Finally, we group accounts by their root parent and merge all emails in each group, returning them sorted. Time complexity: O(n × m × α(n)) where α is the inverse Ackermann function.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Disjoint Set Union)	O(n × m × α(n))	O(n × m)	Use Union-Find to efficiently group accounts that share emails
Brute Force (Graph Building)	O(n² × m²)	O(n × m)	Build a graph of accounts and use DFS to find connected components

Union-Find (Disjoint Set Union) — Algorithm Steps

Create a Union-Find data structure for accounts
Map each email to the first account that contains it
For each subsequent account containing that email, union with the first account
Group accounts by their root parent in Union-Find
Collect and sort all emails for each group

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Each account starts as its own parent in Union-Find

Map Emails

First occurrence of each email maps to account index

Union Operation

When same email appears again, union the accounts

Find Groups

Group accounts by their root parent

Merge & Sort

Collect all emails in each group and sort

Code -

solution.c — C

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

// Union-Find structure
typedef struct {
    int *parent;
    int *rank;
    int size;
} UnionFind;

UnionFind* createUnionFind(int n) {
    UnionFind* uf = (UnionFind*)malloc(sizeof(UnionFind));
    uf->parent = (int*)malloc(n * sizeof(int));
    uf->rank = (int*)calloc(n, sizeof(int));
    uf->size = n;
    
    for (int i = 0; i < n; i++) {
        uf->parent[i] = i;
    }
    return uf;
}

int find(UnionFind* uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find(uf, uf->parent[x]);
    }
    return uf->parent[x];
}

void unionSets(UnionFind* uf, int x, int y) {
    int px = find(uf, x);
    int py = find(uf, y);
    if (px == py) return;
    
    if (uf->rank[px] < uf->rank[py]) {
        uf->parent[px] = py;
    } else if (uf->rank[px] > uf->rank[py]) {
        uf->parent[py] = px;
    } else {
        uf->parent[py] = px;
        uf->rank[px]++;
    }
}

// Email to account mapping structure
typedef struct EmailMap {
    char* email;
    int account;
    struct EmailMap* next;
} EmailMap;

// Hash table for email mapping
#define HASH_SIZE 10007

unsigned int hash(const char* str) {
    unsigned int hash = 5381;
    int c;
    while ((c = *str++)) {
        hash = ((hash << 5) + hash) + c;
    }
    return hash % HASH_SIZE;
}

char*** accountsMerge(char*** accounts, int accountsSize, int* accountsColSize, int* returnSize, int** returnColumnSizes) {
    UnionFind* uf = createUnionFind(accountsSize);
    EmailMap* emailTable[HASH_SIZE] = {NULL};
    
    // Map emails to accounts and union
    for (int i = 0; i < accountsSize; i++) {
        for (int j = 1; j < accountsColSize[i]; j++) {
            char* email = accounts[i][j];
            unsigned int h = hash(email);
            
            EmailMap* current = emailTable[h];
            int found = 0;
            while (current) {
                if (strcmp(current->email, email) == 0) {
                    unionSets(uf, i, current->account);
                    found = 1;
                    break;
                }
                current = current->next;
            }
            
            if (!found) {
                EmailMap* newMap = (EmailMap*)malloc(sizeof(EmailMap));
                newMap->email = email;
                newMap->account = i;
                newMap->next = emailTable[h];
                emailTable[h] = newMap;
            }
        }
    }
    
    // Group and merge accounts (implementation continues...)
    // This would require additional data structures for grouping
    // and string manipulation functions
    
    *returnSize = 0; // Placeholder
    return NULL;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × α(n))

n accounts, m emails per account, α is inverse Ackermann function (nearly constant)

✓ Linear Growth

Space Complexity

O(n × m)

Email to account mapping and Union-Find parent array

⚡ Linearithmic Space

Constraints

1 ≤ accounts.length ≤ 1000
2 ≤ accounts[i].length ≤ 10
1 ≤ accounts[i][j].length ≤ 30
accounts[i][0] consists of English letters
accounts[i][j] (for j > 0) is a valid email address
All emails within the same account are unique

125.0K Views

High Frequency

~25 min Avg. Time

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

Union-Find (Disjoint Set Union) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler