Finding MK Average - Practice Coding Problems

Finding MK Average - Problem

Imagine you're monitoring a data stream and need to calculate a rolling filtered average that excludes outliers! 📊

You're given two integers m and k, and a continuous stream of integers. Your task is to implement the MKAverage data structure that:

🔄 Maintains a sliding window of the last m elements
✂️ Removes the k smallest and k largest values (outliers)
📈 Calculates the average of the remaining middle elements

Key Rules:

If fewer than m elements exist, return -1
After removing 2k outliers, average the remaining m - 2k elements
Round down the result to the nearest integer

Example: With m=3, k=1 and stream [3, 1, 5, 4, 6], when we have 3+ elements, we take the last 3 values, remove the min and max, then average what's left.

Input & Output

example_1.py — Basic Usage

$ Input: ["MKAverage", "addElement", "addElement", "calculateMKAverage", "addElement", "calculateMKAverage", "addElement", "calculateMKAverage", "addElement", "calculateMKAverage"] [[3, 1], [3], [1], [], [10], [], [5], [], [4], []]

› Output: [null, null, null, -1, null, 3, null, 5, null, 4]

💡 Note: MKAverage obj = new MKAverage(3, 1). We need 3 elements minimum, removing 1 smallest and 1 largest. First two adds give us only 2 elements, so -1. After adding 10, we have [3,1,10], sorted is [1,3,10], remove min(1) and max(10), average of [3] is 3. After adding 5, window is [1,10,5], sorted [1,5,10], remove 1 and 10, average of [5] is 5.

example_2.py — Sliding Window

$ Input: ["MKAverage", "addElement", "addElement", "addElement", "addElement", "calculateMKAverage", "addElement", "calculateMKAverage"] [[5, 2], [1], [2], [3], [4], [], [5], []]

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

💡 Note: m=5, k=2. Need 5 elements before calculating. After adding [1,2,3,4], we have only 4 elements, so -1. After adding 5, we have [1,2,3,4,5], remove 2 smallest (1,2) and 2 largest (4,5), middle element is [3], so average is 3. Wait, that's wrong - let me recalculate: remove 2 smallest and 2 largest leaves [3], so answer should be 3, not 2.

example_3.py — Larger Window

$ Input: ["MKAverage", "addElement", "addElement", "addElement", "addElement", "addElement", "calculateMKAverage"] [[5, 1], [10], [20], [30], [40], [50], []]

› Output: [null, null, null, null, null, null, 30]

💡 Note: m=5, k=1. After adding [10,20,30,40,50], we remove 1 smallest (10) and 1 largest (50), leaving middle elements [20,30,40]. Average = (20+30+40)/3 = 90/3 = 30.

Visualization

Tap to expand

Understanding the Visualization

Setup Scoreboards

Create three scoreboards: Low (k judges), Middle (m-2k judges), High (k judges)

New Score Arrives

When a new judge score comes in, determine which scoreboard it belongs to

Rebalance Boards

Move scores between boards to maintain the size constraints and ordering

Instant Average

Calculate the average from the middle scoreboard in O(1) time

Key Takeaway

🎯 Key Insight: By partitioning elements into three balanced buckets (small, middle, large), we achieve O(log m) operations with O(1) average calculation - perfect for high-frequency streaming data!

Time & Space Complexity

Time Complexity

⏱️

O(m log m)

Sorting m elements takes O(m log m) time for each calculateMKAverage call

⚡ Linearithmic

Space Complexity

O(m)

Storing the stream elements and temporary array for sorting

✓ Linear Space

Constraints

3 <= m <= 10⁵
1 <= k*2 < m
1 <= num <= 10⁵
At most 10⁵ calls will be made to addElement and calculateMKAverage
m is always odd and greater than 2*k

Asked in

N Netflix 25 A Amazon 18 G Google 15 M Meta 12

The optimal solution uses three balanced data structures (multisets) to maintain the k smallest, middle m-2k, and k largest elements separately. This enables O(log m) insertions and O(1) average calculations by keeping track of the middle elements' sum. The key insight is partitioning elements into three buckets and rebalancing them as the sliding window moves.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Sort Every Time)	O(m log m)	O(m)	Store elements in a queue and sort the last m elements for each calculation
Three Multisets (Optimal)	O(log m)	O(m)	Use three balanced data structures to maintain k smallest, middle, and k largest elements

Brute Force (Sort Every Time) — Algorithm Steps

Store all elements in a queue/deque
When calculating MK average, check if we have at least m elements
Extract the last m elements into a temporary array
Sort the temporary array
Remove first k and last k elements
Calculate sum of remaining elements and divide by (m-2k)
Return the floor of the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Maintain Stream

Keep the last m elements in a queue

Sort Window

Extract and sort the current window

Remove Outliers

Remove k smallest and k largest elements

Calculate Average

Average the remaining middle elements

Code -

solution.c — C

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

typedef struct {
    int m, k;
    int* stream;
    int size;
    int capacity;
} MKAverage;

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

MKAverage* mKAverageCreate(int m, int k) {
    MKAverage* obj = (MKAverage*)malloc(sizeof(MKAverage));
    obj->m = m;
    obj->k = k;
    obj->stream = (int*)malloc(m * sizeof(int));
    obj->size = 0;
    obj->capacity = m;
    return obj;
}

void mKAverageAddElement(MKAverage* obj, int num) {
    if (obj->size < obj->m) {
        obj->stream[obj->size++] = num;
    } else {
        // Shift elements left and add new element
        for (int i = 0; i < obj->m - 1; i++) {
            obj->stream[i] = obj->stream[i + 1];
        }
        obj->stream[obj->m - 1] = num;
    }
}

int mKAverageCalculateMKAverage(MKAverage* obj) {
    if (obj->size < obj->m) {
        return -1;
    }
    
    // Create copy and sort
    int* elements = (int*)malloc(obj->m * sizeof(int));
    for (int i = 0; i < obj->m; i++) {
        elements[i] = obj->stream[i];
    }
    qsort(elements, obj->m, sizeof(int), compare);
    
    // Calculate sum of middle elements
    long sum = 0;
    for (int i = obj->k; i < obj->m - obj->k; i++) {
        sum += elements[i];
    }
    
    free(elements);
    return sum / (obj->m - 2 * obj->k);
}

void mKAverageFree(MKAverage* obj) {
    free(obj->stream);
    free(obj);
}

// Example usage
int main() {
    MKAverage* mka = mKAverageCreate(3, 1);
    mKAverageAddElement(mka, 3);
    mKAverageAddElement(mka, 1);
    printf("%d\n", mKAverageCalculateMKAverage(mka)); // -1
    mKAverageAddElement(mka, 10);
    printf("%d\n", mKAverageCalculateMKAverage(mka)); // 3
    mKAverageFree(mka);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m log m)

Sorting m elements takes O(m log m) time for each calculateMKAverage call

⚡ Linearithmic

Space Complexity

O(m)

Storing the stream elements and temporary array for sorting

✓ Linear Space

Constraints

3 <= m <= 10⁵
1 <= k*2 < m
1 <= num <= 10⁵
At most 10⁵ calls will be made to addElement and calculateMKAverage
m is always odd and greater than 2*k

28.7K Views

Medium-High Frequency

~35 min Avg. Time

845 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 (Sort Every Time) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler