1class Solution {
2    public int earliestTime(int[][] tasks) {
3        // Initialize the answer with a sufficiently large value
4        // (acts as an upper bound based on the problem constraints)
5        int earliestFinishTime = 200;
6
7        // Iterate over each task, where:
8        // task[0] = start time of the task
9        // task[1] = duration of the task
10        for (int[] task : tasks) {
11            int startTime = task[0];
12            int duration = task[1];
13
14            // The finish time of the current task is start time + duration;
15            // keep track of the minimum finish time seen so far
16            earliestFinishTime = Math.min(earliestFinishTime, startTime + duration);
17        }
18
19        // Return the earliest possible finish time among all tasks
20        return earliestFinishTime;
21    }
22}
23```
24
25**Explanation of the approach:**
26
271. **Problem intent**: Each task is described by a start time and a duration. The goal is to find the earliest moment at which any single task can be completed.
28
292. **Step-by-step reasoning**:
30   - For each task, its completion time is simply `start + duration`.
31   - Since tasks are independent, the earliest overall completion time is the minimum of these values.
32   - The initial value `200` serves as a safe upper bound given typical constraint limits (e.g., values ≤ 100 each, so the sum never exceeds 200).
33
343. **Complexity**:
35   - **Time**: O(n), a single pass over the task list.
36   - **Space**: O(1), only a single tracking variable is used.
37
38**Alternative perspective**: The same logic can be expressed more concisely with the Stream API:
39
40```java
41class Solution {
42    public int earliestTime(int[][] tasks) {
43        // Map each task to its finish time and take the minimum
44        return Arrays.stream(tasks)
45                     .mapToInt(task -> task[0] + task[1])
46                     .min()
47                     .orElse(200);
48    }
49}
50

1class Solution {
2public:
3    int earliestTime(vector<vector<int>>& tasks) {
4        // Initialize the answer with a value larger than any possible finish time.
5        // Constraints guarantee start time + duration will not exceed this bound.
6        int earliestFinishTime = 200;
7
8        // Iterate over each task, where:
9        //   task[0] = start time of the task
10        //   task[1] = duration required to complete the task
11        for (const auto& task : tasks) {
12            int startTime = task[0];
13            int duration = task[1];
14
15            // The finish time of the current task is start time plus duration.
16            // Keep track of the minimum finish time seen so far.
17            earliestFinishTime = min(earliestFinishTime, startTime + duration);
18        }
19
20        // Return the earliest time at which any single task can be completed.
21        return earliestFinishTime;
22    }
23};
24

1/**
2 * Finds the earliest time at which any task can be completed.
3 *
4 * Each task is represented as a pair [startTime, duration],
5 * so its completion time is startTime + duration.
6 * The answer is the minimum completion time among all tasks.
7 *
8 * @param tasks - A list of tasks, where each task is [startTime, duration]
9 * @returns The earliest completion time among all tasks
10 */
11function earliestTime(tasks: number[][]): number {
12    // Track the smallest completion time found so far,
13    // initialized to positive infinity so any task will be smaller
14    let earliestFinish: number = Number.POSITIVE_INFINITY;
15
16    // Iterate over every task to compute its completion time
17    for (const task of tasks) {
18        const startTime: number = task[0];   // Time when the task starts
19        const duration: number = task[1];    // How long the task takes
20
21        // Completion time of the current task
22        const finishTime: number = startTime + duration;
23
24        // Update the minimum if this task finishes earlier
25        earliestFinish = Math.min(earliestFinish, finishTime);
26    }
27
28    return earliestFinish;
29}
30```
31
32A few notes on the rewrite:
33
341. **Explicit loop instead of spread**: The original `Math.min(...tasks.map(...))` is concise, but spreading a very large array into `Math.min` can hit the call-stack argument limit. The loop version is safe for any input size and avoids creating an intermediate array.
35
362. **Naming**: The method name `earliestTime` is kept unchanged as required; internal variables use descriptive camelCase names (`earliestFinish`, `startTime`, `duration`, `finishTime`).
37
383. **Alternative (functional) version** — if you prefer the original one-liner style with clearer naming:
39
40```typescript
41/**
42 * Finds the earliest completion time (startTime + duration) among all tasks.
43 *
44 * @param tasks - A list of tasks, where each task is [startTime, duration]
45 * @returns The earliest completion time among all tasks
46 */
47function earliestTime(tasks: number[][]): number {
48    // Use reduce to fold the tasks into the minimum completion time,
49    // which avoids the argument-spreading limitation of Math.min(...)
50    return tasks.reduce(
51        (minFinish: number, [startTime, duration]: number[]) =>
52            Math.min(minFinish, startTime + duration),
53        Number.POSITIVE_INFINITY
54    );
55}
56