Slowest Key

Slowest Key - Problem

Array String Easy

A newly designed keypad was tested, where a tester pressed a sequence of n keys, one at a time.

You are given a string keysPressed of length n, where keysPressed[i] was the ith key pressed in the testing sequence, and a sorted list releaseTimes, where releaseTimes[i] was the time the ith key was released. Both arrays are 0-indexed. The 0th key was pressed at the time 0, and every subsequent key was pressed at the exact time the previous key was released.

The tester wants to know the key of the keypress that had the longest duration. The ith keypress had a duration of releaseTimes[i] - releaseTimes[i - 1], and the 0th keypress had a duration of releaseTimes[0].

Note that the same key could have been pressed multiple times during the test, and these multiple presses of the same key may not have had the same duration.

Return the key of the keypress that had the longest duration. If there are multiple such keypresses, return the lexicographically largest key of the keypresses.

Input & Output

Example 1 — Basic Case

$ Input: releaseTimes = [9,12,16,20], keysPressed = "abcd"

› Output: d

💡 Note: Durations: a=9, b=12-9=3, c=16-12=4, d=20-16=4. Maximum duration is 4. Both 'c' and 'd' have duration 4, and 'd' > 'c' lexicographically, so we return 'd'.

Example 2 — Lexicographical Tie

$ Input: releaseTimes = [12,23,36,46,62], keysPressed = "spuda"

› Output: a

💡 Note: Durations: s=12, p=11, u=13, d=10, a=16. Maximum duration is 16 for key 'a'.

Example 3 — First Key Longest

$ Input: releaseTimes = [10,15,18], keysPressed = "xyz"

› Output: x

💡 Note: Durations: x=10, y=15-10=5, z=18-15=3. Maximum duration is 10 for key 'x'.

Constraints

1 ≤ releaseTimes.length ≤ 1000
0 < releaseTimes[i] ≤ 10⁹
releaseTimes[i-1] < releaseTimes[i] for all valid i
keysPressed.length == releaseTimes.length
keysPressed contains only lowercase English letters

Visualization

Tap to expand

Asked in

a Amazon 15 Apple 8

The key insight is to calculate key press durations by subtracting consecutive release times, then find the key with maximum duration. For ties, choose the lexicographically largest key. The optimal approach processes in a single pass with O(n) time and O(1) space.

Common Approaches

✓ Brute Force - Calculate All Durations

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

First calculate the duration for each keypress by subtracting release times. Then iterate through all durations to find the maximum, keeping track of the lexicographically largest key in case of ties.

Single Pass Optimal

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

Instead of storing all durations, we calculate each duration on-the-fly and immediately check if it's the new maximum. Keep track of the longest duration and the lexicographically largest key that achieves it.

Brute Force - Calculate All Durations — Algorithm Steps

Step 1: Calculate duration array where duration[i] = releaseTimes[i] - releaseTimes[i-1] (or releaseTimes[0] for first)
Step 2: Find maximum duration and corresponding key, preferring lexicographically larger keys for ties

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Durations

Compute duration for each keypress

Find Maximum

Identify longest duration

Handle Ties

Pick lexicographically largest key

Code -

solution.c — C

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

char solution(int* releaseTimes, int releaseTimesSize, char* keysPressed) {
    int* durations = (int*)malloc(releaseTimesSize * sizeof(int));
    
    // Calculate all durations
    for (int i = 0; i < releaseTimesSize; i++) {
        if (i == 0) {
            durations[i] = releaseTimes[0];
        } else {
            durations[i] = releaseTimes[i] - releaseTimes[i-1];
        }
    }
    
    // Find maximum duration and corresponding key
    int maxDuration = durations[0];
    for (int i = 1; i < releaseTimesSize; i++) {
        if (durations[i] > maxDuration) {
            maxDuration = durations[i];
        }
    }
    
    char result = 'a';
    for (int i = 0; i < releaseTimesSize; i++) {
        if (durations[i] == maxDuration) {
            if (keysPressed[i] > result) {
                result = keysPressed[i];
            }
        }
    }
    
    free(durations);
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int releaseTimes[100];
    int size = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] >= '0' && token[0] <= '9') {
            releaseTimes[size++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    char keysPressed[100];
    fgets(keysPressed, sizeof(keysPressed), stdin);
    keysPressed[strcspn(keysPressed, "\n")] = 0;
    
    char result = solution(releaseTimes, size, keysPressed);
    printf("%c\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes: O(n) to calculate durations + O(n) to find maximum

✓ Linear Growth

Space Complexity

O(n)

Extra array to store n duration values

✓ Linear Space

23.4K Views

Medium Frequency

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

Brute Force - Calculate All Durations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler