Delete Duplicate Emails - Practice Coding Problems

Delete Duplicate Emails - Problem

Database Easy

Email Database Cleanup Challenge

You're working as a database administrator for a company that has been collecting user emails for years. Over time, the same email addresses have been registered multiple times with different IDs, creating duplicates in your Person table.

The Problem: Clean up the database by removing duplicate emails, but keep the record with the smallest ID (the oldest registration).

Table Structure:

Person
+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| id          | int     |
| email       | varchar |
+-------------+---------+

Your Task: Write a DELETE statement (not SELECT) that removes all duplicate emails, preserving only the entry with the smallest id for each unique email.

Note: This is a database manipulation problem - you're actually modifying the table structure, not just querying it!

Input & Output

example_1.sql — Basic Duplicate Removal

$ Input: Person table: +----+------------------+ | id | email | +----+------------------+ | 1 | john@example.com | | 2 | bob@example.com | | 3 | john@example.com | +----+------------------+

› Output: Person table after deletion: +----+------------------+ | id | email | +----+------------------+ | 1 | john@example.com | | 2 | bob@example.com | +----+------------------+

💡 Note: The row with id=3 is deleted because it's a duplicate of john@example.com with a higher ID than the existing row (id=1).

example_2.sql — Multiple Duplicates

$ Input: Person table: +----+------------------+ | id | email | +----+------------------+ | 1 | alice@example.com| | 2 | bob@example.com | | 3 | alice@example.com| | 4 | charlie@ex.com | | 5 | alice@example.com| +----+------------------+

› Output: Person table after deletion: +----+------------------+ | id | email | +----+------------------+ | 1 | alice@example.com| | 2 | bob@example.com | | 4 | charlie@ex.com | +----+------------------+

💡 Note: Rows with id=3 and id=5 are deleted because they are duplicates of alice@example.com. Only the record with the smallest ID (id=1) is kept.

example_3.sql — No Duplicates

$ Input: Person table: +----+------------------+ | id | email | +----+------------------+ | 1 | john@example.com | | 2 | jane@example.com | | 3 | bob@example.com | +----+------------------+

› Output: Person table after deletion: +----+------------------+ | id | email | +----+------------------+ | 1 | john@example.com | | 2 | jane@example.com | | 3 | bob@example.com | +----+------------------+

💡 Note: No rows are deleted because all email addresses are unique. The table remains unchanged.

Visualization

Tap to expand

Understanding the Visualization

Identify Duplicates

Find all email addresses that appear multiple times in the database

Compare IDs

For each duplicate email, compare the ID numbers to find the smallest (oldest)

Mark for Deletion

Mark all duplicate entries with larger IDs for removal

Execute Deletion

Remove the marked records, leaving only unique emails with smallest IDs

Key Takeaway

🎯 Key Insight: Using a self-join with DELETE allows us to compare each row with all other rows having the same email and remove duplicates with higher IDs in a single, efficient database operation.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Self-join operation compares every row with every other row

⚠ Quadratic Growth

Space Complexity

O(n)

Temporary space needed for join operation and result set

⚡ Linearithmic Space

Constraints

1 ≤ Person table rows ≤ 10⁴
All emails are in lowercase format
id is unique and serves as the primary key
Email length: 1 ≤ email.length ≤ 100

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal approach uses a self-join with the DELETE statement: DELETE p1 FROM Person p1, Person p2 WHERE p1.email = p2.email AND p1.id > p2.id. This efficiently removes all duplicate emails in a single operation by comparing each row with others that have the same email but smaller IDs.

Common Approaches

Approach	Time	Space	Notes
✓ Self-Join Deletion	O(n²)	O(n)	Use self-join to identify and delete duplicates in one operation
Row-by-Row Deletion	O(n²)	O(1)	Delete duplicates one by one using correlated subqueries

Self-Join Deletion — Algorithm Steps

Join the Person table with itself (p1 and p2)
Match rows where p1.email = p2.email (same email)
Add condition where p1.id > p2.id (p1 has larger ID)
Delete all rows from p1 that match these conditions

Visualization

Tap to expand

Step-by-Step Walkthrough

Create two table aliases

p1 and p2 both reference the same Person table

Join on email

Match rows where emails are identical

Filter by ID

Keep only matches where p1.id > p2.id

Delete matches

Remove all rows from p1 that match the criteria

Code -

solution.c — C

// C implementation with self-join logic
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

struct Person {
    int id;
    char email[100];
};

int deleteDuplicateEmailsJoin(struct Person* persons, int count) {
    bool* toDelete = calloc(count, sizeof(bool));
    
    // Self-join simulation
    for (int i = 0; i < count; i++) {
        for (int j = 0; j < count; j++) {
            if (strcmp(persons[i].email, persons[j].email) == 0 && 
                persons[i].id > persons[j].id) {
                toDelete[i] = true;
            }
        }
    }
    
    // Compact array by removing deleted elements
    int writeIndex = 0;
    for (int i = 0; i < count; i++) {
        if (!toDelete[i]) {
            if (writeIndex != i) {
                persons[writeIndex] = persons[i];
            }
            writeIndex++;
        }
    }
    
    free(toDelete);
    return writeIndex;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Self-join operation compares every row with every other row

⚠ Quadratic Growth

Space Complexity

O(n)

Temporary space needed for join operation and result set

⚡ Linearithmic Space

Constraints

1 ≤ Person table rows ≤ 10⁴
All emails are in lowercase format
id is unique and serves as the primary key
Email length: 1 ≤ email.length ≤ 100

28.5K Views

Medium Frequency

~15 min Avg. Time

945 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

Self-Join Deletion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler