Slowest Key - Practice Coding Problems

Slowest Key - Problem

Array String Easy

Imagine you're testing a revolutionary new keyboard for a tech company! 🎹 A tester pressed a sequence of n keys, one at a time, and you need to find which key took the longest time to press.

You're given:

keysPressed - a string where each character represents a key that was pressed
releaseTimes - an array where releaseTimes[i] is when the i-th key was released

Key Rules:

The first key (index 0) was pressed at time 0
Each subsequent key was pressed exactly when the previous key was released
Duration of key i = releaseTimes[i] - releaseTimes[i-1] (or just releaseTimes[0] for the first key)

Goal: Return the character of the key that had the longest duration. If there's a tie, return the lexicographically largest character (e.g., 'z' > 'a').

Example: If keys "abc" were pressed with release times [2, 5, 8], then durations are: a=2, b=3, c=3. Since 'c' > 'b' lexicographically, return 'c'.

Input & Output

example_1.py — Basic Case

$ Input: releaseTimes = [2,5,8], keysPressed = "abc"

› Output: "c"

💡 Note: Key durations: a=2 (0→2), b=3 (2→5), c=3 (5→8). Both 'b' and 'c' have max duration 3, but 'c' > 'b' lexicographically.

example_2.py — Single Key

$ Input: releaseTimes = [5], keysPressed = "a"

› Output: "a"

💡 Note: Only one key 'a' with duration 5. It's automatically the answer.

example_3.py — Clear Winner

$ Input: releaseTimes = [1,3,10], keysPressed = "xyz"

› Output: "z"

💡 Note: Key durations: x=1, y=2 (3-1), z=7 (10-3). 'z' has the longest duration of 7.

Constraints

1 ≤ keysPressed.length ≤ 10⁵
releaseTimes.length == keysPressed.length
1 ≤ releaseTimes[i] ≤ 10⁹
releaseTimes is sorted in non-decreasing order
keysPressed contains only lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Timeline Setup

Keys are pressed sequentially, each starting when the previous ends

Duration Calculation

Calculate how long each key was held down

Find Winner

Track the key with longest duration, breaking ties lexicographically

Key Takeaway

🎯 Key Insight: We can solve this efficiently in one pass by calculating durations on-the-fly and immediately comparing with our current best answer, using lexicographical comparison for tie-breaking.

Asked in

a Amazon 25 ⊞ Microsoft 18 G Google 12 Apple 8

The optimal solution uses a single-pass linear scan with O(1) space. As we iterate through the keys, we calculate each duration on-the-fly and maintain the current best answer, updating it whenever we find a longer duration or a lexicographically larger key with the same duration.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Linear Scan (Optimal)	O(n)	O(1)	Calculate durations on-the-fly and track the best answer in a single pass
Brute Force (Calculate All Durations)	O(n)	O(n)	Calculate all key durations first, then find the maximum

One-Pass Linear Scan (Optimal) — Algorithm Steps

Initialize maxDuration = 0 and result = first key
For each key, calculate its duration on-the-fly
If duration > maxDuration, or duration == maxDuration but key > result, update our answer
Return the result after one complete pass

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with first key as current best

Process Keys

Calculate each duration and compare with current best

Update Best

Update answer if we find better duration or lexicographically larger key

Code -

solution.c — C

#include <stdio.h>

char slowestKey(int* releaseTimes, int releaseTimesSize, char* keysPressed) {
    int maxDuration = releaseTimes[0];  // First key duration
    char result = keysPressed[0];       // First key character
    
    // Process remaining keys
    for (int i = 1; i < releaseTimesSize; i++) {
        int duration = releaseTimes[i] - releaseTimes[i-1];
        
        // Update if we found a longer duration,
        // or same duration but lexicographically larger key
        if (duration > maxDuration || 
            (duration == maxDuration && keysPressed[i] > result)) {
            maxDuration = duration;
            result = keysPressed[i];
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both input arrays

✓ Linear Growth

Space Complexity

O(1)

Only storing a few variables regardless of input size

✓ Linear Space

24.7K 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 Linear Scan (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler