Button with Longest Push Time - Practice Coding Problems

Button with Longest Push Time - Problem

Array Easy

Button with Longest Push Time

Imagine a child playing with a digital keyboard, pressing buttons in sequence. You need to determine which button took the longest time to press based on the timing of consecutive button presses.

You are given a 2D array events where each events[i] = [index_i, time_i] represents:
• index_i: The button that was pressed
• time_i: The exact time when it was pressed

The array is sorted by time in ascending order. Your task is to calculate the push duration for each button:
• For the first button: push time = time when pressed
• For subsequent buttons: push time = current time - previous time

Goal: Return the index of the button with the longest push time. If multiple buttons have the same longest time, return the button with the smallest index.

Example: If events = [[1,2],[2,5],[3,9]], then:
• Button 1: push time = 2
• Button 2: push time = 5-2 = 3
• Button 3: push time = 9-5 = 4
Button 3 has the longest push time, so return 3.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: Button 1: duration = 2 (first button), Button 2: duration = 5-2 = 3, Button 3: duration = 9-5 = 4. Button 3 has the longest duration of 4.

example_2.py — Tie Breaker

$ Input: events = [[3,4],[5,6],[2,8]]

› Output: 2

💡 Note: Button 3: duration = 4, Button 5: duration = 6-4 = 2, Button 2: duration = 8-6 = 2. Buttons 3, 5, and 2 all have different durations, with button 3 having the maximum duration of 4.

example_3.py — Single Button

$ Input: events = [[5,10]]

› Output: 5

💡 Note: Only one button pressed at time 10. Its duration is 10, so return button 5.

Constraints

1 ≤ events.length ≤ 1000
events[i] = [index_i, time_i]
1 ≤ index_i, time_i ≤ 10⁵
time_i < time_i+1 for all valid i
All button indices in events are unique

Visualization

Tap to expand

Understanding the Visualization

First Button

Duration = timestamp (no previous button to compare with)

Subsequent Buttons

Duration = current_time - previous_time

Track Maximum

Keep track of button with longest duration, preferring smaller index for ties

Key Takeaway

🎯 Key Insight: We can solve this efficiently in a single pass by calculating durations on-the-fly and maintaining the maximum, eliminating the need for extra storage space.

Asked in

G Google 25 a Amazon 20 f Meta 15 ⊞ Microsoft 12

This problem is efficiently solved with a single-pass approach in O(n) time and O(1) space. The key insight is to calculate push durations on-the-fly while tracking the maximum duration. For the first button, the duration equals its timestamp. For subsequent buttons, the duration is the difference between consecutive timestamps. When durations are equal, we choose the button with the smaller index.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Optimal Solution	O(n)	O(1)	Calculate durations and track maximum in single pass
Brute Force (Calculate All Durations)	O(n)	O(n)	Calculate all push durations first, then find the maximum

One-Pass Optimal Solution — Algorithm Steps

Initialize tracking variables for maximum duration and result index
Handle first button: duration equals its timestamp
For each subsequent button: calculate duration as current_time - previous_time
Update maximum if current duration is larger, or if equal but index is smaller
Return the index with maximum duration

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set first button as current maximum

Process Each Button

Calculate duration and update maximum if necessary

Handle Ties

Choose smaller index when durations are equal

Code -

solution.c — C

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

int buttonWithLongestTime(int** events, int eventsSize) {
    if (eventsSize == 0) return 0;
    
    int maxDuration = events[0][1];  // First button duration
    int resultIndex = events[0][0];  // First button index
    
    // Process remaining buttons
    for (int i = 1; i < eventsSize; i++) {
        int duration = events[i][1] - events[i-1][1];
        int buttonIndex = events[i][0];
        
        // Update if current duration is larger,
        // or same duration but smaller index
        if (duration > maxDuration || 
            (duration == maxDuration && buttonIndex < resultIndex)) {
            maxDuration = duration;
            resultIndex = buttonIndex;
        }
    }
    
    return resultIndex;
}

int main() {
    int n;
    scanf("%d", &n);
    int** events = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        events[i] = (int*)malloc(2 * sizeof(int));
        scanf("%d %d", &events[i][0], &events[i][1]);
    }
    printf("%d\n", buttonWithLongestTime(events, n));
    for (int i = 0; i < n; i++) {
        free(events[i]);
    }
    free(events);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all events to calculate durations and find maximum

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for tracking variables

✓ Linear Space

28.6K Views

Medium Frequency

~8 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

One-Pass Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler