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

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

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

Understanding the Visualization

Input Array

Given integer array with various values

Sort and Remove

Sort array, remove 5% smallest and 5% largest elements

Calculate Mean

Sum remaining elements and divide by count

Key Takeaway

🎯 Key Insight: Sort first to easily identify and remove extreme values, then calculate mean of the stable middle range

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

Approach	Time	Space	Notes
✓ Brute Force - Manual Calculation	O(n log n)	O(1)	Sort array, manually find and remove elements, then calculate mean
Sort and Slice	O(n log n)	O(1)	Sort array then slice out the middle portion for clean calculation

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;
}

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("%f\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