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

Design an Array Statistics Tracker

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"]

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

💡 Note: Single element case: all statistics equal the element (5). After removal, tracker becomes empty.

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

Visualization

Tap to expand

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

✓ Brute Force (Recalculate Everything)

⏱️ Time: O(n log n) Space: O(n)

The simplest approach stores all numbers in insertion order (using a queue for FIFO removal) and recalculates mean, median, and mode from scratch for every query. This involves sorting for median and scanning for mode frequencies each time.

Optimized Multi-Structure Approach

⏱️ Time: O(log n) Space: O(n)

This optimal approach maintains multiple specialized data structures simultaneously. A queue handles FIFO removal, a frequency map tracks mode efficiently, a sorted container maintains order for median, and a running sum enables O(1) mean calculation. Each structure is updated incrementally.

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 <string.h>
#include <limits.h>

#define MAX_SIZE 10000

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

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

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

void statisticsTrackerRemoveFirstAddedNumber(StatisticsTracker* obj) {
    if (obj->size > 0) {
        for (int i = 0; i < obj->size - 1; i++) {
            obj->numbers[i] = obj->numbers[i + 1];
        }
        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;
    for (int i = 0; i < obj->size; i++) {
        sum += obj->numbers[i];
    }
    return sum / obj->size;
}

int statisticsTrackerGetMedian(StatisticsTracker* obj) {
    if (obj->size == 0) return 0;
    int sorted[MAX_SIZE];
    for (int i = 0; i < obj->size; i++) {
        sorted[i] = obj->numbers[i];
    }
    qsort(sorted, obj->size, sizeof(int), compare);
    int n = obj->size;
    if (n % 2 == 0) {
        return sorted[n / 2];  // larger of two middle values
    } else {
        return sorted[n / 2];
    }
}

int statisticsTrackerGetMode(StatisticsTracker* obj) {
    if (obj->size == 0) return 0;
    
    // Simple frequency counting
    int maxFreq = 0;
    int mode = INT_MAX;
    
    for (int i = 0; i < obj->size; i++) {
        int freq = 0;
        for (int j = 0; j < obj->size; j++) {
            if (obj->numbers[j] == obj->numbers[i]) {
                freq++;
            }
        }
        if (freq > maxFreq || (freq == maxFreq && obj->numbers[i] < mode)) {
            maxFreq = freq;
            mode = obj->numbers[i];
        }
    }
    return mode;
}

int main() {
    char operationsLine[1000];
    char valuesLine[2000];
    
    fgets(operationsLine, sizeof(operationsLine), stdin);
    fgets(valuesLine, sizeof(valuesLine), stdin);
    
    // Remove newline
    operationsLine[strcspn(operationsLine, "\n")] = 0;
    valuesLine[strcspn(valuesLine, "\n")] = 0;
    
    // Parse operations
    char* operations[100];
    int opCount = 0;
    char* token = strtok(operationsLine, ",");
    while (token != NULL) {
        operations[opCount++] = token;
        token = strtok(NULL, ",");
    }
    
    // Parse values array
    int values[100][10];
    int valueSizes[100];
    int valueCount = 0;
    
    int i = 1; // Skip first '['
    while (i < strlen(valuesLine) - 1) {
        if (valuesLine[i] == '[') {
            int j = i + 1;
            while (j < strlen(valuesLine) && valuesLine[j] != ']') {
                j++;
            }
            char inner[100];
            strncpy(inner, &valuesLine[i + 1], j - i - 1);
            inner[j - i - 1] = '\0';
            
            if (strlen(inner) > 0) {
                values[valueCount][0] = atoi(inner);
                valueSizes[valueCount] = 1;
            } else {
                valueSizes[valueCount] = 0;
            }
            valueCount++;
            i = j + 1;
        } else {
            i++;
        }
    }
    
    StatisticsTracker* tracker = NULL;
    int result = -1;
    int hasResult = 0;
    
    for (int idx = 0; idx < opCount; idx++) {
        if (strcmp(operations[idx], "StatisticsTracker") == 0) {
            tracker = statisticsTrackerCreate();
        } else if (strcmp(operations[idx], "addNumber") == 0) {
            statisticsTrackerAddNumber(tracker, values[idx][0]);
        } else if (strcmp(operations[idx], "removeFirstAddedNumber") == 0) {
            statisticsTrackerRemoveFirstAddedNumber(tracker);
        } else if (strcmp(operations[idx], "getMean") == 0) {
            result = statisticsTrackerGetMean(tracker);
            hasResult = 1;
        } else if (strcmp(operations[idx], "getMedian") == 0) {
            result = statisticsTrackerGetMedian(tracker);
            hasResult = 1;
        } else if (strcmp(operations[idx], "getMode") == 0) {
            result = statisticsTrackerGetMode(tracker);
            hasResult = 1;
        }
    }
    
    if (hasResult) {
        printf("%d\n", result);
    }
    
    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

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

Design an Array Statistics Tracker

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Recalculate Everything) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler