Product of Two Run-Length Encoded Arrays - Practice Coding Problems

Product of Two Run-Length Encoded Arrays - Problem

Run-length encoding is a clever compression technique that represents arrays with consecutive repeated numbers in a compact format. Instead of storing [1,1,1,2,2,2,2,2], we can represent it as [[1,3],[2,5]] meaning "three 1's followed by five 2's".

Your task is to multiply two run-length encoded arrays without fully expanding them into their original arrays. Given two encoded arrays representing the same-length sequences, calculate their element-wise product and return the result in run-length encoded format.

The Challenge: The naive approach would expand both arrays, multiply corresponding elements, and re-compress. But can you do it more efficiently by working directly with the compressed format?

Example:
• encoded1 = [[1,3],[2,1]] represents [1,1,1,2]
• encoded2 = [[6,2],[1,2]] represents [6,6,1,1]
• Product: [6,6,2,2] → encoded as [[6,2],[2,2]]

Input & Output

example_1.py — Basic Case

$ Input: encoded1 = [[1,3],[2,1]], encoded2 = [[6,2],[1,2]]

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

💡 Note: encoded1 expands to [1,1,1,2] and encoded2 expands to [6,6,1,1]. The product is [1*6,1*6,1*1,2*1] = [6,6,1,2], which compresses to [[6,2],[1,1],[2,1]]. However, we can optimize to get [[6,2],[2,1]] by noticing that [1,1] can be merged with [2,1] as they're not consecutive equal values.

example_2.py — Single Segments

$ Input: encoded1 = [[1,3]], encoded2 = [[2,3]]

› Output: [[2,3]]

💡 Note: encoded1 expands to [1,1,1] and encoded2 expands to [2,2,2]. The product is [1*2,1*2,1*2] = [2,2,2], which compresses to [[2,3]].

example_3.py — Multiple Products

$ Input: encoded1 = [[2,2],[3,1]], encoded2 = [[1,1],[4,2]]

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

💡 Note: encoded1 expands to [2,2,3] and encoded2 expands to [1,4,4]. The product is [2*1,2*4,3*4] = [2,8,12]. Since these are all different values, the result compresses to [[2,1],[8,1],[12,1]], but we need to be careful about segment boundaries.

Constraints

1 ≤ encoded1.length, encoded2.length ≤ 10⁵
encoded1[i].length == encoded2[i].length == 2
1 ≤ val_i, freq_i ≤ 10⁴
The sum of freq_i for encoded1 equals the sum of freq_i for encoded2
Both arrays represent sequences of the same total length

Visualization

Tap to expand

Understanding the Visualization

Setup Coordination

Position supervisors at both conveyor belts to monitor current batches

Synchronize Production

Calculate how many combined products can be made from current batches

Update Inventory

Reduce remaining counts and move to next batch when current is exhausted

Optimize Output

Merge consecutive identical products into single batches

Key Takeaway

🎯 Key Insight: By synchronizing two pointers and tracking remaining counts, we can multiply run-length encoded arrays directly without expansion, achieving optimal time and space complexity.

Asked in

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

The optimal solution uses two pointers to traverse both encoded arrays simultaneously. Instead of expanding arrays fully, we process segments directly by maintaining current positions and remaining counts. The key insight is to consume the minimum available count from both current segments, add the product to results, and advance pointers when segments are exhausted. This achieves O(m + n) time and O(1) extra space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Full Expansion)	O(n)	O(n)	Expand both arrays completely, multiply elements, then re-compress
Two Pointers (Optimal)	O(m + n)	O(1)	Process both encoded arrays simultaneously using two pointers

Brute Force (Full Expansion) — Algorithm Steps

Expand encoded1 into full array nums1
Expand encoded2 into full array nums2
Create product array by multiplying nums1[i] * nums2[i]
Compress the product array back into run-length encoding

Visualization

Tap to expand

Step-by-Step Walkthrough

Expand Arrays

Convert run-length encoded arrays to full arrays

Element-wise Multiplication

Multiply corresponding elements

Re-compress

Group consecutive equal products back into run-length format

Code -

solution.c — C

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

int** findRLEArray(int** encoded1, int encoded1Size, int* encoded1ColSize,
                   int** encoded2, int encoded2Size, int* encoded2ColSize,
                   int* returnSize, int** returnColumnSizes) {
    // Calculate total length
    int totalLen = 0;
    for (int i = 0; i < encoded1Size; i++) {
        totalLen += encoded1[i][1];
    }
    
    // Expand both arrays
    int* nums1 = (int*)malloc(totalLen * sizeof(int));
    int* nums2 = (int*)malloc(totalLen * sizeof(int));
    
    int idx = 0;
    for (int i = 0; i < encoded1Size; i++) {
        for (int j = 0; j < encoded1[i][1]; j++) {
            nums1[idx++] = encoded1[i][0];
        }
    }
    
    idx = 0;
    for (int i = 0; i < encoded2Size; i++) {
        for (int j = 0; j < encoded2[i][1]; j++) {
            nums2[idx++] = encoded2[i][0];
        }
    }
    
    // Multiply and compress
    int** result = (int**)malloc(totalLen * sizeof(int*));
    *returnColumnSizes = (int*)malloc(totalLen * sizeof(int));
    
    int resultIdx = 0;
    int currentVal = nums1[0] * nums2[0];
    int currentCount = 1;
    
    for (int i = 1; i < totalLen; i++) {
        int product = nums1[i] * nums2[i];
        if (product == currentVal) {
            currentCount++;
        } else {
            result[resultIdx] = (int*)malloc(2 * sizeof(int));
            result[resultIdx][0] = currentVal;
            result[resultIdx][1] = currentCount;
            (*returnColumnSizes)[resultIdx] = 2;
            resultIdx++;
            currentVal = product;
            currentCount = 1;
        }
    }
    
    result[resultIdx] = (int*)malloc(2 * sizeof(int));
    result[resultIdx][0] = currentVal;
    result[resultIdx][1] = currentCount;
    (*returnColumnSizes)[resultIdx] = 2;
    resultIdx++;
    
    *returnSize = resultIdx;
    free(nums1);
    free(nums2);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the total length of the expanded arrays. We expand, multiply, and compress in linear time.

✓ Linear Growth

Space Complexity

O(n)

Need to store both fully expanded arrays plus the product array before compression

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~18 min Avg. Time

847 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 (Full Expansion) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler