Calculate Compressed Mean - Practice Coding Problems

Calculate Compressed Mean - Problem

Database Easy

Calculate Compressed Mean

You are working as a data analyst for an e-commerce company. The database contains a compressed representation of order data where each row represents multiple occurrences of similar orders.

Given a table Orders with the following structure:

Column Name	Type
order_id	int
item_count	int
order_occurrences	int

Where:
• order_id is the unique identifier for each order type
• item_count is the number of items in that specific order type
• order_occurrences is how many times this exact order occurred

Your task: Calculate the average number of items per individual order across all actual orders, rounded to 2 decimal places.

Key insight: Since the data is compressed, you need to 'expand' it by considering that each row represents multiple individual orders based on order_occurrences.

Input & Output

example_1.sql — Basic Case

$ Input: Orders table: | order_id | item_count | order_occurrences | |----------|------------|-------------------| | 1 | 3 | 4 | | 2 | 2 | 3 | | 3 | 5 | 2 |

› Output: | average_items_per_order | |------------------------| | 2.89 |

💡 Note: Total items = (3×4) + (2×3) + (5×2) = 12 + 6 + 10 = 28. Total orders = 4 + 3 + 2 = 9. Average = 28/9 = 3.11... ≈ 2.89 (rounded to 2 decimals).

example_2.sql — Single Row

$ Input: Orders table: | order_id | item_count | order_occurrences | |----------|------------|-------------------| | 1 | 10 | 5 |

› Output: | average_items_per_order | |------------------------| | 10.00 |

💡 Note: Only one row: Total items = 10×5 = 50. Total orders = 5. Average = 50/5 = 10.00.

example_3.sql — Mixed Values

$ Input: Orders table: | order_id | item_count | order_occurrences | |----------|------------|-------------------| | 1 | 1 | 10 | | 2 | 10 | 1 |

› Output: | average_items_per_order | |------------------------| | 1.82 |

💡 Note: Total items = (1×10) + (10×1) = 10 + 10 = 20. Total orders = 10 + 1 = 11. Average = 20/11 = 1.818... ≈ 1.82.

Visualization

Tap to expand

Understanding the Visualization

Identify Weights

Each item_count is weighted by its order_occurrences frequency

Calculate Weighted Sum

Multiply each item count by how often it occurred, then sum all results

Calculate Total Weight

Sum all the occurrence frequencies to get total number of individual orders

Compute Weighted Average

Divide weighted sum by total weight, round to 2 decimal places

Key Takeaway

🎯 Key Insight: This is a weighted average problem, not a simple arithmetic mean. Each item count must be weighted by its occurrence frequency to get the true average items per individual order.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all rows for aggregation

✓ Linear Growth

Space Complexity

O(1)

Only stores intermediate aggregation results

✓ Linear Space

Constraints

1 ≤ Number of rows in Orders table ≤ 1000
1 ≤ item_count ≤ 100
1 ≤ order_occurrences ≤ 1000
order_id is unique for each row
Result must be rounded to exactly 2 decimal places

Asked in

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

The optimal solution uses SQL aggregation with weighted average. Calculate SUM(item_count × order_occurrences) for total items and SUM(order_occurrences) for total orders, then divide and round to 2 decimal places. This approach leverages SQL's built-in optimization and handles the compressed data format efficiently in O(n) time with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Row-by-Row Expansion)	O(n)	O(1)	Mentally expand each compressed row and calculate average step by step
SQL Aggregation (Optimal)	O(n)	O(1)	Use SQL's SUM and weighted average in a single query

Brute Force (Row-by-Row Expansion) — Algorithm Steps

Initialize total_items = 0 and total_orders = 0
For each row, add (item_count × order_occurrences) to total_items
For each row, add order_occurrences to total_orders
Calculate average = total_items / total_orders
Round to 2 decimal places

Visualization

Tap to expand

Step-by-Step Walkthrough

Read Compressed Data

Process each row with item_count and order_occurrences

Calculate Contribution

Multiply item_count by order_occurrences for total items from this row

Accumulate Totals

Add to running totals of items and orders

Compute Average

Divide total items by total orders and round

Code -

solution.c — C

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

typedef struct {
    int item_count;
    int order_occurrences;
} Order;

double calculateCompressedMean(Order orders[], int n) {
    int totalItems = 0;
    int totalOrders = 0;
    
    // Process each compressed row
    for (int i = 0; i < n; i++) {
        // Accumulate totals (simulating expansion)
        totalItems += orders[i].item_count * orders[i].order_occurrences;
        totalOrders += orders[i].order_occurrences;
    }
    
    // Calculate average and round to 2 decimal places
    if (totalOrders == 0) {
        return 0.00;
    }
    
    double average = (double)totalItems / totalOrders;
    return round(average * 100.0) / 100.0;
}

int main() {
    Order orders[1000];
    int n = 0;
    // Parse input implementation
    printf("%.2f\n", calculateCompressedMean(orders, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We scan through each row once to accumulate totals

✓ Linear Growth

Space Complexity

O(1)

Only need variables to store running totals

✓ Linear Space

Constraints

1 ≤ Number of rows in Orders table ≤ 1000
1 ≤ item_count ≤ 100
1 ≤ order_occurrences ≤ 1000
order_id is unique for each row
Result must be rounded to exactly 2 decimal places

28.8K Views

Medium Frequency

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Row-by-Row Expansion) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler