Better Compression of String

Better Compression of String - Problem

You are given a string compressed representing a compressed version of a string. The format is a character followed by its frequency.

For example, "a3b1a1c2" is a compressed version of the string "aaabacc".

We seek a better compression with the following conditions:

Each character should appear only once in the compressed version
The characters should be in alphabetical order

Return the better compression of compressed.

Note: In the better version of compression, the order of letters may change, which is acceptable.

Input & Output

Example 1 — Basic Case

$ Input: compressed = "a3b1a1c2"

› Output: "a4b1c2"

💡 Note: Character 'a' appears with frequencies 3 and 1, total = 4. Character 'b' appears once with frequency 1. Character 'c' appears once with frequency 2. Result is sorted alphabetically: a4b1c2

Example 2 — Single Character

$ Input: compressed = "c1"

› Output: "c1"

💡 Note: Only one character 'c' with frequency 1, so result remains c1

Example 3 — Multiple Duplicates

$ Input: compressed = "a1b1b1a2"

› Output: "a3b2"

💡 Note: Character 'a' appears with frequencies 1 and 2, total = 3. Character 'b' appears with frequencies 1 and 1, total = 2. Sorted result: a3b2

Constraints

1 ≤ compressed.length ≤ 1000
compressed consists of lowercase English letters and digits
Each character in compressed is followed by its frequency
1 ≤ frequency ≤ 999

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 10 🍎 Apple 8

The key insight is to parse character-frequency pairs and use a hash map to accumulate total frequencies for each character, then sort alphabetically. Best approach is Hash Map Frequency Counting with Time: O(n + k log k), Space: O(k) where k ≤ 26.

Common Approaches

✓ Brute Force String Parsing

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

Iterate through the compressed string manually parsing each character-frequency pair. Use nested loops to find and accumulate frequencies for each character, then sort the results alphabetically.

Hash Map Frequency Counting

⏱️ Time: O(n + k log k) Space: O(k)

Parse the compressed string to extract character-frequency pairs and use a hash map to accumulate the total frequency for each character. Then sort the keys alphabetically and build the result string.

Brute Force String Parsing — Algorithm Steps

Step 1: Manually parse string to extract character-frequency pairs
Step 2: For each character, search through all pairs to sum frequencies
Step 3: Sort characters alphabetically and build result string

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Pairs

Extract character-frequency pairs manually

Accumulate

Sum frequencies for duplicate characters

Sort & Build

Sort alphabetically and create result

Code -

solution.c — C

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

char* solution(char* compressed) {
    char chars[26];
    int freqs[26];
    int count = 0;
    
    // Parse character-frequency pairs manually
    int i = 0;
    int len = strlen(compressed);
    while (i < len) {
        char ch = compressed[i];
        i++;
        char freqStr[10] = {0};
        int freqIdx = 0;
        while (i < len && isdigit(compressed[i])) {
            freqStr[freqIdx++] = compressed[i];
            i++;
        }
        
        int freq = atoi(freqStr);
        
        // Find if character already exists
        int found = 0;
        for (int j = 0; j < count; j++) {
            if (chars[j] == ch) {
                freqs[j] += freq;
                found = 1;
                break;
            }
        }
        
        if (!found) {
            chars[count] = ch;
            freqs[count] = freq;
            count++;
        }
    }
    
    // Sort by character
    for (int i1 = 0; i1 < count; i1++) {
        for (int j = i1 + 1; j < count; j++) {
            if (chars[i1] > chars[j]) {
                char tempChar = chars[i1];
                chars[i1] = chars[j];
                chars[j] = tempChar;
                int tempFreq = freqs[i1];
                freqs[i1] = freqs[j];
                freqs[j] = tempFreq;
            }
        }
    }
    
    // Build result
    char* result = malloc(1000);
    result[0] = '\0';
    for (int i1 = 0; i1 < count; i1++) {
        char temp[10];
        sprintf(temp, "%c%d", chars[i1], freqs[i1]);
        strcat(result, temp);
    }
    
    return result;
}

int main() {
    char compressed[1000];
    fgets(compressed, sizeof(compressed), stdin);
    compressed[strcspn(compressed, "\n")] = 0;
    
    char* result = solution(compressed);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops for parsing and frequency accumulation

⚠ Quadratic Growth

Space Complexity

O(k)

Storage for unique characters (k ≤ 26)

✓ Linear Space

25.6K Views

Medium Frequency

~15 min Avg. Time

890 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 String Parsing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler