Reshape Data: Melt - Practice Coding Problems

Reshape Data: Melt - Problem

Database Easy

DataFrame Transformation Challenge: Reshape Data with Melt Operation

You are working as a data analyst for a company that tracks quarterly sales data. The data is currently stored in a wide format where each product has its quarterly sales data spread across multiple columns (quarter_1, quarter_2, quarter_3, quarter_4).

Your task is to reshape this data into a long format where each row represents a single product-quarter combination. This transformation is commonly known as a "melt" operation in data science.

Input Format:
A DataFrame with columns: product (string), quarter_1 (int), quarter_2 (int), quarter_3 (int), quarter_4 (int)

Output Format:
A reshaped DataFrame with columns: product (string), quarter (string), sales (int)

Goal: Transform wide data format to long data format, making it easier for analysis and visualization.

Input & Output

example_1.py — Basic Melt Operation

$ Input: report = pd.DataFrame({ 'product': ['Laptop', 'Mouse'], 'quarter_1': [1000, 500], 'quarter_2': [1100, 550], 'quarter_3': [950, 600], 'quarter_4': [1200, 450] })

› Output: product quarter sales 0 Laptop quarter_1 1000 1 Laptop quarter_2 1100 2 Laptop quarter_3 950 3 Laptop quarter_4 1200 4 Mouse quarter_1 500 5 Mouse quarter_2 550 6 Mouse quarter_3 600 7 Mouse quarter_4 450

💡 Note: Each product row is transformed into 4 rows, one for each quarter. The wide format with quarter columns becomes a long format with quarter and sales columns.

example_2.py — Single Product

$ Input: report = pd.DataFrame({ 'product': ['Keyboard'], 'quarter_1': [300], 'quarter_2': [320], 'quarter_3': [290], 'quarter_4': [350] })

› Output: product quarter sales 0 Keyboard quarter_1 300 1 Keyboard quarter_2 320 2 Keyboard quarter_3 290 3 Keyboard quarter_4 350

💡 Note: Even with a single product, the melt operation creates 4 rows, transforming the wide format into the expected long format structure.

example_3.py — Multiple Products

$ Input: report = pd.DataFrame({ 'product': ['Phone', 'Tablet', 'Watch'], 'quarter_1': [2000, 1500, 800], 'quarter_2': [2200, 1600, 900], 'quarter_3': [1900, 1400, 750], 'quarter_4': [2400, 1800, 950] })

› Output: product quarter sales 0 Phone quarter_1 2000 1 Phone quarter_2 2200 2 Phone quarter_3 1900 3 Phone quarter_4 2400 4 Tablet quarter_1 1500 5 Tablet quarter_2 1600 6 Tablet quarter_3 1400 7 Tablet quarter_4 1800 8 Watch quarter_1 800 9 Watch quarter_2 900 10 Watch quarter_3 750 11 Watch quarter_4 950

💡 Note: With 3 products, the result contains 12 rows (3 × 4 quarters). Each product's quarterly data is properly melted into separate rows while maintaining the product identifier.

Visualization

Tap to expand

Understanding the Visualization

📋 Wide Format Analysis

Original data has products as rows and quarters as separate columns - like a spreadsheet

🔄 Identification Phase

Identify which columns to keep (product) and which to melt (all quarter columns)

⚡ Melt Transformation

Built-in melt function efficiently transforms column headers into row values

📈 Long Format Result

Each original row becomes multiple rows - one for each quarter with proper labeling

Key Takeaway

🎯 Key Insight: Melt operations transform wide data (multiple columns) into long data (multiple rows), making it ideal for analysis, visualization, and database storage. The built-in functions handle this efficiently with optimized algorithms.

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Where n is number of rows and m is number of columns to melt, optimized internally

✓ Linear Growth

Space Complexity

O(n × m)

Same output size as manual approach but with better memory management

⚡ Linearithmic Space

Constraints

1 ≤ number of products ≤ 1000
0 ≤ quarterly sales values ≤ 10⁶
Product names are non-empty strings with length ≤ 50
Each product must have exactly 4 quarters of data
Output should maintain the order: all quarters for first product, then all quarters for second product, etc.

Asked in

N Netflix 35 ♪ Spotify 28 🏠 Airbnb 22 U Uber 18

The optimal solution uses built-in melt operations like pandas.melt() to efficiently transform wide format data to long format. This approach leverages vectorized operations and optimized memory management for superior performance compared to manual iteration methods.

Common Approaches

Approach	Time	Space	Notes
✓ Built-in Melt Operation (Optimal)	O(n × m)	O(n × m)	Use pandas.melt() or equivalent built-in function for efficient transformation
Manual Row-by-Row Transformation	O(n × m)	O(n × m)	Manually iterate through each row and create new rows for each quarter

Built-in Melt Operation (Optimal) — Algorithm Steps

Identify the columns to melt (quarter_1 through quarter_4)
Specify the id column (product)
Call the melt function with appropriate parameters
Rename the resulting columns to match expected output format

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Structure

Built-in function analyzes the DataFrame structure

Vectorized Operation

Efficiently processes all rows simultaneously

Memory Optimization

Optimized memory allocation and data copying

Result Generation

Returns properly formatted long-format DataFrame

Code -

solution.c — C

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

typedef struct {
    char product[50];
    char quarter[20];
    int sales;
} Record;

typedef struct {
    char product[50];
    int quarters[4]; // quarter_1, quarter_2, quarter_3, quarter_4
} InputRow;

// Efficient melt function with pre-allocated memory
int meltData(const InputRow* report, int reportSize, Record* result) {
    const char quarterNames[4][20] = {"quarter_1", "quarter_2", "quarter_3", "quarter_4"};
    int resultIndex = 0;
    
    for (int i = 0; i < reportSize; i++) {
        const InputRow* row = &report[i];
        
        // Efficiently copy data for each quarter
        for (int q = 0; q < 4; q++) {
            Record* newRecord = &result[resultIndex];
            strcpy(newRecord->product, row->product);
            strcpy(newRecord->quarter, quarterNames[q]);
            newRecord->sales = row->quarters[q];
            resultIndex++;
        }
    }
    
    return resultIndex;
}

int main() {
    InputRow data[] = {
        {"Widget A", {100, 120, 110, 130}},
        {"Widget B", {150, 180, 160, 190}}
    };
    
    int dataSize = sizeof(data) / sizeof(data[0]);
    Record* result = malloc(dataSize * 4 * sizeof(Record)); // Pre-allocate
    
    int resultSize = meltData(data, dataSize, result);
    
    for (int i = 0; i < resultSize; i++) {
        printf("%s, %s, %d\n", result[i].product, result[i].quarter, result[i].sales);
    }
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Where n is number of rows and m is number of columns to melt, optimized internally

✓ Linear Growth

Space Complexity

O(n × m)

Same output size as manual approach but with better memory management

⚡ Linearithmic Space

Constraints

1 ≤ number of products ≤ 1000
0 ≤ quarterly sales values ≤ 10⁶
Product names are non-empty strings with length ≤ 50
Each product must have exactly 4 quarters of data
Output should maintain the order: all quarters for first product, then all quarters for second product, etc.

32.0K Views

High Frequency

~15 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Built-in Melt Operation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler