Skip to content

1619. Mean of Array After Removing Some Elements

SourceBiweekly Contest 37 Q1DifficultyEasyRating1374

Description

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.

 

Example 1:

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
Explanation: After erasing the minimum and the maximum values of this array, all elements are equal to 2, so the mean is 2.

Example 2:

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

Example 3:

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,3,4]
Output: 4.77778

 

Constraints:

  • 20 <= arr.length <= 1000
  • arr.length is a multiple of 20.
  • 0 <= arr[i] <= 105

Solutions

Solution 1

Thinking

We drop the lowest and highest \(5\%\) and average the rest. The length is a multiple of \(20\) and small enough that sorting then slicing is enough.

After sorting, discard \(0.05n\) elements at each end, average the middle, and round to five decimals.

1
2
3
4
5
6
7
class Solution:
    def trimMean(self, arr: List[int]) -> float:
        n = len(arr)
        start, end = int(n * 0.05), int(n * 0.95)
        arr.sort()
        t = arr[start:end]
        return round(sum(t) / len(t), 5)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
class Solution {
    public double trimMean(int[] arr) {
        Arrays.sort(arr);
        int n = arr.length;
        double s = 0;
        for (int start = (int) (n * 0.05), i = start; i < n - start; ++i) {
            s += arr[i];
        }
        return s / (n * 0.9);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
class Solution {
public:
    double trimMean(vector<int>& arr) {
        sort(arr.begin(), arr.end());
        int n = arr.size();
        double s = 0;
        for (int start = (int) (n * 0.05), i = start; i < n - start; ++i)
            s += arr[i];
        return s / (n * 0.9);
    }
};

1
2
3
4
5
6
7
8
9
func trimMean(arr []int) float64 {
    sort.Ints(arr)
    n := len(arr)
    sum := 0.0
    for i := n / 20; i < n-n/20; i++ {
        sum += float64(arr[i])
    }
    return sum / (float64(n) * 0.9)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
function trimMean(arr: number[]): number {
    arr.sort((a, b) => a - b);
    let n = arr.length,
        rmLen = n * 0.05;
    let sum = 0;
    for (let i = rmLen; i < n - rmLen; i++) {
        sum += arr[i];
    }
    return sum / (n * 0.9);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
impl Solution {
    pub fn trim_mean(mut arr: Vec<i32>) -> f64 {
        arr.sort();
        let n = arr.len();
        let count = ((n as f64) * 0.05).floor() as usize;
        let mut sum = 0;
        for i in count..n - count {
            sum += arr[i];
        }
        (sum as f64) / ((n as f64) * 0.9)
    }
}

Comments