Reshape Data: Melt

Reshape Data: Melt - Problem

Database Easy

You are given a DataFrame report with the following schema:

Column Name	Type
product	object
quarter_1	int
quarter_2	int
quarter_3	int
quarter_4	int

Write a solution to reshape the data so that each row represents sales data for a product in a specific quarter.

The result should transform wide format data (quarters as columns) into long format data (quarters as rows), where each product appears multiple times - once for each quarter with its corresponding sales value.

Input & Output

Example 1 — Basic Reshape

$ Input: data = [{"product": "A", "quarter_1": 100, "quarter_2": 200, "quarter_3": 150, "quarter_4": 180}]

💡 Note: Product A's quarterly sales are reshaped from columns to rows: each quarter becomes a separate record

Example 2 — Multiple Products

$ Input: data = [{"product": "A", "quarter_1": 100, "quarter_2": 200, "quarter_3": 150, "quarter_4": 180}, {"product": "B", "quarter_1": 120, "quarter_2": 180, "quarter_3": 160, "quarter_4": 200}]

› Output: [{"product": "A", "quarter": "quarter_1", "sales": 100}, {"product": "A", "quarter": "quarter_2", "sales": 200}, {"product": "A", "quarter": "quarter_3", "sales": 150}, {"product": "A", "quarter": "quarter_4", "sales": 180}, {"product": "B", "quarter": "quarter_1", "sales": 120}, {"product": "B", "quarter": "quarter_2", "sales": 180}, {"product": "B", "quarter": "quarter_3", "sales": 160}, {"product": "B", "quarter": "quarter_4", "sales": 200}]

💡 Note: Two products become 8 rows total: each product contributes 4 quarter records

Example 3 — Zero Sales

$ Input: data = [{"product": "C", "quarter_1": 0, "quarter_2": 50, "quarter_3": 0, "quarter_4": 75}]

› Output: [{"product": "C", "quarter": "quarter_1", "sales": 0}, {"product": "C", "quarter": "quarter_2", "sales": 50}, {"product": "C", "quarter": "quarter_3", "sales": 0}, {"product": "C", "quarter": "quarter_4", "sales": 75}]

💡 Note: Even zero sales values are preserved in the melted format

Constraints

1 ≤ data.length ≤ 1000
Product names are non-empty strings
Sales values are non-negative integers

Visualization

Tap to expand

Asked in

M Microsoft 25 G Google 20 f Facebook 15

The key insight is to transform wide format data (quarters as columns) into long format data (quarters as rows) using the melt operation. Best approach is using pandas melt() function for clean, efficient reshaping. Time: O(n), Space: O(n)

Common Approaches

✓ Manual Row Creation

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

For each product, create four separate rows - one for each quarter with the product name, quarter identifier, and sales value.

Pandas Melt Function

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

Leverage pandas melt() function which is specifically designed for transforming wide format data to long format by unpivoting columns.

Manual Row Creation — Algorithm Steps

Step 1: Initialize empty result list
Step 2: For each row, create 4 new rows (one per quarter)
Step 3: Combine all rows into final DataFrame

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Data

Wide format with quarters as columns

Iterate Products

For each product, create 4 new rows

Result

Long format with quarters as rows

Code -

solution.c — C

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

char* solution(char* data) {
    static char result[100000];
    strcpy(result, "[");
    int first = 1;
    
    char* ptr = data;
    
    // Skip initial '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++;
    
    while (*ptr) {
        // Skip whitespace
        while (*ptr && (*ptr == ' ' || *ptr == '\n' || *ptr == '\t')) ptr++;
        
        if (*ptr == ']') break;
        if (*ptr == ',') {
            ptr++;
            continue;
        }
        
        if (*ptr == '{') {
            char product[100] = "";
            int quarters[4] = {0};
            
            ptr++; // skip '{'
            
            // Parse the object
            while (*ptr && *ptr != '}') {
                // Skip whitespace and commas
                while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\n' || *ptr == '\t')) ptr++;
                
                if (*ptr == '"') {
                    ptr++; // skip opening quote
                    
                    if (strncmp(ptr, "product", 7) == 0) {
                        ptr += 7; // skip "product"
                        while (*ptr && *ptr != '"') ptr++; // find closing quote
                        if (*ptr) ptr++; // skip closing quote
                        while (*ptr && *ptr != '"') ptr++; // find value opening quote
                        if (*ptr) ptr++; // skip opening quote
                        
                        int i = 0;
                        while (*ptr && *ptr != '"' && i < 99) {
                            product[i++] = *ptr++;
                        }
                        product[i] = '\0';
                        if (*ptr) ptr++; // skip closing quote
                    }
                    else if (strncmp(ptr, "quarter_", 8) == 0) {
                        ptr += 8; // skip "quarter_"
                        int quarter_num = *ptr - '1'; // get quarter number (0-3)
                        ptr++; // skip quarter number
                        while (*ptr && *ptr != ':') ptr++; // find colon
                        if (*ptr) ptr++; // skip colon
                        while (*ptr && (*ptr == ' ' || *ptr == '\t')) ptr++; // skip whitespace
                        
                        // Parse number
                        int value = 0;
                        while (*ptr && *ptr >= '0' && *ptr <= '9') {
                            value = value * 10 + (*ptr - '0');
                            ptr++;
                        }
                        if (quarter_num >= 0 && quarter_num < 4) {
                            quarters[quarter_num] = value;
                        }
                    }
                    else {
                        // Skip unknown field
                        while (*ptr && *ptr != '"') ptr++; // find closing quote
                        if (*ptr) ptr++; // skip closing quote
                        while (*ptr && *ptr != ':') ptr++; // find colon
                        if (*ptr) ptr++; // skip colon
                        while (*ptr && *ptr != ',' && *ptr != '}') ptr++; // skip value
                    }
                }
                else {
                    ptr++;
                }
            }
            
            if (*ptr == '}') ptr++; // skip closing '}'
            
            // Generate output for this product
            for (int q = 0; q < 4; q++) {
                if (!first) {
                    strcat(result, ", ");
                }
                first = 0;
                
                char temp[200];
                sprintf(temp, "{\"product\": \"%s\", \"quarter\": \"quarter_%d\", \"sales\": %d}", 
                       product, q + 1, quarters[q]);
                strcat(result, temp);
            }
        }
        else {
            ptr++;
        }
    }
    
    strcat(result, "]");
    
    // Allocate and return result
    char* final_result = malloc(strlen(result) + 1);
    strcpy(final_result, result);
    return final_result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through n products, creating 4 rows each

✓ Linear Growth

Space Complexity

O(n)

Store 4n rows in result (4 times original data size)

⚡ Linearithmic Space

30.6K Views

Medium Frequency

~15 min Avg. Time

850 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

Manual Row Creation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler