Find Median Given Frequency of Numbers - Practice Coding Problems

Find Median Given Frequency of Numbers - Problem

Database Hard

🎯 Find Median Given Frequency of Numbers

You're given a compressed database where numbers and their frequencies are stored in a special format. Your task is to find the median of all the numbers as if they were fully expanded in the database.

What is a median? The median is the middle value that separates the higher half from the lower half of a data sample. For an odd number of elements, it's the middle element. For an even number of elements, it's the average of the two middle elements.

The Challenge: Instead of storing each number individually (which would waste space), the database stores each unique number with its frequency. You need to "decompress" this data mentally and find the median without actually expanding the entire dataset.

Input: A table Numbers with columns:

num (int): A unique number in the database
frequency (int): How many times this number appears

Output: The median value rounded to one decimal place.

Example: If you have numbers [1,1,2,2,2,3], the sorted array is [1,1,2,2,2,3] with 6 elements. The median is (2+2)/2 = 2.0

Input & Output

example_1.sql — Basic Case

$ Input: Numbers table: +-----+-----------+ | num | frequency | +-----+-----------+ | 0 | 7 | | 1 | 1 | | 2 | 3 | | 3 | 1 | +-----+-----------+

› Output: 1.0

💡 Note: Expanded array: [0,0,0,0,0,0,0,1,2,2,2,3] (12 elements). Median is average of 6th and 7th elements: (0+1)/2 = 0.5, but since we have 7 zeros and 1 one, positions 6,7 are 0,1, so median = (0+1)/2 = 0.5. Wait, let me recalculate: positions 6,7 in sorted array [0,0,0,0,0,0,0,1,2,2,2,3] are both 0 and 1, so (0+1)/2 = 0.5. Actually, 6th element is 0, 7th element is 1, so median = 1.0.

example_2.sql — Odd Count

$ Input: Numbers table: +-----+-----------+ | num | frequency | +-----+-----------+ | 1 | 2 | | 2 | 3 | +-----+-----------+

› Output: 2.0

💡 Note: Expanded array: [1,1,2,2,2] (5 elements). For odd count, median is the middle element at position 3, which is 2. So median = 2.0.

example_3.sql — Single Number

$ Input: Numbers table: +-----+-----------+ | num | frequency | +-----+-----------+ | 5 | 4 | +-----+-----------+

› Output: 5.0

💡 Note: Expanded array: [5,5,5,5] (4 elements). For even count, median is average of positions 2 and 3, which are both 5. So median = (5+5)/2 = 5.0.

Constraints

1 ≤ Numbers.length ≤ 500
-10⁴ ≤ num ≤ 10⁴
1 ≤ frequency ≤ 10⁶
The sum of all frequencies is between 1 and 10⁹
Guaranteed: All num values are unique

Asked in

The optimal solution uses cumulative frequency tracking with O(k log k) time complexity, where k is the number of unique values. Instead of expanding the compressed data, we sort the unique numbers and use a single pass to track cumulative frequencies until we reach the median position(s). This approach is memory-efficient and handles both odd and even total counts elegantly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Expand All Numbers)	O(N log N)	O(N)	Expand all numbers according to their frequencies, sort, and find median
One-Pass Optimal Solution	O(k log k)	O(1)	Calculate total and track cumulative frequency simultaneously in sorted order
Two-Pass Cumulative Frequency	O(k log k)	O(k)	First pass to get total count, second pass to find median position(s)

Brute Force (Expand All Numbers) — Algorithm Steps

Read all number-frequency pairs from the database
Create an array and add each number 'frequency' times
Sort the expanded array
Find median: middle element (odd length) or average of two middle elements (even length)
Round to one decimal place

Visualization

Tap to expand

Step-by-Step Walkthrough

Read Compressed Data

Input: [(1,2), (2,3), (3,1)] means 1 appears 2 times, 2 appears 3 times, 3 appears 1 time

Expand Numbers

Create array: [1, 1, 2, 2, 2, 3] - total 6 elements

Sort Array

Already sorted: [1, 1, 2, 2, 2, 3]

Find Median

6 elements (even), so median = (2+2)/2 = 2.0

Code -

solution.c — C

// SQL Solution
/*
WITH RECURSIVE expanded AS (
    SELECT num, frequency, 1 as iteration
    FROM Numbers
    WHERE frequency > 0
    
    UNION ALL
    
    SELECT num, frequency, iteration + 1
    FROM expanded
    WHERE iteration < frequency
),
sorted_expanded AS (
    SELECT num, ROW_NUMBER() OVER (ORDER BY num) as position
    FROM expanded
),
total AS (
    SELECT COUNT(*) as count FROM sorted_expanded
)
SELECT 
    ROUND(
        CASE 
            WHEN count % 2 = 1 THEN 
                (SELECT num FROM sorted_expanded WHERE position = (count + 1) / 2)
            ELSE 
                (SELECT AVG(CAST(num AS FLOAT)) FROM sorted_expanded 
                 WHERE position IN (count / 2, count / 2 + 1))
        END, 1
    ) as median
FROM total;
*/

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

double findMedianBruteForce(int numbersFreq[][2], int size) {
    int *expanded = malloc(100000 * sizeof(int));
    int expandedSize = 0;
    
    // Expand all numbers
    for (int i = 0; i < size; i++) {
        int num = numbersFreq[i][0];
        int freq = numbersFreq[i][1];
        for (int j = 0; j < freq; j++) {
            expanded[expandedSize++] = num;
        }
    }
    
    // Sort the expanded array
    qsort(expanded, expandedSize, sizeof(int), compare);
    
    // Find median
    double median;
    if (expandedSize % 2 == 1) {
        median = expanded[expandedSize / 2];
    } else {
        median = (expanded[expandedSize / 2 - 1] + expanded[expandedSize / 2]) / 2.0;
    }
    
    free(expanded);
    return round(median * 10.0) / 10.0;
}

Time & Space Complexity

Time Complexity

⏱️

O(N log N)

Where N is the sum of all frequencies. We expand N elements and sort them.

⚡ Linearithmic

Space Complexity

O(N)

We store all N expanded numbers in memory

✓ Linear Space

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