Long Pressed Name - Practice Coding Problems

Long Pressed Name - Problem

Long Pressed Name - Your friend is typing his name on a keyboard, but sometimes keys get stuck! 🎹

When your friend types his name, occasionally a key might get long pressed, causing a character to be typed multiple times in a row. For example, if his name is "alex" but the 'l' key gets stuck, the typed result might be "allex" or even "alllex".

Your Task: Given the original name and the typed string, determine if it's possible that the typed string was created by long-pressing some (or none) of the keys while typing the original name.

Key Rules:
• Characters must appear in the same order as the original name
• Each character can be repeated 1 or more times (long pressed)
• No extra characters can be added that weren't in the original name

Example: name = "alex", typed = "aaleex" → True (both 'a' and 'e' were long pressed)

Input & Output

example_1.py — Python

$ Input: name = "alex", typed = "aaleex"

› Output: true

💡 Note: The 'a' key and 'e' key were long pressed, creating extra characters. The sequence matches with long presses: a(long) + l + e(long) + x

example_2.py — Python

$ Input: name = "saeed", typed = "ssaaedd"

› Output: false

💡 Note: The 'e' key was long pressed, but there's a missing 'e' character. We have 'eed' in name but only 'edd' pattern in typed after accounting for long presses

example_3.py — Python

$ Input: name = "leelee", typed = "lleeelee"

› Output: true

💡 Note: Multiple long presses occurred: the first 'l' and middle 'e' characters were long pressed, but the sequence order remains correct

Visualization

Tap to expand

Understanding the Visualization

Set the Stage

Place two conductors - one following the original score (name), one following the performance (typed)

Synchronize the Music

When both conductors point to matching notes, they move forward together in harmony

Handle Sticky Keys

When notes don't match but the performer plays the same note as before, it's a sticky key - only the performance conductor advances

Complete the Symphony

The piece is valid if we reach the end of the original score and any remaining performance notes are just sticky key repeats

Key Takeaway

🎯 Key Insight: By using two pointers that move at different paces, we can efficiently validate if a typed string matches the original with possible long-pressed characters, all in a single pass with O(n+m) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

For each character, we can choose to repeat it 1 to m times, leading to exponential combinations

⚠ Quadratic Growth

Space Complexity

O(2^n)

Need to store all possible generated strings in memory

⚠ Quadratic Space

Constraints

1 ≤ name.length ≤ 1000
1 ≤ typed.length ≤ 1000
name and typed consist of only lowercase English letters
The typed string length is at least equal to name length

Asked in

G Google 45 a Amazon 32 ⊞ Microsoft 28 f Meta 22

The optimal solution uses two pointers to traverse both strings simultaneously in O(n+m) time. When characters match, advance both pointers. When they don't match, check if it's a long press (typed character equals the previous typed character) and advance only the typed pointer. This elegant approach handles all edge cases while maintaining optimal complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Possibilities)	O(2^n)	O(2^n)	Generate all possible long-pressed versions of the name and check if typed matches any
Two Pointers (Optimal)	O(n + m)	O(1)	Use two pointers to traverse both strings simultaneously, handling long-pressed characters

Brute Force (Generate All Possibilities) — Algorithm Steps

For each character in the original name, try all possible repetition counts
Recursively generate all possible long-pressed combinations
Check if any generated string matches the typed string
Return true if a match is found, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first character

Try repeating 'a' 1, 2, 3... times

Recursively process next

For each 'a' repetition, try 'l' repetitions

Continue for all characters

Generate complete combinations

Check if typed matches any

Compare typed string with all possibilities

Code -

solution.c — C

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

#define MAX_LEN 1000
#define MAX_POSSIBILITIES 10000

char possibilities[MAX_POSSIBILITIES][MAX_LEN];
int possibilityCount = 0;

void generateAllPossibilities(const char* name, int index, char* current, int maxLen) {
    if (index == strlen(name)) {
        strcpy(possibilities[possibilityCount++], current);
        return;
    }
    
    char ch = name[index];
    for (int repeatCount = 1; repeatCount <= maxLen && possibilityCount < MAX_POSSIBILITIES; repeatCount++) {
        char newCurrent[MAX_LEN];
        strcpy(newCurrent, current);
        int len = strlen(newCurrent);
        
        for (int i = 0; i < repeatCount; i++) {
            newCurrent[len + i] = ch;
        }
        newCurrent[len + repeatCount] = '\0';
        
        if (strlen(newCurrent) <= maxLen) {
            generateAllPossibilities(name, index + 1, newCurrent, maxLen);
        }
    }
}

bool isLongPressedName(const char* name, const char* typed) {
    possibilityCount = 0;
    char empty[1] = "";
    generateAllPossibilities(name, 0, empty, strlen(typed));
    
    for (int i = 0; i < possibilityCount; i++) {
        if (strcmp(possibilities[i], typed) == 0) {
            return true;
        }
    }
    return false;
}

int main() {
    char name[MAX_LEN], typed[MAX_LEN];
    fgets(name, MAX_LEN, stdin);
    fgets(typed, MAX_LEN, stdin);
    
    // Remove quotes and newlines
    name[strcspn(name, "\"\n")] = '\0';
    if (name[0] == '"') memmove(name, name+1, strlen(name));
    typed[strcspn(typed, "\"\n")] = '\0';
    if (typed[0] == '"') memmove(typed, typed+1, strlen(typed));
    
    printf("%s\n", isLongPressedName(name, typed) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

For each character, we can choose to repeat it 1 to m times, leading to exponential combinations

⚠ Quadratic Growth

Space Complexity

O(2^n)

Need to store all possible generated strings in memory

⚠ Quadratic Space

Constraints

1 ≤ name.length ≤ 1000
1 ≤ typed.length ≤ 1000
name and typed consist of only lowercase English letters
The typed string length is at least equal to name length

78.4K Views

Medium Frequency

~15 min Avg. Time

1.9K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Possibilities) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler