Better Compression of String - Practice Coding Problems

Better Compression of String - Problem

Better String Compression Challenge

You're given a compressed string where each character is followed by its frequency count. Your task is to create an optimized compression that follows these rules:

🎯 Optimization Rules:
• Each character appears only once in the result
• Characters are arranged in alphabetical order
• Combine frequencies for duplicate characters

Example: "a3b1a1c2" represents the string "aaabacc"
The better compression would be "a4b1c2" (combining both 'a' occurrences: 3+1=4)

Note: The order of characters may change in the optimized version, which is perfectly acceptable.

Input & Output

example_1.py — Basic Compression

$ Input: "a3b1a1c2"

› Output: "a4b1c2"

💡 Note: The character 'a' appears twice with frequencies 3 and 1, so we combine them to get 4. Characters are sorted alphabetically: a(4), b(1), c(2).

example_2.py — Multiple Duplicates

$ Input: "z1a3b2z2a1"

› Output: "a4b2z3"

💡 Note: Character 'a' appears with frequencies 3+1=4, 'z' appears with frequencies 1+2=3. Final sorted order: a(4), b(2), z(3).

example_3.py — Single Characters

$ Input: "x1y1z1"

› Output: "x1y1z1"

💡 Note: No duplicate characters to combine, already in alphabetical order, so result remains the same.

Visualization

Tap to expand

Understanding the Visualization

Initialize Hash Table

Create empty frequency counter for each character

Parse & Update

For each character-frequency pair, update hash table in O(1) time

Combine Duplicates

Hash table automatically handles duplicate characters by updating counts

Sort & Output

Extract all characters, sort alphabetically, and build final compressed string

Key Takeaway

🎯 Key Insight: Hash tables transform an O(n²) character search problem into an O(n) frequency counting solution by providing instant lookups and updates, making the overall algorithm optimal for string compression tasks.

Time & Space Complexity

Time Complexity

⏱️

O(n + k log k)

O(n) to parse string + O(k log k) to sort k unique characters

⚡ Linearithmic

Space Complexity

O(k)

Hash map stores at most k unique characters

✓ Linear Space

Constraints

1 ≤ compressed.length ≤ 1000
compressed consists of lowercase English letters and digits
Each character is followed by its frequency (1 ≤ frequency ≤ 10⁴)
The compressed string is guaranteed to be valid

Asked in

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

The optimal solution uses a hash table to track character frequencies in a single pass through the input string. This approach achieves O(n + k log k) time complexity where n is the input length and k is the number of unique characters. The key insight is that hash tables provide O(1) lookup and update operations, eliminating the need for repeated linear searches through the result.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n + k log k)	O(k)	Use hash map to track character frequencies in single pass
Brute Force (Character-by-Character Search)	O(n²)	O(k)	Parse characters one by one, searching through result for duplicates

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize an empty hash map for character frequencies
Parse the compressed string character by character
For each character-frequency pair, update the hash map
Extract all characters and sort them alphabetically
Build result string with sorted characters and their frequencies

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse & Hash

Read each character-frequency pair and update hash map

Accumulate

Hash map automatically combines duplicate characters

Sort & Build

Extract sorted keys and build final result

Code -

solution.c — C

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

typedef struct {
    char ch;
    int freq;
} CharFreq;

int compare(const void* a, const void* b) {
    return ((CharFreq*)a)->ch - ((CharFreq*)b)->ch;
}

char* betterCompression(char* compressed) {
    int charCount[26] = {0}; // Assuming lowercase letters only
    int i = 0;
    int len = strlen(compressed);
    
    // Single pass to count frequencies
    while (i < len) {
        char ch = compressed[i];
        i++;
        
        // Extract the frequency number
        int freq = 0;
        while (i < len && isdigit(compressed[i])) {
            freq = freq * 10 + (compressed[i] - '0');
            i++;
        }
        
        // Update frequency
        charCount[ch - 'a'] += freq;
    }
    
    // Build result
    char* result = malloc(1000);
    result[0] = '\0';
    
    for (int i = 0; i < 26; i++) {
        if (charCount[i] > 0) {
            char temp[20];
            sprintf(temp, "%c%d", 'a' + i, charCount[i]);
            strcat(result, temp);
        }
    }
    
    return result;
}

int main() {
    char compressed[1000];
    scanf("%s", compressed);
    printf("%s\n", betterCompression(compressed));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + k log k)

O(n) to parse string + O(k log k) to sort k unique characters

⚡ Linearithmic

Space Complexity

O(k)

Hash map stores at most k unique characters

✓ Linear Space

Constraints

1 ≤ compressed.length ≤ 1000
compressed consists of lowercase English letters and digits
Each character is followed by its frequency (1 ≤ frequency ≤ 10⁴)
The compressed string is guaranteed to be valid

42.3K Views

Medium-High 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler