String Compression

String Compression - Problem

Given an array of characters chars, compress it using the following algorithm:

Begin with an empty string s. For each group of consecutive repeating characters in chars:

If the group's length is 1, append the character to s.
Otherwise, append the character followed by the group's length.

The compressed string s should not be returned separately, but instead, be stored in the input character array chars.

Note: Group lengths that are 10 or longer will be split into multiple characters in chars.

After you are done modifying the input array, return the new length of the array.

You must write an algorithm that uses only constant extra space.

Input & Output

Example 1 — Basic Compression

$ Input: chars = ["a","a","b","b","c","c","c"]

› Output: 6

💡 Note: Groups: 'a' appears 2 times, 'b' appears 2 times, 'c' appears 3 times. Compressed: ['a','2','b','2','c','3']. Length is 6.

Example 2 — Single Characters

$ Input: chars = ["a"]

› Output: 1

💡 Note: Single character 'a' with count 1, so no count is appended. Result: ['a']. Length is 1.

Example 3 — Mixed Groups

$ Input: chars = ["a","b","b","b","b","b","b","b","b","b","b","b","b"]

› Output: 4

💡 Note: 'a' appears 1 time (no count), 'b' appears 12 times. Compressed: ['a','b','1','2']. Length is 4.

Constraints

1 ≤ chars.length ≤ 2000
chars[i] is a lowercase English letter, uppercase English letter, or digit

Visualization

Tap to expand

Asked in

M Microsoft 35 a Amazon 28 G Google 22 🍎 Apple 18

The key insight is that we can compress the array in-place using two pointers since the compressed form is never longer than the original. The optimal approach uses a read pointer to count consecutive characters and a write pointer to store the compressed result. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force with Extra Space

⏱️ Time: O(n) Space: O(n)

Create a separate result array, iterate through input counting consecutive characters, append character and count to result, then copy back to input array.

Two Pointers In-Place

⏱️ Time: O(n) Space: O(1)

Use two pointers - one to read through the original characters and count consecutive groups, another to write the compressed result directly into the same array. This saves space by modifying the array in-place.

Brute Force with Extra Space — Algorithm Steps

Create result array
Count consecutive characters
Append char + count to result
Copy result back to input

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Groups

Count consecutive characters: a(3), b(2), c(1)

Build Result

Create result array: ['a','3','b','2','c']

Copy Back

Copy result back to original array

Code -

solution.c — C

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

int solution(char* chars, int charsSize) {
    if (charsSize == 0) return 0;
    
    char* result = (char*)malloc(charsSize * 10 * sizeof(char));
    int resultSize = 0;
    int i = 0;
    
    while (i < charsSize) {
        char ch = chars[i];
        int count = 1;
        
        // Count consecutive characters
        while (i + 1 < charsSize && chars[i + 1] == ch) {
            count++;
            i++;
        }
        
        // Add character to result
        result[resultSize++] = ch;
        
        // Add count if > 1
        if (count > 1) {
            char countStr[20];
            sprintf(countStr, "%d", count);
            for (int j = 0; countStr[j]; j++) {
                result[resultSize++] = countStr[j];
            }
        }
        
        i++;
    }
    
    // Copy result back to chars
    for (int j = 0; j < resultSize; j++) {
        chars[j] = result[j];
    }
    
    free(result);
    return resultSize;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    char chars[2000];
    int charsSize = 0;
    int inQuote = 0;
    
    for (int i = 0; line[i]; i++) {
        if (line[i] == '"') {
            inQuote = !inQuote;
        } else if (inQuote && (line[i] >= 'a' && line[i] <= 'z' || line[i] >= 'A' && line[i] <= 'Z' || line[i] >= '0' && line[i] <= '9')) {
            chars[charsSize++] = line[i];
        }
    }
    
    int result = solution(chars, charsSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array to count and compress

✓ Linear Growth

Space Complexity

O(n)

Extra array to store compressed result before copying back

✓ Linear Space

68.0K Views

Medium Frequency

~15 min Avg. Time

1.8K 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 with Extra Space — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler