The Employee That Worked on the Longest Task

The Employee That Worked on the Longest Task - Problem

Array Easy

There are n employees, each with a unique id from 0 to n - 1.

You are given a 2D integer array logs where logs[i] = [id_i, leaveTime_i] where:

id_i is the id of the employee that worked on the ith task, and
leaveTime_i is the time at which the employee finished the ith task. All the values leaveTime_i are unique.

Note that the ith task starts the moment right after the (i - 1)th task ends, and the 0th task starts at time 0.

Return the id of the employee that worked the task with the longest time. If there is a tie between two or more employees, return the smallest id among them.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: Task durations: [3-0=3, 5-3=2, 9-5=4, 15-9=6]. Employee 1 worked the longest task (6 time units).

Example 2 — Tie Breaking

$ Input: logs = [[1,1],[2,3],[3,4]]

› Output: 1

💡 Note: Task durations: [1-0=1, 3-1=2, 4-3=1]. Employee 2 has the longest task (2 time units).

Example 3 — Same Duration Different IDs

$ Input: logs = [[2,4],[1,7],[3,8]]

› Output: 1

💡 Note: Task durations: [4-0=4, 7-4=3, 8-7=1]. Employee 2 worked the longest task (4 time units).

Constraints

1 ≤ logs.length ≤ 500
logs[i].length == 2
0 ≤ id_i ≤ 499
1 ≤ leaveTime_i ≤ 500
id_i != id_i+1
leaveTime_i are sorted in a strictly increasing order

Visualization

Tap to expand

Asked in

A Amazon 12 🍎 Apple 8

The key insight is that each task's duration equals the difference between consecutive leave times. Best approach is single pass optimization which calculates durations and tracks maximum simultaneously. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Calculate All Durations

⏱️ Time: O(n) Space: O(n)

First pass calculates the duration of each task by subtracting consecutive leave times. Second pass finds the employee with the maximum task duration, preferring smaller employee IDs in case of ties.

Single Pass Optimization

⏱️ Time: O(n) Space: O(1)

Instead of storing all durations, we calculate each task duration on the fly and immediately check if it's the new maximum. This saves space and reduces the number of passes through the data.

Brute Force - Calculate All Durations — Algorithm Steps

Step 1: Calculate duration for each task (current_leave_time - previous_leave_time)
Step 2: Find the maximum duration among all tasks
Step 3: Return the employee ID with maximum duration (smallest ID if tied)

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Durations

Compute duration for each task using consecutive leave times

Find Maximum

Identify the longest task duration

Return Employee

Return employee ID with longest task (smallest ID if tied)

Code -

solution.c — C

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

int solution(int logs[][2], int n) {
    int* durations = (int*)malloc(n * sizeof(int));
    
    // Calculate duration for each task
    for (int i = 0; i < n; i++) {
        if (i == 0) {
            durations[i] = logs[i][1] - 0;  // First task starts at time 0
        } else {
            durations[i] = logs[i][1] - logs[i-1][1];
        }
    }
    
    // Find employee with maximum duration (smallest ID if tied)
    int maxDuration = durations[0];
    for (int i = 1; i < n; i++) {
        if (durations[i] > maxDuration) {
            maxDuration = durations[i];
        }
    }
    
    for (int i = 0; i < n; i++) {
        if (durations[i] == maxDuration) {
            free(durations);
            return logs[i][0];
        }
    }
    
    free(durations);
    return logs[0][0];
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse 2D array manually
    int logs[1000][2];
    int n = 0;
    
    char* ptr = strchr(line, '[');
    ptr++; // Skip first [
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            logs[n][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++; // Skip comma
            logs[n][1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            ptr++; // Skip ]
            n++;
        }
        ptr++;
    }
    
    int result = solution(logs, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the logs array: one to calculate durations, one to find maximum

✓ Linear Growth

Space Complexity

O(n)

Extra array to store task durations for each log entry

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~15 min Avg. Time

485 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

Brute Force - Calculate All Durations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler