String Compression III

String Compression III - Problem

String Medium

Given a string word, compress it using the following algorithm:

Begin with an empty string comp.

While word is not empty:

Remove a maximum length prefix of word made of a single character c repeating at most 9 times.
Append the length of the prefix followed by c to comp.

Return the string comp.

Input & Output

Example 1 — Basic Consecutive Characters

$ Input: word = "abcde"

› Output: "1a1b1c1d1e"

💡 Note: Each character appears exactly once, so each gets compressed to '1' + character

Example 2 — Repeated Characters with Limit

$ Input: word = "aaaaaaaaaaaaaabb"

› Output: "9a5a2b"

💡 Note: 14 'a's become '9a' + '5a' (due to 9-character limit), 2 'b's become '2b'

Example 3 — Mixed Repetitions

$ Input: word = "aabcccccccccaaa"

› Output: "2a1b9c1c3a"

💡 Note: 2 'a's → '2a', 1 'b' → '1b', 10 'c's → '9c1c', 3 'a's → '3a'

Constraints

1 ≤ word.length ≤ 2 × 10⁵
word consists of only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 30 M Microsoft 20 f Facebook 15

The key insight is to process consecutive identical characters in groups of maximum 9. The optimal approach uses a single pass with character tracking and counting. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Single Pass	O(n)	O(1)	Process characters in a single pass with efficient counting
Brute Force - Character by Character	O(n)	O(1)	Process each character individually and count consecutive occurrences

Optimized Single Pass — Algorithm Steps

Initialize result string and character counter
For each character, check if it matches the previous
If same and count < 9, increment counter
If different or count = 9, append to result and reset

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with first character and count = 1

Compare

Compare each next character with current

Output

When character changes or count hits 9, output and reset

Code -

solution.c — C

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

char* solution(char* word) {
    if (!word || strlen(word) == 0) {
        char* result = malloc(1);
        result[0] = '\0';
        return result;
    }
    
    int len = strlen(word);
    char* comp = malloc(len * 2 + 1);
    int compIndex = 0;
    
    char currentChar = word[0];
    int count = 1;
    
    for (int i = 1; i < len; i++) {
        if (word[i] == currentChar && count < 9) {
            count++;
        } else {
            comp[compIndex++] = '0' + count;
            comp[compIndex++] = currentChar;
            currentChar = word[i];
            count = 1;
        }
    }
    
    // Don't forget the last group
    comp[compIndex++] = '0' + count;
    comp[compIndex++] = currentChar;
    comp[compIndex] = '\0';
    
    return comp;
}

int main() {
    char word[100001];
    fgets(word, sizeof(word), stdin);
    
    // Remove newline
    int len = strlen(word);
    if (len > 0 && word[len-1] == '\n') {
        word[len-1] = '\0';
    }
    
    char* result = solution(word);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string of length n

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters and current character

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

485 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

Optimized Single Pass — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler