The Employee That Worked on the Longest Task

The Employee That Worked on the Longest Task - Problem

Array Easy

You're managing a team of n employees in a busy workplace, each with a unique ID from 0 to n - 1. Throughout the day, tasks are completed in sequence, and you need to track which employee worked the longest on a single task.

You're given a 2D array logs where logs[i] = [employeeId, leaveTime] represents:

employeeId: The ID of the employee who completed the i-th task
leaveTime: The exact time when this employee finished the task

Important timing rules:

Task 0 starts at time 0
Each subsequent task starts immediately when the previous task ends
Task duration = leaveTime - startTime

Goal: Find the employee ID who worked on the task with the longest duration. In case of a tie, return the employee with the smallest ID.

Example: If logs = [[0,3],[2,5],[0,9],[1,15]], the task durations are [3,2,4,6] and employee 1 worked the longest (6 time units).

Input & Output

example_1.py — Basic Case

$ Input: n = 10, logs = [[0,3],[2,5],[0,9],[1,15]]

› Output: 1

💡 Note: Task durations: [3,2,4,6]. Employee 1 worked on the longest task (6 time units) from time 9 to 15.

example_2.py — Tie Breaking

$ Input: n = 26, logs = [[1,1],[3,7],[2,12],[7,17]]

› Output: 3

💡 Note: Task durations: [1,6,5,5]. Both employees 3 and 7 worked for 5-6 time units, but employee 3 has smaller ID.

example_3.py — Single Task

$ Input: n = 2, logs = [[0,10]]

› Output: 0

💡 Note: Only one task with duration 10. Employee 0 is the answer.

Constraints

2 ≤ n ≤ 500
1 ≤ logs.length ≤ 500
logs[i].length == 2
0 ≤ id_i ≤ n - 1
1 ≤ leaveTime_i ≤ 500
id_i != id_i+1
All leaveTime_i are unique and in strictly increasing order

Visualization

Tap to expand

Understanding the Visualization

Sequential Tasks

Tasks run one after another, each employee's duration = finish_time - start_time

Track Maximum

Keep track of longest duration seen so far and which employee achieved it

Handle Ties

If two employees have same duration, choose the one with smaller ID

Key Takeaway

🎯 Key Insight: Sequential task execution means we can calculate durations on-the-fly in a single pass, achieving optimal O(n) time and O(1) space complexity.

Asked in

a Amazon 15 G Google 8 ⊞ Microsoft 6 f Meta 4

The optimal solution uses a single-pass approach to calculate task durations on-the-fly while tracking the maximum duration and corresponding employee ID. Key insight: since tasks run sequentially, each duration is simply currentLeaveTime - previousLeaveTime, allowing us to solve in O(n) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Optimal Solution	O(n)	O(1)	Calculate durations and track maximum in one pass through the logs
Brute Force (Calculate All Durations)	O(n)	O(n)	Calculate all task durations first, then find the maximum

Single Pass Optimal Solution — Algorithm Steps

Initialize variables for tracking maximum duration and best employee
Iterate through logs, calculating each task duration as leaveTime - previousTime
Compare current duration with maximum, updating if larger or same duration but smaller employee ID
Update previousTime for next iteration
Return the employee ID with longest task duration

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with maxDuration=0, resultEmployee=0, prevTime=0

Process Each Log

Calculate duration and update maximum if needed

Return Result

Employee ID with longest task duration

Code -

solution.c — C

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

int hardestWorker(int n, int** logs, int logsSize) {
    int maxDuration = 0;
    int resultEmployee = 0;
    int prevTime = 0;
    
    for (int i = 0; i < logsSize; i++) {
        int employeeId = logs[i][0];
        int leaveTime = logs[i][1];
        
        // Calculate current task duration
        int duration = leaveTime - prevTime;
        
        // Update if this is the longest duration, or same duration but smaller employee ID
        if (duration > maxDuration || (duration == maxDuration && employeeId < resultEmployee)) {
            maxDuration = duration;
            resultEmployee = employeeId;
        }
        
        // Update previous time for next iteration
        prevTime = leaveTime;
    }
    
    return resultEmployee;
}

int main() {
    printf("C solution ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through n log entries, each taking O(1) time

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant amount of extra space for tracking variables

✓ Linear Space

26.8K Views

Medium Frequency

~12 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Single Pass Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler