Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/2432.html

2432. The Employee That Worked on the Longest Task

  • Difficulty: Easy.
  • Related Topics: .
  • Similar Questions: .

Problem

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] = [idi, leaveTimei] where:

  • idi is the id of the employee that worked on the ith task, and

  • leaveTimei is the time at which the employee finished the ith task. All the values leaveTimei 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**.

  Example 1:

Input: n = 10, logs = [[0,3],[2,5],[0,9],[1,15]]
Output: 1
Explanation: 
Task 0 started at 0 and ended at 3 with 3 units of times.
Task 1 started at 3 and ended at 5 with 2 units of times.
Task 2 started at 5 and ended at 9 with 4 units of times.
Task 3 started at 9 and ended at 15 with 6 units of times.
The task with the longest time is task 3 and the employee with id 1 is the one that worked on it, so we return 1.

Example 2:

Input: n = 26, logs = [[1,1],[3,7],[2,12],[7,17]]
Output: 3
Explanation: 
Task 0 started at 0 and ended at 1 with 1 unit of times.
Task 1 started at 1 and ended at 7 with 6 units of times.
Task 2 started at 7 and ended at 12 with 5 units of times.
Task 3 started at 12 and ended at 17 with 5 units of times.
The tasks with the longest time is task 1. The employees that worked on it is 3, so we return 3.

Example 3:

Input: n = 2, logs = [[0,10],[1,20]]
Output: 0
Explanation: 
Task 0 started at 0 and ended at 10 with 10 units of times.
Task 1 started at 10 and ended at 20 with 10 units of times.
The tasks with the longest time are tasks 0 and 1. The employees that worked on them are 0 and 1, so we return the smallest id 0.

  Constraints:

  • 2 <= n <= 500

  • 1 <= logs.length <= 500

  • logs[i].length == 2

  • 0 <= idi <= n - 1

  • 1 <= leaveTimei <= 500

  • idi != idi+1

  • leaveTimei are sorted in a strictly increasing order.

Solution (Java, C++, Python)

  • class Solution {
        public int hardestWorker(int n, int[][] logs) {
            int ans = 0, mx = 0, last = 0;
            for (var e : logs) {
                int uid = e[0], t = e[1];
                int x = t - last;
                if (mx < x) {
                    mx = x;
                    ans = uid;
                } else if (mx == x && ans > uid) {
                    ans = uid;
                }
                last = t;
            }
            return ans;
        }
    }
    
  • class Solution {
    public:
        int hardestWorker(int n, vector<vector<int>>& logs) {
            int ans = 0, mx = 0, last = 0;
            for (auto& e : logs) {
                int uid = e[0], t = e[1];
                int x = t - last;
                if (mx < x) {
                    mx = x;
                    ans = uid;
                } else if (mx == x && ans > uid) {
                    ans = uid;
                }
                last = t;
            }
            return ans;
        }
    };
    
  • class Solution:
        def hardestWorker(self, n: int, logs: List[List[int]]) -> int:
            ans = mx = last = 0
            for uid, t in logs:
                x = t - last
                if mx < x:
                    mx = x
                    ans = uid
                elif mx == x and ans > uid:
                    ans = uid
                last = t
            return ans
    
    
  • func hardestWorker(n int, logs [][]int) int {
    	ans, mx, last := 0, 0, 0
    	for _, e := range logs {
    		uid, t := e[0], e[1]
    		x := t - last
    		if mx < x {
    			mx, ans = x, uid
    		} else if mx == x && ans > uid {
    			ans = uid
    		}
    		last = t
    	}
    	return ans
    }
    
  • function hardestWorker(n: number, logs: number[][]): number {
        let [ans, max_num] = logs[0];
        for (let i = 1; i < logs.length; i++) {
            let duration = logs[i][1] - logs[i - 1][1];
            let id = logs[i][0];
            if (duration > max_num || (duration == max_num && id < ans)) {
                ans = id;
                max_num = duration;
            }
        }
        return ans;
    }
    
    
  • impl Solution {
        pub fn hardest_worker(n: i32, logs: Vec<Vec<i32>>) -> i32 {
            let mut res = 0;
            let mut max = 0;
            let mut pre = 0;
            for log in logs.iter() {
                let t = log[1] - pre;
                if t > max || t == max && res > log[0] {
                    res = log[0];
                    max = t;
                }
                pre = log[1];
            }
            res
        }
    }
    
    

Explain:

nope.

Complexity:

  • Time complexity : O(n).
  • Space complexity : O(n).

All Problems

All Solutions