Mean of Array After Removing Some Elements

Mean of Array After Removing Some Elements - Problem

Array Sorting Easy

Given an integer array arr, return the mean of the remaining integers after removing the smallest 5% and the largest 5% of the elements.

Answers within 10^-5 of the actual answer will be considered accepted.

Note: The percentage is calculated based on the original array length. For example, if the array has 20 elements, remove the smallest element (5% of 20 = 1) and the largest element.

Input & Output

Example 1 — Basic Case

$ Input: arr = [1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3]

› Output: 2.00000

💡 Note: Array has 20 elements. Remove 5% = 1 element from each end. Remove smallest (1) and largest (3). Remaining 18 elements are all 2s, so mean = 2.0

Example 2 — Different Values

$ Input: arr = [6,2,7,5,1,2,10,8,5,8,2,6]

› Output: 5.16667

💡 Note: 12 elements, remove 5% = 0.6 → 0 elements from each end. Keep all elements. Sum = 62, mean = 62/12 = 5.16667

Example 3 — Larger Array

$ Input: arr = [6,0,7,0,7,5,7,8,3,4,0,7,8,1,6,8,1,1,2,4,8,1,9,5,4,3,8,5,10,8,6,6,1,0,6,10,8,2,8,4,1,4,1,8,8,8,9,0,7,4,4,4,3,8,5,5,4,1,3,1]

› Output: 4.77778

💡 Note: 60 elements, remove 5% = 3 elements from each end. After sorting, remove 3 smallest and 3 largest values. Calculate mean of remaining 54 elements.

Constraints

20 ≤ arr.length ≤ 1000
arr.length is a multiple of 20
0 ≤ arr[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to sort the array first, then remove the extreme values (5% from each end) and calculate the mean of the remaining elements. The optimal approach is to sort and slice - after sorting, we calculate how many elements to remove from each end, then extract the middle portion and compute its mean. Time: O(n log n) for sorting, Space: O(1) using in-place operations.

Common Approaches

✓ Brute Force - Manual Calculation

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

Sort the entire array, calculate how many elements to remove from each end, iterate through remaining elements to sum them up, then divide by count.

Sort and Slice

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

Sort the array first, calculate the exact indices to remove from both ends, then use array slicing to get the middle portion and calculate its mean directly.

Brute Force - Manual Calculation — Algorithm Steps

Step 1: Sort the array in ascending order
Step 2: Calculate removal count (5% from each side)
Step 3: Loop through middle elements and sum them
Step 4: Divide sum by remaining count to get mean

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Arrange elements in ascending order

Remove Extremes

Calculate 5% from each end to remove

Sum Middle

Add up remaining elements and divide by count

Code -

solution.c — C

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

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

double solution(int* arr, int n) {
    qsort(arr, n, sizeof(int), compare);
    int removeCount = (int)(n * 0.05);
    
    long long total = 0;
    int count = 0;
    for (int i = removeCount; i < n - removeCount; i++) {
        total += arr[i];
        count++;
    }
    
    return (double)total / count;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int arr[1000];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            arr[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    double result = solution(arr, n);
    printf("%.15lf\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), then single pass O(n) for summing

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables for counting and summing

✓ Linear Space

34.5K Views

Medium Frequency

~15 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Manual Calculation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler