Delete Duplicate Emails solution and explanation

DELETE p1 FROM Person p1 WHERE EXISTS (SELECT 1 FROM Person p2 WHERE p1.email = p2.email AND p1.id > p2.id);

DELETE FROM Person WHERE id NOT IN (SELECT min_id FROM (SELECT MIN(id) as min_id FROM Person GROUP BY email) as Temp);

def remove_duplicates(persons):
    email_to_id = {}
    for person_id, email in persons:
        if email not in email_to_id or person_id < email_to_id[email]:
            email_to_id[email] = person_id

    return [(id, email) for email, id in email_to_id.items()]

persons = [(1, "john@example.com"), (2, "bob@example.com"), (3, "john@example.com")]
persons = remove_duplicates(persons)
for person in persons:
    print(person)

import java.util.*;

class Person {
    int id;
    String email;

    Person(int id, String email) {
        this.id = id;
        this.email = email;
    }
}

public class Main {

    public static void removeDuplicates(List<Person> persons) {
        Map<String, Integer> emailToId = new HashMap<>();
        for(Person person : persons) {
            if (!emailToId.containsKey(person.email) || person.id < emailToId.get(person.email)) {
                emailToId.put(person.email, person.id);
            }
        }

        List<Person> uniquePersons = new ArrayList<>();
        for(Map.Entry<String, Integer> entry : emailToId.entrySet()) {
            uniquePersons.add(new Person(entry.getValue(), entry.getKey()));
        }

        persons.clear();
        persons.addAll(uniquePersons);
    }

    public static void main(String[] args) {
        List<Person> persons = new ArrayList<>();
        persons.add(new Person(1, "john@example.com"));
        persons.add(new Person(2, "bob@example.com"));
        persons.add(new Person(3, "john@example.com"));

        removeDuplicates(persons);

        for (Person person : persons) {
            System.out.println(person.id + " " + person.email);
        }
    }
}

#include <iostream>
#include <unordered_map>
#include <vector>
#include <string>

struct Person {
    int id;
    std::string email;
};

void removeDuplicates(std::vector<Person>& persons) {
    std::unordered_map<std::string, int> emailToId;
    for (const auto& person : persons) {
        if (emailToId.find(person.email) == emailToId.end() || person.id < emailToId[person.email]) {
            emailToId[person.email] = person.id;
        }
    }

    std::vector<Person> uniquePersons;
    for (const auto& [email, id] : emailToId) {
        uniquePersons.push_back({id, email});
    }
    persons = std::move(uniquePersons);
}

int main() {
    std::vector<Person> persons = {{1, "john@example.com"}, {2, "bob@example.com"}, {3, "john@example.com"}};
    removeDuplicates(persons);
    for (const auto& person : persons) {
        std::cout << "{" << person.id << ", " << person.email << "}" << std::endl;
    }
    return 0;
}

function removeDuplicates(persons) {
    const emailToId = {};
    persons.forEach(({ id, email }) => {
        if (!emailToId[email] || id < emailToId[email]) {
            emailToId[email] = id;
        }
    });

    return Object.keys(emailToId).map(email => ({ id: emailToId[email], email }));
}

const persons = [
    { id: 1, email: "john@example.com" },
    { id: 2, email: "bob@example.com" },
    { id: 3, email: "john@example.com" }
];

const uniquePersons = removeDuplicates(persons);
console.log(uniquePersons);

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

#define MAX_RECORDS 100
#define EMAIL_LENGTH 256

typedef struct {
    int id;
    char email[EMAIL_LENGTH];
} Person;

int comparePersons(const void *a, const void *b) {
    Person *personA = (Person *)a;
    Person *personB = (Person *)b;
    return (personA->id - personB->id);
}

void removeDuplicates(Person persons[], int *size) {
    int n = *size;
    qsort(persons, n, sizeof(Person), comparePersons);

    int uniqueCount = 0;
    for (int i = 0; i < n; i++) {
        if (i == 0 || strcmp(persons[i].email, persons[uniqueCount - 1].email) != 0) {
            persons[uniqueCount++] = persons[i];
        }
    }

    *size = uniqueCount;
}

int main() {
    Person persons[MAX_RECORDS] = {
        {1, "john@example.com"},
        {2, "bob@example.com"},
        {3, "john@example.com"}
    };
    int n = 3;

    removeDuplicates(persons, &n);

    for (int i = 0; i < n; i++) {
        printf("%d %s\n", persons[i].id, persons[i].email);
    }

    return 0;
}

using System;
using System.Collections.Generic;
using System.Linq;

public class Person {
    public int Id { get; set; }
    public string Email { get; set; }
}

public class Program {
    public static void RemoveDuplicates(List<Person> persons) {
        var emailToId = new Dictionary<string, int>();
        foreach (var person in persons) {
            if (!emailToId.ContainsKey(person.Email) || person.Id < emailToId[person.Email]) {
                emailToId[person.Email] = person.Id;
            }
        }

        var uniquePersons = emailToId.Select(e => new Person { Id = e.Value, Email = e.Key }).ToList();

        persons.Clear();
        persons.AddRange(uniquePersons);
    }

    public static void Main(string[] args) {
        List<Person> persons = new List<Person> {
            new Person { Id = 1, Email = "john@example.com" },
            new Person { Id = 2, Email = "bob@example.com" },
            new Person { Id = 3, Email = "john@example.com" }
        };

        RemoveDuplicates(persons);

        foreach (var person in persons) {
            Console.WriteLine($"{person.Id} {person.Email}");
        }
    }
}

DELETE FROM Person
WHERE id NOT IN (
  SELECT MIN(id)
  FROM Person
  GROUP BY email
);