Decompress Run-Length Encoded List - Practice Coding Problems

Decompress Run-Length Encoded List - Problem

Array Easy

Run-Length Encoding (RLE) is a simple compression technique used in data storage and transmission. In this problem, you're given a compressed array and need to decompress it back to its original form.

You are given an array nums where each pair of adjacent elements represents compressed data:

Format: [frequency, value, frequency, value, ...]
Each pair [nums[2*i], nums[2*i+1]] means: repeat nums[2*i+1] exactly nums[2*i] times

Goal: Decompress the array by expanding each [frequency, value] pair into a sequence of repeated values, then concatenate all sequences from left to right.

Example: [1,2,3,4] → [2,4,4,4]
Because: 1×2 + 3×4 = [2] + [4,4,4] = [2,4,4,4]

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,2,3,4]

› Output: [2,4,4,4]

💡 Note: The pairs are [1,2] and [3,4]. This means take value 2 once and value 4 three times, resulting in [2,4,4,4].

example_2.py — Multiple Pairs

$ Input: nums = [1,1,2,3,3,2]

› Output: [1,3,3,2,2,2]

💡 Note: The pairs are [1,1], [2,3], and [3,2]. This expands to [1] + [3,3] + [2,2,2] = [1,3,3,2,2,2].

example_3.py — Edge Case

$ Input: nums = [2,5]

› Output: [5,5]

💡 Note: Single pair [2,5] means take value 5 twice, resulting in [5,5].

Constraints

2 <= nums.length <= 100
nums.length % 2 == 0
1 <= nums[2*i] <= 100
0 <= nums[2*i+1] <= 100
The input array always has even length

Visualization

Tap to expand

Understanding the Visualization

Read Compressed Format

Parse input as [frequency, note, frequency, note, ...]

Process Each Pair

For each [freq, note], add note to result freq times

Build Final Sequence

Concatenate all expanded notes into final melody

Return Decompressed

Output the complete expanded sequence

Key Takeaway

🎯 Key Insight: This problem requires direct expansion without complex data structures - just process each frequency-value pair and build the result incrementally.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution processes the run-length encoded array in a single pass, expanding each [frequency, value] pair by adding the value to the result array frequency number of times. The key insight is that we can build the result directly without needing any additional data structures, achieving O(n + m) time complexity where n is the input size and m is the output size.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Single Pass (Optimal)	O(n + m)	O(m)	Process pairs in one pass using list extension for better performance
Brute Force (Nested Loops)	O(n + m)	O(m)	Process each frequency-value pair with nested loops to build the result

Optimized Single Pass (Optimal) — Algorithm Steps

Calculate the total output size by summing all frequencies
Pre-allocate the result array with the exact size needed
Iterate through input pairs once
For each pair, use efficient bulk operations to add values
Return the pre-sized result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Size

Sum all frequencies to get total output size

Pre-allocate

Create result array with exact size needed

Fill Efficiently

Use bulk operations to fill array sections

Return Result

Return the completed decompressed array

Code -

solution.c — C

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

int* decompressRLElist(int* nums, int numsSize, int* returnSize) {
    // Calculate total size first
    int totalSize = 0;
    for (int i = 0; i < numsSize; i += 2) {
        totalSize += nums[i];
    }
    
    int* result = (int*)malloc(totalSize * sizeof(int));
    int index = 0;
    
    // Process pairs efficiently
    for (int i = 0; i < numsSize; i += 2) {
        int frequency = nums[i];
        int value = nums[i + 1];
        // Fill array section efficiently
        for (int j = 0; j < frequency; j++) {
            result[index + j] = value;
        }
        index += frequency;
    }
    
    *returnSize = totalSize;
    return result;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[100];
    int size = 0;
    char* token = strtok(input, "[,]\n ");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[,]\n ");
    }
    
    int returnSize;
    int* result = decompressRLElist(nums, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Two passes: O(n) to calculate size + O(m) to fill result, where n is input size and m is output size

✓ Linear Growth

Space Complexity

O(m)

Exactly m space for output array, no extra space for dynamic resizing

✓ Linear Space

58.0K Views

Medium Frequency

~8 min Avg. Time

2.4K 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 (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler