Expressive Words - Practice Coding Problems

Expressive Words - Problem

Have you ever noticed how people stretch out letters when they're really excited? Like when someone types "hellooooo!" instead of just "hello", or "hiiiiii" instead of "hi"? That's exactly what this problem is about!

You're given a stretched string s and an array of normal words. Your task is to find how many of these normal words could have been stretched to create the string s.

The stretching rules are:

You can take any group of consecutive identical letters in a word
You can extend that group by adding more of the same letter
But here's the catch: the final group must have at least 3 letters

Example: Starting with "hello", you could stretch the "o" to get "hellooo" (3 o's), or stretch the "ll" to get "hellllo" (4 l's), but you cannot get "helloo" because "oo" has only 2 letters.

Goal: Return the count of words that can be stretched to match the given string s.

Input & Output

example_1.py — Basic Stretching

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

› Output: 1

💡 Note: Only "hello" can be stretched to "heeellooo". We can stretch 'e' (1→3), keep 'll' (2→2), and stretch 'o' (1→3). "hi" has different characters, and "helo" has only one 'l' which can't become "ll".

example_2.py — No Valid Stretches

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

› Output: 0

💡 Note: Neither word can be stretched. "zy" would need z (1→5) and y (1→5), but single characters can't be stretched to 5. "zyy" would need z (1→5) which is impossible since 1 < 3.

example_3.py — Multiple Valid Stretches

$ Input: s = "abccc", words = ["abc", "abcc", "abccc"]

› Output: 2

💡 Note: "abcc" (2→3 c's, valid stretch) and "abccc" (already matches) are valid. "abc" can't work because 1 c can't become 3 c's (needs at least 3 to stretch).

Constraints

1 ≤ s.length, words[i].length ≤ 50
1 ≤ words.length ≤ 100
s and words[i] consist of lowercase English letters only
A group of characters can only be stretched if the result has at least 3 characters
Groups with less than 3 characters must remain unchanged

Visualization

Tap to expand

Understanding the Visualization

Group Formation

Identify consecutive identical characters in both strings

Stretching Rules

Check if word groups can be stretched to match target groups

Validation

Ensure all groups match and both strings are fully processed

Count Results

Count how many words can be successfully stretched

Key Takeaway

🎯 Key Insight: Group consecutive identical characters and validate stretching rules - target groups must be at least as large as word groups, and groups smaller than 3 characters cannot be stretched.

Asked in

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

The optimal solution uses two pointers to compare character groups between the target string and each word. The key insight is that we can group consecutive identical characters and validate stretching rules: the target group must have at least as many characters as the word group, and if the word group has fewer than 3 characters, both groups must have exactly the same count.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Character Comparison	O(n * m * k)	O(1)	Compare each word with the target string character by character using nested loops
Two Pointers (Optimal)	O(n * (m + k))	O(1)	Use two pointers to compare groups of characters efficiently

Brute Force Character Comparison — Algorithm Steps

For each word in the array, initialize two pointers for the word and target string
Compare characters at current positions - if different, word cannot be stretched
If same character, count consecutive occurrences in both strings
Check if the group in word can be stretched to match target group (target count >= word count, and if word count < 3, target count must equal word count)
Continue until both strings are fully processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Start with two pointers, one for the word and one for the target string

Compare Characters

Check if current characters match

Count Groups

Count consecutive identical characters in both strings

Validate Stretching

Check if the group can be validly stretched

Code -

solution.c — C

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

bool canStretch(char* word, char* target) {
    int i = 0, j = 0;
    int wordLen = strlen(word);
    int targetLen = strlen(target);
    
    while (i < wordLen && j < targetLen) {
        if (word[i] != target[j]) {
            return false;
        }
        
        char ch = word[i];
        int wordCount = 0;
        while (i < wordLen && word[i] == ch) {
            wordCount++;
            i++;
        }
        
        int targetCount = 0;
        while (j < targetLen && target[j] == ch) {
            targetCount++;
            j++;
        }
        
        if (targetCount < wordCount) {
            return false;
        }
        if (wordCount < 3 && targetCount != wordCount) {
            return false;
        }
    }
    
    return i == wordLen && j == targetLen;
}

int expressiveWords(char* s, char** words, int wordsSize) {
    int count = 0;
    for (int i = 0; i < wordsSize; i++) {
        if (canStretch(words[i], s)) {
            count++;
        }
    }
    return count;
}

int main() {
    // Implementation for input parsing
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m * k)

n words, each with average length m, compared against target string of length k

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers and counters

✓ Linear Space

23.5K Views

Medium-High Frequency

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