2890. Reshape Data Melt

1import java.util.ArrayList;
2import java.util.HashMap;
3import java.util.List;
4import java.util.Map;
5
6class SalesReport {
7
8    // A method to transform a report into a melted format where each row represents a single observation
9    public static List<Map<String, String>> meltTable(List<Map<String, String>> report) {
10        List<Map<String, String>> meltedReport = new ArrayList<>();
11
12        // Loop over each row (each map is a row with the product and sales data)
13        for (Map<String, String> row : report) {
14            String product = row.get("product");
15            // Loop over each entry in the map, which represents the columns in the original table
16            for (Map.Entry<String, String> entry : row.entrySet()) {
17                if (!entry.getKey().equals("product")) { // Ignore the product column for melting
18                    // Create a new map for the melted row
19                    Map<String, String> meltedRow = new HashMap<>();
20                    meltedRow.put("product", product);
21                    meltedRow.put("quarter", entry.getKey()); // The column name becomes the quarter
22                    meltedRow.put("sales", entry.getValue()); // The value remains the sale amount
23                    meltedReport.add(meltedRow);
24                }
25            }
26        }
27        return meltedReport; // Return the melted table
28    }
29
30    // Example usage
31    public static void main(String[] args) {
32        List<Map<String, String>> report = new ArrayList<>();
33        Map<String, String> row1 = new HashMap<>();
34        row1.put("product", "A");
35        row1.put("Q1", "10");
36        row1.put("Q2", "15");
37        row1.put("Q3", "20");
38        row1.put("Q4", "25");
39        report.add(row1);
40
41        Map<String, String> row2 = new HashMap<>();
42        row2.put("product", "B");
43        row2.put("Q1", "5");
44        row2.put("Q2", "10");
45        row2.put("Q3", "15");
46        row2.put("Q4", "20");
47        report.add(row2);
48
49        List<Map<String, String>> meltedReport = meltTable(report);
50
51        // Print melted report
52        for (Map<String, String> meltedRow : meltedReport) {
53            System.out.println(meltedRow);
54        }
55    }
56}
57

1#include <pandas/pandas.h> // Include the pandas C++ library (note: a C++ pandas-like library doesn't exist, but assuming it for the purpose of the exercise.)
2
3class ReportTransformer {
4public:
5    // Transforms the input DataFrame into a format where each row represents a single observation for a specific quarter and product.
6    pandas::DataFrame meltTable(const pandas::DataFrame& report) const {
7        // 'melt': Convert the given DataFrame from wide format to long format.
8        // 'idVars': Vector of column names to use as identifier variables.
9        // 'varName': Name of the new column created after melting that will hold the variable names.
10        // 'valueName': Name of the new column created that will contain the values.
11        pandas::DataFrame meltedReport = report.melt(
12            {"product"}, // idVars
13            "quarter",   // varName
14            "sales"      // valueName
15        );
16      
17        return meltedReport; // Return the melted DataFrame
18    }
19};
20
21// Usage example:
22// Assuming 'report' is a pandas::DataFrame structured with 'product' as one of the columns
23// and other columns represent sales data for each quarter like Q1, Q2, Q3, Q4.
24// Example structure of 'report' before melting:
25// product  Q1  Q2  Q3  Q4
26// A        10  15  20  25
27// B        5   10  15  20
28// After calling meltTable(report), the result will be:
29// product quarter sales
30// A       Q1      10
31// B       Q1      5
32// A       Q2      15
33// B       Q2      10
34// ...and so on for each product and quarter.
35

1interface ProductReport {
2    product: string;
3    [key: string]: string | number; // Represents sales data for each quarter with dynamic keys
4}
5
6interface MeltedReport {
7    product: string;
8    quarter: string;
9    sales: number;
10}
11
12function meltTable(report: ProductReport[]): MeltedReport[] {
13    // Function to transform the input array of objects into a format
14    // where each entry represents a single observation for a specific quarter and product.
15
16    let meltedReport: MeltedReport[] = [];
17
18    // Loop over each product report
19    report.forEach((productReport) => {
20        // Loop over each property in the product report object
21        for (const [key, value] of Object.entries(productReport)) {
22            // Skip the 'product' key as it's the identifier
23            if (key !== 'product') {
24                // Create an object for each quarter with sales data and push it into the meltedReport array
25                meltedReport.push({
26                    product: productReport.product,
27                    quarter: key,
28                    sales: value as number // Assuming the value is always a number for sales data
29                });
30            }
31        }
32    });
33
34    return meltedReport; // Return the transformed data
35}
36
37// Usage example:
38// Assuming 'report' is an array of objects structured with 'product' as one of the properties
39// and other properties represent sales data for each quarter.
40// Example structure of 'report' before melting:
41// [
42//   { product: 'A', Q1: 10, Q2: 15, Q3: 20, Q4: 25 },
43//   { product: 'B', Q1: 5, Q2: 10, Q3: 15, Q4: 20 }
44// ]
45// After calling meltTable(report), the result will be:
46// [
47//   { product: 'A', quarter: 'Q1', sales: 10 },
48//   { product: 'A', quarter: 'Q2', sales: 15 },
49//   ...
50//   { product: 'B', quarter: 'Q1', sales: 5 },
51//   { product: 'B', quarter: 'Q2', sales: 10 },
52//   ...
53// ]
54