Moving Average from Data Stream - Practice Coding Problems

Moving Average from Data Stream - Problem

You're given a stream of integers and need to efficiently calculate the moving average of all integers within a sliding window of fixed size. This is a common problem in real-time data processing, financial applications, and signal processing.

Design and implement the MovingAverage class with the following methods:

MovingAverage(int size): Initialize the object with the window size
double next(int val): Add the new value to the stream and return the moving average of the last size values

Example: If window size is 3 and you receive values [1, 10, 3, 5], the moving averages would be:

After 1: 1.0 (only one value)
After 10: 5.5 (average of [1, 10])
After 3: 4.67 (average of [1, 10, 3])
After 5: 6.0 (average of [10, 3, 5] - sliding window)

Input & Output

example_1.py — Basic Window Operations

$ Input: MovingAverage(3) .next(1) → 1.0 .next(10) → 5.5 .next(3) → 4.666... .next(5) → 6.0

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

💡 Note: Window size is 3. After adding 1: avg of [1] = 1.0. After 10: avg of [1,10] = 5.5. After 3: avg of [1,10,3] = 4.67. After 5: window slides to [10,3,5], avg = 6.0

example_2.py — Single Element Window

$ Input: MovingAverage(1) .next(7) → 7.0 .next(3) → 3.0 .next(9) → 9.0

› Output: [7.0, 3.0, 9.0]

💡 Note: Window size is 1, so each value becomes the complete window and the average is just that value itself

example_3.py — Large Window

$ Input: MovingAverage(5) .next(1) → 1.0 .next(2) → 1.5 .next(3) → 2.0 .next(4) → 2.5 .next(5) → 3.0 .next(6) → 4.0

› Output: [1.0, 1.5, 2.0, 2.5, 3.0, 4.0]

💡 Note: Window fills up gradually. First 5 calls fill the window [1,2,3,4,5] with avg 3.0. The 6th call slides window to [2,3,4,5,6] with avg 4.0

Visualization

Tap to expand

Understanding the Visualization

Initialize Window

Create a queue (like a conveyor belt) that holds exactly 3 numbers and a running sum counter

Add First Numbers

Add 1, then 10. Queue grows: [1] → [1,10]. Running sum: 1 → 11. Averages: 1.0 → 5.5

Fill the Window

Add 3. Queue becomes [1,10,3]. Running sum: 14. Average: 4.67. Window is now full!

Sliding Window

Add 5. Remove 1 (oldest), add 5 (newest). Queue: [10,3,5]. Sum: 18-1=18. Average: 6.0

Key Takeaway

🎯 Key Insight: Use a queue to maintain the exact window elements and a running sum for O(1) average calculation. When adding: sum += new_val, when removing: sum -= old_val.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each next() operation takes constant time - just add/remove and divide

✓ Linear Growth

Space Complexity

O(size)

Queue stores at most 'size' elements for the sliding window

✓ Linear Space

Constraints

1 ≤ size ≤ 1000
-10⁵ ≤ val ≤ 10⁵
At most 10⁴ calls will be made to next
Window size is fixed after initialization

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28 Apple 25 B Bloomberg 22

The optimal solution uses a queue (deque) to maintain the sliding window and a running sum for O(1) time complexity. When a new value arrives, add it to both the queue and running sum. If the queue exceeds the window size, remove the oldest element from both. The average is simply running_sum / queue_size.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recalculate Every Time)	O(n)	O(n)	Store all values and recalculate the entire average for each new value
Queue with Running Sum (Optimal)	O(1)	O(size)	Use a queue to maintain the sliding window and keep a running sum for O(1) operations

Brute Force (Recalculate Every Time) — Algorithm Steps

Store all incoming values in a list
For each next() call, take the last 'size' elements
Sum all elements in the window
Divide by the number of elements to get average

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Value 1

Store 1, calculate sum of [1] = 1, average = 1.0

Add Value 10

Store 10, calculate sum of [1,10] = 11, average = 5.5

Add Value 3

Store 3, calculate sum of [1,10,3] = 14, average = 4.67

Add Value 5

Store 5, calculate sum of [10,3,5] (window slides) = 18, average = 6.0

Code -

solution.c — C

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

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

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

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

void movingAverageFree(MovingAverage* ma) {
    free(ma->values);
    free(ma);
}

int main() {
    MovingAverage* ma = movingAverageCreate(3);
    printf("%.1f\n", movingAverageNext(ma, 1));   // 1.0
    printf("%.1f\n", movingAverageNext(ma, 10));  // 5.5
    printf("%.6f\n", movingAverageNext(ma, 3));   // 4.666667
    printf("%.1f\n", movingAverageNext(ma, 5));   // 6.0
    movingAverageFree(ma);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each next() operation takes O(size) time to sum the window elements

✓ Linear Growth

Space Complexity

O(n)

Store all values that have been added to the stream

⚡ Linearithmic Space

Constraints

1 ≤ size ≤ 1000
-10⁵ ≤ val ≤ 10⁵
At most 10⁴ calls will be made to next
Window size is fixed after initialization

89.2K Views

High Frequency

~15 min Avg. Time

1.8K 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 (Recalculate Every Time) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler