Problem

Table: Project

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| project_id  | int     |
| employee_id | int     |
+-------------+---------+
(project_id, employee_id) is the primary key (combination of columns with unique values) of this table.
employee_id is a foreign key (reference column) to Employee table.
Each row of this table indicates that the employee with employee_id is working on the project with project_id.

Table: Employee

+------------------+---------+
| Column Name      | Type    |
+------------------+---------+
| employee_id      | int     |
| name             | varchar |
| experience_years | int     |
+------------------+---------+
employee_id is the primary key (column with unique values) of this table.
Each row of this table contains information about one employee.

Write a solution to report the most experienced employees in each project. In case of a tie, report all employees with the maximum number of experience years.

Return the result table in any order.

The result format is in the following example.

Examples

Example 1:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

Input: 
Project table:
+-------------+-------------+
| project_id  | employee_id |
+-------------+-------------+
| 1           | 1           |
| 1           | 2           |
| 1           | 3           |
| 2           | 1           |
| 2           | 4           |
+-------------+-------------+
Employee table:
+-------------+--------+------------------+
| employee_id | name   | experience_years |
+-------------+--------+------------------+
| 1           | Khaled | 3                |
| 2           | Ali    | 2                |
| 3           | John   | 3                |
| 4           | Doe    | 2                |
+-------------+--------+------------------+
Output: 
+-------------+---------------+
| project_id  | employee_id   |
+-------------+---------------+
| 1           | 1             |
| 1           | 3             |
| 2           | 1             |
+-------------+---------------+
Explanation: Both employees with id 1 and 3 have the most experience among the employees of the first project. For the second project, the employee with id 1 has the most experience.

Solution

Method 1 – Join and Filter by Max Experience

Intuition

We need to find, for each project, the employee(s) with the highest experience. This is a classic group-by-max problem, solved by joining the tables and filtering for the maximum experience per project.

Approach

  1. Join Project and Employee on employee_id.
  2. For each project_id, find the maximum experience_years.
  3. Select employees whose experience_years equals the maximum for their project.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

SELECT p.project_id, p.employee_id
FROM Project p
JOIN Employee e ON p.employee_id = e.employee_id
JOIN (
    SELECT p2.project_id, MAX(e2.experience_years) AS max_exp
    FROM Project p2
    JOIN Employee e2 ON p2.employee_id = e2.employee_id
    GROUP BY p2.project_id
) t
ON p.project_id = t.project_id AND e.experience_years = t.max_exp;
 1
 2
 3
 4
 5
 6
 7
 8
 9
10

SELECT p.project_id, p.employee_id
FROM Project p
JOIN Employee e ON p.employee_id = e.employee_id
JOIN (
    SELECT p2.project_id, MAX(e2.experience_years) AS max_exp
    FROM Project p2
    JOIN Employee e2 ON p2.employee_id = e2.employee_id
    GROUP BY p2.project_id
) t
ON p.project_id = t.project_id AND e.experience_years = t.max_exp;
1
2
3
4
5
6
7

# Assume Project and Employee are pandas DataFrames
import pandas as pd
def most_experienced_employees(Project: pd.DataFrame, Employee: pd.DataFrame) -> pd.DataFrame:
    merged = Project.merge(Employee, on='employee_id')
    max_exp = merged.groupby('project_id')['experience_years'].transform('max')
    result = merged[merged['experience_years'] == max_exp][['project_id', 'employee_id']]
    return result

Complexity

  • ⏰ Time complexity: O(N) where N is the number of rows in Project.
  • 🧺 Space complexity: O(N) for the join and grouping.