Finding MK Average

Finding MK Average - Problem

You are given two integers, m and k, and a stream of integers. You need to implement a data structure that calculates the MKAverage for the stream.

The MKAverage can be calculated using these steps:

If the number of elements in the stream is less than m, the MKAverage is -1.
Otherwise, copy the last m elements of the stream to a separate container.
Remove the smallest k elements and the largest k elements from the container.
Calculate the average value for the remaining elements, rounded down to the nearest integer.

Implement the MKAverage class:

MKAverage(int m, int k) Initializes the MKAverage object with an empty stream and the two integers m and k.
void addElement(int num) Inserts a new element num into the stream.
int calculateMKAverage() Calculates and returns the MKAverage for the current stream rounded down to the nearest integer.

Input & Output

Example 1 — Basic Operations

$ Input: MKAverage(3, 1), addElement(3), addElement(1), addElement(10), addElement(5), addElement(5), addElement(5), calculateMKAverage()

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

💡 Note: After adding [3,1,10,5,5,5], last 3 elements are [5,5,5]. Remove 1 smallest and 1 largest: middle element is 5, so average is 5.

Example 2 — Insufficient Elements

$ Input: MKAverage(3, 1), addElement(3), addElement(1), calculateMKAverage()

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

💡 Note: Only 2 elements in stream, but need m=3 elements minimum, so return -1.

Example 3 — Different Values

$ Input: MKAverage(5, 2), addElement(3), addElement(1), addElement(12), addElement(5), addElement(3), addElement(4), calculateMKAverage()

› Output: [null, null, null, null, null, null, null, 4]

💡 Note: Last 5 elements: [1,12,5,3,4]. Sorted: [1,3,4,5,12]. Remove 2 smallest [1,3] and 2 largest [5,12]. Middle: [4]. Average = 4.

Constraints

1 ≤ m ≤ 10⁵
1 ≤ k*2 < m
1 ≤ num ≤ 10⁵
At most 10⁵ calls to addElement and calculateMKAverage

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8 Apple 6

The key insight is to maintain a sliding window of the last m elements while keeping them sorted for efficient range queries. The optimal approach uses balanced data structures like TreeMap or multiset to achieve O(log m) time complexity per operation. Time: O(log m), Space: O(m).

Common Approaches

✓ Binary Search

⏱️ Time: N/A Space: N/A

Brute Force - Sort Every Time

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

Maintain a list of all stream elements. For each calculateMKAverage call, extract the last m elements, sort them, remove k smallest and k largest, then calculate the average.

Optimized with Balanced Data Structures

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

Maintain a sliding window of the last m elements using a deque, and use a balanced binary search tree (multiset) to keep elements sorted. This allows efficient insertion, deletion, and range sum queries.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* fruits, int* baskets, int n) {
    bool* used = (bool*)calloc(n, sizeof(bool));
    int unplaced = 0;
    
    for (int i = 0; i < n; i++) {
        int fruitQuantity = fruits[i];
        bool placed = false;
        
        // Find leftmost available basket with enough capacity
        for (int j = 0; j < n; j++) {
            if (!used[j] && baskets[j] >= fruitQuantity) {
                used[j] = true;
                placed = true;
                break;
            }
        }
        
        if (!placed) {
            unplaced++;
        }
    }
    
    free(used);
    return unplaced;
}

int parseNumbers(char* line, int* arr) {
    int count = 0;
    char* ptr = line;
    
    // Skip opening bracket
    while (*ptr && (*ptr == '[' || *ptr == ' ')) ptr++;
    
    while (*ptr && *ptr != ']' && *ptr != '\n') {
        if (*ptr >= '0' && *ptr <= '9') {
            arr[count++] = strtol(ptr, &ptr, 10);
        } else {
            ptr++;
        }
    }
    
    return count;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int fruits[100], baskets[100];
    int n = parseNumbers(line, fruits);
    
    fgets(line, sizeof(line), stdin);
    int m = parseNumbers(line, baskets);
    
    int result = solution(fruits, baskets, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~45 min Avg. Time

892 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