Compression Algorithm - Problem

Implement a complete Huffman encoding algorithm for text compression and decompression. Your solution should build a Huffman tree from character frequencies, generate unique binary codes for each character, compress the input text, and then decompress it back to verify correctness.

The algorithm should:

Count character frequencies in the input text
Build a Huffman tree using a priority queue (min-heap)
Generate binary codes for each character
Compress the text using these codes
Decompress the compressed data back to original text
Calculate and return the compression ratio

Return a JSON object with: compressedBits (compressed binary string), decompressed (original text), compressionRatio (original bits / compressed bits), and codes (character to binary code mapping).

Input & Output

Example 1 — Basic Compression

$ Input: text = "AAAABBC"

› Output: {"compressedBits":"00001010111","decompressed":"AAAABBC","compressionRatio":5.09,"codes":{"A":"0","B":"10","C":"11"}}

💡 Note: A appears 4 times (most frequent) gets code '0', B appears 2 times gets '10', C appears 1 time gets '11'. Compression: A(0)+A(0)+A(0)+A(0)+B(10)+B(10)+C(11) = '00001010111'

Example 2 — Equal Frequencies

$ Input: text = "AABB"

› Output: {"compressedBits":"0011","decompressed":"AABB","compressionRatio":4.0,"codes":{"A":"0","B":"1"}}

💡 Note: A and B have equal frequency (2 each), so they get 1-bit codes. Result: A(0)+A(0)+B(1)+B(1) = '0011'

Example 3 — Single Character

$ Input: text = "AAAA"

› Output: {"compressedBits":"0000","decompressed":"AAAA","compressionRatio":8.0,"codes":{"A":"0"}}

💡 Note: Single character case: A gets code '0'. Each A becomes '0', so 'AAAA' becomes '0000'. Excellent compression ratio.

Constraints

0 ≤ text.length ≤ 1000
text contains only printable ASCII characters
Empty string is valid input

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18 N Netflix 15

The Huffman encoding algorithm provides optimal lossless compression by building a binary tree where frequent characters get shorter codes. The key insight is using a min-heap to systematically merge nodes until forming a tree that naturally assigns the shortest codes to the most frequent characters. Time: O(n + k log k), Space: O(k) where k is the number of unique characters.

Common Approaches

✓ Fixed-Length Encoding

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

Simply convert each character to its 8-bit ASCII representation. No compression occurs, but serves as a baseline to compare against Huffman encoding efficiency.

Frequency-Based Variable Length

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

Count character frequencies first, then manually assign variable-length codes with shorter codes for frequent characters and longer codes for rare ones.

Huffman Tree Algorithm

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

Implement full Huffman encoding by building a binary tree from character frequencies using a min-heap, generating optimal variable-length codes, compressing text, and decompressing it back.

Fixed-Length Encoding — Algorithm Steps

Convert each character to 8-bit binary
Concatenate all binary codes
Calculate metrics

Visualization

Tap to expand

Step-by-Step Walkthrough

Character Input

Read each character from input text

ASCII Conversion

Convert each character to 8-bit binary

Concatenation

Join all binary codes together

Code -

solution.c — C

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

char* solution(const char* text) {
    int len = strlen(text);
    if (len == 0) {
        char* result = malloc(100);
        strcpy(result, "{\"compressedBits\":\"\",\"decompressed\":\"\",\"compressionRatio\":1.0,\"codes\":{}}");
        return result;
    }
    
    // Simple fixed-length encoding
    char* result = malloc(len * 20 + 1000);
    char compressed[len * 8 + 1];
    compressed[0] = '\0';
    
    // Convert each character to 8-bit binary
    for (int i = 0; i < len; i++) {
        char binary[9];
        unsigned char ch = text[i];
        for (int j = 7; j >= 0; j--) {
            binary[7-j] = (ch & (1 << j)) ? '1' : '0';
        }
        binary[8] = '\0';
        strcat(compressed, binary);
    }
    
    sprintf(result, "{\"compressedBits\":\"%s\",\"decompressed\":\"%s\",\"compressionRatio\":1.0,\"codes\":{}}", compressed, text);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through input text to convert each character

⚡ Linearithmic

Space Complexity

O(1)

Only stores the output string, no additional data structures

✓ Linear Space

23.4K Views

Medium Frequency

~45 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

Compression Algorithm - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Fixed-Length Encoding — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler