Expressive Words

Expressive Words - Problem

Sometimes people repeat letters to represent extra feeling. For example:

"hello" → "heeellooo"
"hi" → "hiiii"

In strings like "heeellooo", we have groups of adjacent letters that are all the same: "h", "eee", "ll", "ooo".

You are given a string s and an array of query strings words. A query word is stretchy if it can be made equal to s by extending character groups to have 3 or more characters.

For example, starting with "hello", we could extend the group "o" to get "hellooo", but we cannot get "helloo" since the group "oo" has size less than 3. We could also extend "ll" → "lllll" to get "helllllooo".

Return the number of query strings that are stretchy.

Input & Output

Example 1 — Basic Stretching

$ Input: s = "heeellooo", words = ["hello", "hi", "helo"]

› Output: 1

💡 Note: "hello" can be stretched: h(1→1), e(1→3), l(2→2), o(1→3). "hi" fails because 'h' matches but 'i' doesn't match 'e'. "helo" fails because it's missing one 'l'.

Example 2 — No Valid Stretches

$ Input: s = "zzzzzyyyyy", words = ["zzyy", "zy", "zyy"]

› Output: 3

💡 Note: "zzyy": z(2→5)✓, y(2→5)✓. "zy": z(1→5)✓, y(1→5)✓. "zyy": z(1→5)✓, y(2→5)✓. All can be stretched to match the target.

Example 3 — Edge Case Single Character

$ Input: s = "aaa", words = ["a", "aa", "aaa"]

› Output: 2

💡 Note: "a" can be stretched to "aaa" (1→3). "aa" cannot be stretched because 2→3 requires at least 3 in target for extension. "aaa" matches exactly.

Constraints

1 ≤ s.length, words[i].length ≤ 50
1 ≤ words.length ≤ 50
s and words[i] consist of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 42 f Facebook 28

The key insight is to compare character groups rather than individual characters. Use two pointers to process consecutive character groups, checking if each group in the query word can be stretched to match the target string (groups can only be extended to 3+ characters). Best approach is two-pointers with group comparison. Time: O(n × (m + k)), Space: O(1).

Common Approaches

✓ Brute Force Character Comparison

⏱️ Time: O(n × m × k) Space: O(1)

For each word, iterate through characters and handle stretching cases with nested loops and multiple conditions.

Two Pointers Group Comparison

⏱️ Time: O(n × (m + k)) Space: O(1)

Use two pointers to traverse both strings, counting consecutive characters in groups and validating stretching rules.

Brute Force Character Comparison — Algorithm Steps

For each word, compare character by character with s
Handle stretching cases with nested loops
Count valid stretchy words

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Characters

Check if current characters match

Count Groups

Count consecutive same characters in both strings

Validate Stretching

Check if stretching rules are satisfied

Code -

solution.c — C

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

bool isStretchy(const char* s, const char* word) {
    int i = 0, j = 0;
    int sLen = strlen(s), wordLen = strlen(word);
    
    while (i < sLen && j < wordLen) {
        if (s[i] != word[j]) {
            return false;
        }
        
        char c = s[i];
        int countS = 0;
        while (i < sLen && s[i] == c) {
            countS++;
            i++;
        }
        
        int countWord = 0;
        while (j < wordLen && word[j] == c) {
            countWord++;
            j++;
        }
        
        if (countS < countWord) {
            return false;
        }
        if (countS > countWord && countS < 3) {
            return false;
        }
    }
    
    return i == sLen && j == wordLen;
}

int solution(const char* s, char words[][100], int wordCount) {
    int count = 0;
    for (int i = 0; i < wordCount; i++) {
        if (isStretchy(s, words[i])) {
            count++;
        }
    }
    return count;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char wordsLine[10000];
    fgets(wordsLine, sizeof(wordsLine), stdin);
    wordsLine[strcspn(wordsLine, "\n")] = 0;
    
    // Simple JSON parsing for array of strings
    char words[100][100];
    int wordCount = 0;
    
    char* token = strtok(wordsLine + 1, ",]");
    while (token != NULL && wordCount < 100) {
        // Remove quotes and spaces
        while (*token == ' ' || *token == '"') token++;
        int len = strlen(token);
        while (len > 0 && (token[len-1] == ' ' || token[len-1] == '"')) {
            token[len-1] = '\0';
            len--;
        }
        strcpy(words[wordCount], token);
        wordCount++;
        token = strtok(NULL, ",]");
    }
    
    int result = solution(s, words, wordCount);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × k)

n words, each with m characters, up to k stretching checks per character

✓ Linear Growth

Space Complexity

O(1)

Only using variables for counting and indexing

✓ Linear Space

28.5K Views

Medium Frequency

~25 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 Character Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler