String Compression III - Practice Coding Problems

String Compression III - Problem

String Medium

Given a string word, your task is to compress it using a specific run-length encoding algorithm with a twist - each run can contain at most 9 characters.

The compression algorithm works as follows:

Start with an empty result string comp
While the input string is not empty:
- Find the longest prefix of consecutive identical characters (maximum 9)
- Append the count followed by the character to comp
- Remove this prefix from the input string

Example: If you have "aaabcccccccccc", you would get:

"aaa" → "3a"
"b" → "1b"
"ccccccccc" → "9c" (first 9 c's)
"c" → "1c" (remaining c)

Result: "3a1b9c1c"

Return the compressed string comp.

Input & Output

example_1.py — Basic Compression

$ Input: word = "aaabcccccccccc"

› Output: "3a1b9c1c"

💡 Note: We have 3 consecutive 'a's, 1 'b', and 10 consecutive 'c's. Since we can only encode up to 9 characters at a time, the 10 'c's become '9c' + '1c'.

example_2.py — No Compression Needed

$ Input: word = "abcdef"

› Output: "1a1b1c1d1e1f"

💡 Note: Each character appears only once, so each gets encoded as '1' followed by the character.

example_3.py — Maximum Run Length

$ Input: word = "aaaaaaaaaaaa"

› Output: "9a3a"

💡 Note: We have 12 consecutive 'a's. The first 9 become '9a', and the remaining 3 become '3a'.

Constraints

1 ≤ word.length ≤ 2 × 10⁵
word consists of only lowercase English letters
Each compressed segment contains at most 9 consecutive identical characters

Visualization

Tap to expand

Understanding the Visualization

Scan Characters

Move through string tracking current character and count

Count Matches

Increment count for identical consecutive characters

Handle Boundaries

When character changes or count reaches 9, output the group

Reset and Continue

Start new group with the different character

Key Takeaway

🎯 Key Insight: Track consecutive characters and their counts, outputting compressed groups when limits are reached or characters change

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a single-pass linear scan approach with O(n) time complexity. We maintain a current character and count, appending to the result whenever we encounter a different character or reach the maximum count of 9. This run-length encoding with chunk limits efficiently compresses the string in one traversal.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Character by Character)	O(n²)	O(n)	Check each character individually and rebuild the string multiple times
One-Pass Linear Scan (Optimal)	O(n)	O(1)	Single pass through string with character counting and direct result building

Brute Force (Character by Character) — Algorithm Steps

Start from the beginning of the string
For current character, scan ahead to count consecutive occurrences
Take minimum of count and 9
Append count + character to result
Create new string by removing processed characters
Repeat until string is empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original string "aaabcc"

Process 'aaa'

Count 3 consecutive 'a's, append "3a", remaining: "bcc"

Process 'b'

Count 1 'b', append "1b", remaining: "cc"

Process 'cc'

Count 2 consecutive 'c's, append "2c", remaining: ""

Code -

solution.c — C

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

char* compressString(char* word) {
    int len = strlen(word);
    char* comp = malloc(2 * len + 1);
    int compIndex = 0;
    int wordIndex = 0;
    
    while (wordIndex < len) {
        char currentChar = word[wordIndex];
        int count = 0;
        // Count consecutive characters (max 9)
        while (wordIndex < len && word[wordIndex] == currentChar && count < 9) {
            count++;
            wordIndex++;
        }
        // Append count and character
        comp[compIndex++] = '0' + count;
        comp[compIndex++] = currentChar;
    }
    comp[compIndex] = '\0';
    return comp;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each character, we potentially scan ahead and create substrings, leading to quadratic time

⚠ Quadratic Growth

Space Complexity

O(n)

Multiple substring creations during processing

⚡ Linearithmic Space

28.6K 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 (Character by Character) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler