Design an Array Statistics Tracker

Design an Array Statistics Tracker - Problem

Hash Table Binary Search Design Queue Heap (Priority Queue) Data Stream Ordered Set Hard

You need to design a smart data structure that can dynamically track statistical measures of numbers as they are added and removed. Think of it as a real-time analytics system that maintains running statistics!

Your StatisticsTracker class should support:

Adding numbers: Insert new values into the tracker
Removing numbers: Remove the earliest added number (FIFO - First In, First Out)
Computing statistics: Calculate mean, median, and mode on-demand

Statistical Definitions:

Mean: Sum of all values ÷ count of values (floored to integer)
Median: Middle value when sorted. If even count, take the larger of the two middle values
Mode: Most frequently occurring value. If multiple modes exist, return the smallest one

The challenge is to efficiently maintain these statistics as the data changes dynamically through additions and removals.

Input & Output

example_1.py — Basic Operations

$ Input: ["StatisticsTracker", "addNumber", "addNumber", "addNumber", "getMean", "getMedian", "getMode"] [[], [1], [3], [1], [], [], []]

› Output: [null, null, null, null, 1, 1, 1]

💡 Note: Initialize tracker, add 1, 3, 1. Mean = (1+3+1)/3 = 1, Median of [1,1,3] = 1 (middle), Mode = 1 (appears twice)

example_2.py — With Removal

$ Input: ["StatisticsTracker", "addNumber", "addNumber", "addNumber", "removeFirstAddedNumber", "getMean", "getMedian", "getMode"] [[], [4], [2], [1], [], [], [], []]

› Output: [null, null, null, null, null, 1, 2, 1]

💡 Note: Add 4,2,1 then remove first (4). Remaining: [2,1]. Mean = (2+1)/2 = 1, Median of [1,2] = 2 (larger middle), Mode = 1 (lexically smaller)

example_3.py — Edge Case Single Element

$ Input: ["StatisticsTracker", "addNumber", "getMean", "getMedian", "getMode", "removeFirstAddedNumber", "getMean"] [[], [5], [], [], [], [], []]

› Output: [null, null, 5, 5, 5, null, 0]

💡 Note: Single element case: all statistics equal the element. After removal, empty tracker returns 0 for mean.

Visualization

Tap to expand

Understanding the Visualization

Data Ingestion

New stock prices arrive continuously and must be stored in processing order

Data Expiration

Old prices expire (FIFO) to maintain a sliding window of recent data

Real-time Analytics

Traders need instant mean, median, and mode calculations for decision making

Performance Optimization

Multiple data structures work together to provide sub-second response times

Key Takeaway

🎯 Key Insight: Instead of recalculating statistics from scratch each time, maintain multiple specialized data structures that can be updated incrementally. This transforms expensive O(n log n) operations into efficient O(log n) or O(1) operations.

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Add/Remove: O(log n) for sorted structure updates. Mean: O(1), Median: O(log n), Mode: O(1) amortized

⚡ Linearithmic

Space Complexity

O(n)

Additional space for frequency map and sorted structure, but still O(n) overall

⚡ Linearithmic Space

Constraints

1 ≤ number ≤ 10⁵
At most 10⁴ calls to addNumber and removeFirstAddedNumber
At most 10⁴ calls to getMean, getMedian, and getMode
removeFirstAddedNumber is called only when the array is non-empty
Statistics methods are called only when the array is non-empty

Asked in

G Google 32 a Amazon 28 f Meta 24 ⊞ Microsoft 18

The optimal solution uses multiple specialized data structures working together: a queue for FIFO removal, a frequency map for O(1) mode calculation, a sorted container for efficient median access, and a running sum for O(1) mean calculation. This approach achieves O(log n) time complexity for most operations while maintaining O(n) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recalculate Everything)	O(n log n)	O(n)	Store numbers in a queue and recalculate all statistics from scratch each time
Optimized Multi-Structure Approach	O(log n)	O(n)	Use specialized data structures: queue for order, frequency map for mode, sorted list for median, running sum for mean

Brute Force (Recalculate Everything) — Algorithm Steps

Use a queue/deque to maintain insertion order for FIFO removal
For getMean(): Sum all numbers and divide by count
For getMedian(): Sort all numbers and find middle element(s)
For getMode(): Count frequencies of all numbers and find most frequent (smallest if tie)

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Numbers

Numbers are stored in insertion order: [3, 1, 4, 1, 5]

Calculate Mean

Sum all numbers (14) and divide by count (5) = 2

Calculate Median

Sort [1, 1, 3, 4, 5] and find middle element = 3

Calculate Mode

Count frequencies: 1 appears 2 times (most frequent) = 1

Code -

solution.c — C

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

#define MAX_SIZE 10000

typedef struct {
    int numbers[MAX_SIZE];
    int front;
    int rear;
    int size;
} StatisticsTracker;

StatisticsTracker* statisticsTrackerCreate() {
    StatisticsTracker* tracker = (StatisticsTracker*)malloc(sizeof(StatisticsTracker));
    tracker->front = 0;
    tracker->rear = 0;
    tracker->size = 0;
    return tracker;
}

void statisticsTrackerAddNumber(StatisticsTracker* obj, int number) {
    obj->numbers[obj->rear] = number;
    obj->rear = (obj->rear + 1) % MAX_SIZE;
    obj->size++;
}

void statisticsTrackerRemoveFirstAddedNumber(StatisticsTracker* obj) {
    if (obj->size > 0) {
        obj->front = (obj->front + 1) % MAX_SIZE;
        obj->size--;
    }
}

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

int statisticsTrackerGetMean(StatisticsTracker* obj) {
    if (obj->size == 0) return 0;
    long long sum = 0;
    int idx = obj->front;
    for (int i = 0; i < obj->size; i++) {
        sum += obj->numbers[idx];
        idx = (idx + 1) % MAX_SIZE;
    }
    return sum / obj->size;
}

int statisticsTrackerGetMedian(StatisticsTracker* obj) {
    if (obj->size == 0) return 0;
    int sorted[MAX_SIZE];
    int idx = obj->front;
    for (int i = 0; i < obj->size; i++) {
        sorted[i] = obj->numbers[idx];
        idx = (idx + 1) % MAX_SIZE;
    }
    qsort(sorted, obj->size, sizeof(int), compare);
    if (obj->size % 2 == 0) {
        return sorted[obj->size / 2];
    } else {
        return sorted[obj->size / 2];
    }
}

int statisticsTrackerGetMode(StatisticsTracker* obj) {
    if (obj->size == 0) return 0;
    int freq[20001] = {0};  // assuming numbers in range [-10000, 10000]
    int idx = obj->front;
    int maxFreq = 0;
    for (int i = 0; i < obj->size; i++) {
        int num = obj->numbers[idx] + 10000;  // offset for negative numbers
        freq[num]++;
        if (freq[num] > maxFreq) {
            maxFreq = freq[num];
        }
        idx = (idx + 1) % MAX_SIZE;
    }
    for (int i = 0; i < 20001; i++) {
        if (freq[i] == maxFreq) {
            return i - 10000;
        }
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each statistics query requires O(n log n) sorting for median and O(n) scanning for mode/mean

⚡ Linearithmic

Space Complexity

O(n)

Only stores the actual numbers in the queue, no additional data structures

⚡ Linearithmic Space

Constraints

1 ≤ number ≤ 10⁵
At most 10⁴ calls to addNumber and removeFirstAddedNumber
At most 10⁴ calls to getMean, getMedian, and getMode
removeFirstAddedNumber is called only when the array is non-empty
Statistics methods are called only when the array is non-empty

38.4K Views

High Frequency

~25 min Avg. Time

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