Product of Two Run-Length Encoded Arrays - Problem

Run-length encoding is a compression algorithm that allows for an integer array nums with many segments of consecutive repeated numbers to be represented by a (generally smaller) 2D array encoded. Each encoded[i] = [val_i, freq_i] describes the i^th segment of repeated numbers in nums where val_i is the value that is repeated freq_i times.

For example, nums = [1,1,1,2,2,2,2,2] is represented by the run-length encoded array encoded = [[1,3],[2,5]]. Another way to read this is "three 1's followed by five 2's".

The product of two run-length encoded arrays encoded1 and encoded2 can be calculated using the following steps:

Expand both encoded1 and encoded2 into the full arrays nums1 and nums2 respectively.
Create a new array prodNums of length nums1.length and set prodNums[i] = nums1[i] * nums2[i].
Compress prodNums into a run-length encoded array and return it.

You are given two run-length encoded arrays encoded1 and encoded2 representing full arrays nums1 and nums2 respectively. Both nums1 and nums2 have the same length. Each encoded1[i] = [val_i, freq_i] describes the i^th segment of nums1, and each encoded2[j] = [val_j, freq_j] describes the j^th segment of nums2.

Return the product of encoded1 and encoded2.

Note: Compression should be done such that the run-length encoded array has the minimum possible length.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: Expanded arrays are [1,1,1,2,2] and [6,6,3,3,3]. Products: [6,6,3,6,6]. Compressed: [[6,2],[3,1],[6,2]]

Example 2 — Single Segments

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

› Output: [[4,2]]

💡 Note: Both arrays have single segments. Products: [1×4, 1×4] = [4,4]. Compressed: [[4,2]]

Example 3 — Different Lengths

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

› Output: [[10,1],[15,1],[20,1]]

💡 Note: First array [2,3,4], second array [5,5,5]. Products: [10,15,20]. All different, so [[10,1],[15,1],[20,1]]

Constraints

1 ≤ encoded1.length, encoded2.length ≤ 10⁵
encoded1[i].length == 2
1 ≤ encoded1[i][1], encoded2[i][1] ≤ 10⁴
-10⁵ ≤ encoded1[i][0], encoded2[i][0] ≤ 10⁵

Visualization

Tap to expand

Asked in

f Facebook 15 G Google 12 a Amazon 8

The key insight is to use two pointers to process both run-length encoded arrays simultaneously without expanding them fully. Instead of creating the full arrays (which uses O(n) space), we can process overlapping segments directly and build the result on-the-fly. Best approach is Two Pointers with Time: O(m+n), Space: O(1).

Common Approaches

✓ Brute Force - Full Expansion

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

First expand both run-length encoded arrays into their full representations, then multiply corresponding elements, and finally compress the result back into run-length encoding. This is straightforward but uses extra space for the expanded arrays.

Two Pointers - Direct Processing

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

Instead of expanding the entire arrays, use two pointers to track current positions in both encoded arrays. Process overlapping segments by calculating how many elements can be processed together, compute their product, and add to result if different from previous.

Brute Force - Full Expansion — Algorithm Steps

Step 1: Expand encoded1 into full array nums1
Step 2: Expand encoded2 into full array nums2
Step 3: Multiply corresponding elements: prodNums[i] = nums1[i] * nums2[i]
Step 4: Compress prodNums back into run-length encoding

Visualization

Tap to expand

Step-by-Step Walkthrough

Expand Arrays

Convert run-length encoding to full arrays

Element-wise Product

Multiply corresponding elements

Compress Result

Convert back to run-length encoding

Code -

solution.c — C

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

int** solution(int** encoded1, int encoded1Size, int* encoded1ColSize, int** encoded2, int encoded2Size, int* encoded2ColSize, int* returnSize, int** returnColumnSizes) {
    // Expand encoded1 to full array
    int nums1Size = 0;
    for (int i = 0; i < encoded1Size; i++) {
        nums1Size += encoded1[i][1];
    }
    int* nums1 = (int*)malloc(nums1Size * sizeof(int));
    int nums1Idx = 0;
    for (int i = 0; i < encoded1Size; i++) {
        int val = encoded1[i][0];
        int freq = encoded1[i][1];
        for (int j = 0; j < freq; j++) {
            nums1[nums1Idx++] = val;
        }
    }
    
    // Expand encoded2 to full array
    int nums2Size = 0;
    for (int i = 0; i < encoded2Size; i++) {
        nums2Size += encoded2[i][1];
    }
    int* nums2 = (int*)malloc(nums2Size * sizeof(int));
    int nums2Idx = 0;
    for (int i = 0; i < encoded2Size; i++) {
        int val = encoded2[i][0];
        int freq = encoded2[i][1];
        for (int j = 0; j < freq; j++) {
            nums2[nums2Idx++] = val;
        }
    }
    
    // Multiply corresponding elements
    int* prodNums = (int*)malloc(nums1Size * sizeof(int));
    for (int i = 0; i < nums1Size; i++) {
        prodNums[i] = nums1[i] * nums2[i];
    }
    
    // Compress back to run-length encoding
    if (nums1Size == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int** result = (int**)malloc(nums1Size * sizeof(int*));
    *returnColumnSizes = (int*)malloc(nums1Size * sizeof(int));
    int resultSize = 0;
    
    int currentVal = prodNums[0];
    int currentFreq = 1;
    
    for (int i = 1; i < nums1Size; i++) {
        if (prodNums[i] == currentVal) {
            currentFreq++;
        } else {
            result[resultSize] = (int*)malloc(2 * sizeof(int));
            result[resultSize][0] = currentVal;
            result[resultSize][1] = currentFreq;
            (*returnColumnSizes)[resultSize] = 2;
            resultSize++;
            currentVal = prodNums[i];
            currentFreq = 1;
        }
    }
    
    result[resultSize] = (int*)malloc(2 * sizeof(int));
    result[resultSize][0] = currentVal;
    result[resultSize][1] = currentFreq;
    (*returnColumnSizes)[resultSize] = 2;
    resultSize++;
    
    *returnSize = resultSize;
    
    free(nums1);
    free(nums2);
    free(prodNums);
    
    return result;
}

// Parsing helpers
int** parseArray(char* str, int* size, int** colSizes) {
    int** arr = (int**)malloc(1000 * sizeof(int*));
    *colSizes = (int*)malloc(1000 * sizeof(int));
    int count = 0;

    char* p = str;
    // Skip initial '['
    while (*p && *p != '[') p++;
    if (*p) p++;

    while (*p) {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',' || *p == '\n' || *p == '\r') p++;
        
        // Look for inner '['
        if (*p == '[') {
            p++; // skip '['
            
            // Parse first number
            int val = (int)strtol(p, &p, 10);
            
            // Skip comma
            while (*p == ',' || *p == ' ') p++;
            
            // Parse second number
            int freq = (int)strtol(p, &p, 10);
            
            // Skip to ']'
            while (*p && *p != ']') p++;
            if (*p) p++; // skip ']'
            
            arr[count] = (int*)malloc(2 * sizeof(int));
            arr[count][0] = val;
            arr[count][1] = freq;
            (*colSizes)[count] = 2;
            count++;
        } else if (*p == ']') {
            break;
        } else if (*p == '\0') {
            break;
        } else {
            p++;
        }
    }

    *size = count;
    return arr;
}

void printResult(int** result, int size) {
    printf("[");
    for (int i = 0; i < size; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", result[i][0], result[i][1]);
    }
    printf("]\n");
}

int main() {
    char line1[100000], line2[100000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);

    int enc1Size, enc2Size;
    int* enc1ColSizes;
    int* enc2ColSizes;

    int** encoded1 = parseArray(line1, &enc1Size, &enc1ColSizes);
    int** encoded2 = parseArray(line2, &enc2Size, &enc2ColSizes);

    int returnSize;
    int* returnColumnSizes;

    int** result = solution(encoded1, enc1Size, enc1ColSizes, encoded2, enc2Size, enc2ColSizes, &returnSize, &returnColumnSizes);

    printResult(result, returnSize);

    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to expand each array (2n) + single pass to multiply (n) + single pass to compress (n) = O(n)

✓ Linear Growth

Space Complexity

O(n)

Two expanded arrays of size n plus result array

⚡ Linearithmic Space

23.4K Views

Medium Frequency

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

Product of Two Run-Length Encoded Arrays - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Full Expansion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler