Mean of Array After Removing Some Elements

Mean of Array After Removing Some Elements - Problem

Array Sorting Easy

Given an integer array arr, you need to calculate the trimmed mean by removing outliers from both ends.

Specifically, you must:

Remove the smallest 5% of elements
Remove the largest 5% of elements
Calculate and return the mean (average) of the remaining elements

This technique is commonly used in statistics to reduce the impact of outliers on the final result, making it more representative of the central tendency.

Note: Answers within 10^-5 of the actual answer will be considered correct.

Input & Output

example_1.py — Basic Case

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

› Output: 5.5

💡 Note: Array length is 10, so we remove 5% from each end (0.5 elements, rounded to 1). After sorting: [1,2,3,4,5,6,7,8,9,10]. Remove first element (1) and last element (10). Remaining elements: [2,3,4,5,6,7,8,9]. Sum = 44, Count = 8, Mean = 44/8 = 5.5

example_2.py — Larger Array

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

› Output: 4.0

💡 Note: Array length is 20, so we remove 5% from each end (1 element each). After sorting: [0,0,0,0,1,2,2,2,3,5,5,5,5,6,6,7,7,8,8,10]. Remove first element (0) and last element (10). Remaining 18 elements sum to 72. Mean = 72/18 = 4.0

example_3.py — Edge Case

$ Input: arr = [9,7,8,7,7,8,4,4,6,8,8]

› Output: 7.18182

💡 Note: Array length is 11, so we remove 5% from each end (0.55 elements, rounded to 0). No elements are removed. All elements are included in the mean calculation. Sum = 79, Count = 11, Mean = 79/11 ≈ 7.18182

Visualization

Tap to expand

Understanding the Visualization

Collect All Scores

Gather all the judge scores (array elements)

Arrange in Order

Sort scores from lowest to highest

Remove Extremes

Remove the lowest 5% and highest 5% of scores

Calculate Fair Average

Compute the mean of the remaining middle scores

Key Takeaway

🎯 Key Insight: Sorting allows us to easily identify and remove outliers, creating a more robust average that better represents the central tendency of the data.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Finding min/max requires O(n) time, and we do this O(n) times in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

20 ≤ arr.length ≤ 1000
arr.length is a multiple of 20
0 ≤ arr[i] ≤ 10⁵
At most 1% of test cases will have extreme values

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 Apple 18

The optimal approach is to sort the array and then calculate the mean of the middle elements. This eliminates the need for repeated min/max finding and achieves O(n log n) time complexity. The key insight is that sorting once allows us to easily identify and exclude the extreme values (outliers) from both ends.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Find Min/Max Repeatedly)	O(n²)	O(1)	Repeatedly find and remove minimum and maximum elements
Sorting + Direct Removal (Optimal)	O(n log n)	O(log n)	Sort array and calculate mean of middle elements

Brute Force (Find Min/Max Repeatedly) — Algorithm Steps

Calculate how many elements to remove from each end (5% of array length)
For each element to remove, find the minimum in the array and remove it
For each element to remove, find the maximum in the array and remove it
Calculate the sum of remaining elements
Return the mean by dividing sum by count of remaining elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with the original array

Find Minimum

Scan entire array to find minimum value

Remove Minimum

Remove the minimum value from array

Repeat Process

Repeat for all elements to be removed

Calculate Mean

Sum remaining elements and divide by count

Code -

solution.c — C

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

double trimMean(int* arr, int n) {
    int removeCount = n / 20; // 5% from each end
    
    // Create a copy
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        nums[i] = arr[i];
    }
    int size = n;
    
    // Remove smallest elements
    for (int i = 0; i < removeCount; i++) {
        int minIdx = 0;
        for (int j = 1; j < size; j++) {
            if (nums[j] < nums[minIdx]) {
                minIdx = j;
            }
        }
        // Shift elements to remove minimum
        for (int k = minIdx; k < size - 1; k++) {
            nums[k] = nums[k + 1];
        }
        size--;
    }
    
    // Remove largest elements
    for (int i = 0; i < removeCount; i++) {
        int maxIdx = 0;
        for (int j = 1; j < size; j++) {
            if (nums[j] > nums[maxIdx]) {
                maxIdx = j;
            }
        }
        // Shift elements to remove maximum
        for (int k = maxIdx; k < size - 1; k++) {
            nums[k] = nums[k + 1];
        }
        size--;
    }
    
    long long sum = 0;
    for (int i = 0; i < size; i++) {
        sum += nums[i];
    }
    
    free(nums);
    return (double)sum / size;
}

int main() {
    // Simple parsing for demonstration
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    printf("%.5f\n", trimMean(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Finding min/max requires O(n) time, and we do this O(n) times in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

20 ≤ arr.length ≤ 1000
arr.length is a multiple of 20
0 ≤ arr[i] ≤ 10⁵
At most 1% of test cases will have extreme values

24.7K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Find Min/Max Repeatedly) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler