Moving Average from Data Stream

Moving Average from Data Stream - Problem

Design a class to calculate the moving average of a stream of integers over a sliding window of a specified size.

Implement the MovingAverage class:

MovingAverage(int size) - Initializes the object with the size of the window.
double next(int val) - Returns the moving average of the last size values of the stream.

The moving average is calculated by taking the sum of all values in the current window and dividing by the number of values in the window.

Input & Output

Example 1 — Basic Moving Average

$ Input: operations = [["MovingAverage",3],["next",1],["next",10],["next",3],["next",5]]

› Output: [null,1.0,5.5,4.666666666666667,6.0]

💡 Note: Initialize with window size 3. Add 1 → avg=1.0, add 10 → avg=(1+10)/2=5.5, add 3 → avg=(1+10+3)/3=4.67, add 5 → avg=(10+3+5)/3=6.0

Example 2 — Single Element Window

$ Input: operations = [["MovingAverage",1],["next",2],["next",8]]

› Output: [null,2.0,8.0]

💡 Note: Window size 1 means only current value matters. Add 2 → avg=2.0, add 8 → avg=8.0

Example 3 — Larger Window

$ Input: operations = [["MovingAverage",5],["next",1],["next",2],["next",3]]

› Output: [null,1.0,1.5,2.0]

💡 Note: Window size 5 but only 3 values added. Add 1 → avg=1.0, add 2 → avg=(1+2)/2=1.5, add 3 → avg=(1+2+3)/3=2.0

Constraints

1 ≤ size ≤ 1000
-10⁵ ≤ val ≤ 10⁵
At most 10⁴ calls to next

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 f Facebook 12 M Microsoft 15

The key insight is to maintain a sliding window using a queue and keep a running sum to avoid recalculating the total each time. The optimal approach uses a queue to store exactly the window size elements and tracks the running sum, achieving O(1) time per operation. Time: O(1), Space: O(k) where k is window size.

Common Approaches

✓ Brute Force - Store All Values

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

Keep all incoming values in a list and for each new value, take the last 'size' values, sum them up, and divide by the count. Simple but inefficient as we recalculate everything.

Optimized - Queue with Running Sum

⏱️ Time: O(1) Space: O(k)

Maintain a queue of exactly 'size' elements and keep a running sum. When adding a new value, if queue is full, remove the oldest value from sum, add new value to sum and queue. This avoids recalculating the entire sum each time.

Brute Force - Store All Values — Algorithm Steps

Store each new value in a list
Take the last 'size' values from the list
Sum all values in the window and divide by count

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Value

Add new value to growing list

Extract Window

Take last 3 values from list

Calculate

Sum window values and divide by count

Code -

solution.c — C

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

typedef struct {
    int size;
    int* values;
    int count;
    int capacity;
} MovingAverage;

static char line[10000];
static char operations[100][2][50];
static double results[100];
static int is_null[100];

MovingAverage* movingAverageCreate(int size) {
    MovingAverage* ma = (MovingAverage*)malloc(sizeof(MovingAverage));
    ma->size = size;
    ma->values = (int*)malloc(1000 * sizeof(int));
    ma->count = 0;
    ma->capacity = 1000;
    return ma;
}

double movingAverageNext(MovingAverage* ma, int val) {
    ma->values[ma->count] = val;
    ma->count++;
    
    // Take last size values
    int start = (ma->count > ma->size) ? ma->count - ma->size : 0;
    int sum = 0;
    int windowSize = 0;
    for (int i = start; i < ma->count; i++) {
        sum += ma->values[i];
        windowSize++;
    }
    return (double)sum / windowSize;
}

int main() {
    fgets(line, sizeof(line), stdin);
    
    // Parse operations from JSON
    int op_count = 0;
    char* p = line;
    
    // Skip initial whitespace and find first '['
    while (*p && *p != '[') p++;
    if (*p) p++;
    
    while (*p) {
        // Find start of inner array
        while (*p && *p != '[') p++;
        if (!*p) break;
        p++; // Skip '['
        
        // Find operation name
        while (*p && *p != '"') p++;
        if (!*p) break;
        p++; // Skip opening quote
        
        char* op_start = p;
        while (*p && *p != '"') p++;
        if (!*p) break;
        
        int op_len = p - op_start;
        strncpy(operations[op_count][0], op_start, op_len);
        operations[op_count][0][op_len] = '\0';
        p++; // Skip closing quote
        
        // Find comma and value
        while (*p && *p != ',') p++;
        if (*p) {
            p++; // Skip comma
            while (*p && (*p == ' ' || *p == '\t')) p++;
            
            char* val_start = p;
            while (*p && *p != ']') p++;
            if (*p) {
                int val_len = p - val_start;
                strncpy(operations[op_count][1], val_start, val_len);
                operations[op_count][1][val_len] = '\0';
            }
        }
        
        op_count++;
        
        // Skip to next operation
        while (*p && *p != ']') p++;
        if (*p) p++; // Skip ']'
        while (*p && (*p == ',' || *p == ' ' || *p == '\t')) p++;
    }
    
    MovingAverage* ma = NULL;
    int result_count = 0;
    
    for (int i = 0; i < op_count; i++) {
        if (strcmp(operations[i][0], "MovingAverage") == 0) {
            ma = movingAverageCreate(atoi(operations[i][1]));
            is_null[result_count] = 1;
            result_count++;
        } else if (strcmp(operations[i][0], "next") == 0) {
            results[result_count] = movingAverageNext(ma, atoi(operations[i][1]));
            is_null[result_count] = 0;
            result_count++;
        }
    }
    
    printf("[");
    for (int i = 0; i < result_count; i++) {
        if (is_null[i]) {
            printf("null");
        } else {
            if (results[i] == (int)results[i]) {
                printf("%.1f", results[i]);
            } else {
                printf("%.16g", results[i]);
            }
        }
        if (i < result_count - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k)

Each next() call processes k values in the window to calculate sum

✓ Linear Growth

Space Complexity

O(n)

Stores all n values received, even those outside the window

✓ Linear Space

32.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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Store All Values — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler