Button with Longest Push Time

Button with Longest Push Time - Problem

Array Easy

You are given a 2D array events which represents a sequence of events where a child pushes a series of buttons on a keyboard.

Each events[i] = [index_i, time_i] indicates that the button at index index_i was pressed at time time_i.

The array is sorted in increasing order of time. The time taken to press a button is the difference in time between consecutive button presses. The time for the first button is simply the time at which it was pressed.

Return the index of the button that took the longest time to push. If multiple buttons have the same longest time, return the button with the smallest index.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: Button durations: Button 1 at time 2 (duration=2), Button 2 at time 5 (duration=5-2=3), Button 3 at time 9 (duration=9-5=4), Button 1 at time 15 (duration=15-9=6). Button 1 has the longest press duration of 6.

Example 2 — First Button Winner

$ Input: events = [[6,1],[1,3],[1,8],[9,20]]

› Output: 9

💡 Note: Button durations: Button 6 (duration=1), Button 1 (duration=3-1=2), Button 1 (duration=8-3=5), Button 9 (duration=20-8=12). Button 9 has the longest press duration of 12.

Example 3 — Tie Breaking

$ Input: events = [[2,3],[1,7]]

› Output: 1

💡 Note: Button durations: Button 2 (duration=3), Button 1 (duration=7-3=4). Button 1 has longer duration of 4, so return 1.

Constraints

1 ≤ events.length ≤ 1000
events[i] = [index_i, time_i]
1 ≤ index_i, time_i ≤ 10⁵
events is sorted in increasing order of time_i

Visualization

Tap to expand

Asked in

f Meta 15 a Amazon 12 G Google 8

The key insight is that we need to calculate press durations correctly: first button's duration is its timestamp, others are time differences between consecutive events. The optimal approach uses a single pass to track the longest duration while handling ties by preferring smaller indices. Time: O(n), Space: O(1).

Common Approaches

✓ Optimized Single Pass with Early Comparison

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

This approach uses the same single pass strategy but optimizes the comparison logic by handling tie-breaking more efficiently, ensuring we always prefer the smallest index when durations are equal.

Single Pass Tracking

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

We iterate through the events array once, calculating the press duration for each button (first button uses its timestamp, others use time difference), and keep track of which button had the longest press time.

Optimized Single Pass with Early Comparison — Algorithm Steps

Step 1: Track maximum duration and corresponding button index
Step 2: For each button, calculate duration and compare with current maximum
Step 3: Update result only when finding strictly longer duration or equal duration with smaller index

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Initialize with first button as baseline

Compare

For each button, calculate duration and compare efficiently

Decide

Update only when finding longer duration or equal duration with smaller index

Code -

solution.c — C

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

int solution(int events[][2], int n) {
    int maxDuration = events[0][1];  // First button duration
    int resultButton = events[0][0];
    
    for (int i = 1; i < n; i++) {
        int buttonIdx = events[i][0];
        int duration = events[i][1] - events[i-1][1];
        
        // Update if strictly longer duration, or same duration with smaller index
        if (duration > maxDuration || (duration == maxDuration && buttonIdx < resultButton)) {
            maxDuration = duration;
            resultButton = buttonIdx;
        }
    }
    
    return resultButton;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int events[1000][2];
    int n = 0;
    
    char *ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    ptr++;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            events[n][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++;
            events[n][1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            ptr++;
            n++;
        } else {
            ptr++;
        }
    }
    
    int result = solution(events, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n events

✓ Linear Growth

Space Complexity

O(1)

Only constant extra variables for tracking

✓ Linear Space

8.5K Views

Medium Frequency

~12 min Avg. Time

245 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

Optimized Single Pass with Early Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler