Average Salary Excluding the Minimum and Maximum Salary

Average Salary Excluding the Minimum and Maximum Salary - Problem

Array Sorting Easy

You're working as a payroll analyst for a company and need to calculate the fair average salary for performance evaluation purposes.

Given an array of unique integers salary where salary[i] represents the salary of the i-th employee, you need to:

🚫 Exclude the minimum salary (outlier - might be intern/part-time)
🚫 Exclude the maximum salary (outlier - might be executive/exceptional case)
📊 Calculate the average of the remaining salaries

This approach helps eliminate extreme outliers that might skew the average compensation analysis.

Return: The average salary after removing the minimum and maximum values.

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

Input & Output

example_1.py — Basic Case

$ Input: salary = [4000,3000,1000,2000]

› Output: 2500.0

💡 Note: Minimum salary is 1000, maximum salary is 4000. After excluding them, we have [3000, 2000]. Average = (3000 + 2000) / 2 = 2500.0

example_2.py — Higher Salaries

$ Input: salary = [1000,2000,3000]

› Output: 2000.0

💡 Note: Minimum is 1000, maximum is 3000. After exclusion: [2000]. Average = 2000 / 1 = 2000.0

example_3.py — Larger Dataset

$ Input: salary = [6000,5000,4000,3000,2000,1000]

› Output: 3500.0

💡 Note: Min=1000, Max=6000. Remaining: [5000,4000,3000,2000]. Average = (5000+4000+3000+2000) / 4 = 3500.0

Constraints

3 ≤ salary.length ≤ 100
1000 ≤ salary[i] ≤ 10⁶
All the integers of salary are unique
Answers within 10^-5 of the actual answer will be accepted

Visualization

Tap to expand

Total Sum: $1,000 + $2,000 + $3,000 + $4,000 = $10,0002. Remove Outliers: $10,000 - $1,000 (min) - $4,000 (max) = $5,0003. Valid Employees: 4 total - 2 outliers = 2 employees4. Fair Average: $5,000 ÷ 2 = $2,500💡 This represents the typical salary range, excluding extreme cases

Understanding the Visualization

Data Collection

Gather all employee salary data into an array

Outlier Detection

Identify minimum and maximum salaries as outliers

Fair Average

Calculate average excluding the extreme values

Key Takeaway

🎯 Key Insight: By eliminating salary outliers (minimum and maximum), we get a more representative average that better reflects typical employee compensation levels.

Asked in

a Amazon 35 ⊞ Microsoft 28 G Google 22 Apple 18

The optimal solution uses a single-pass approach to simultaneously track the minimum salary, maximum salary, and total sum. This achieves O(n) time complexity with O(1) space complexity, making it the most efficient approach for calculating the fair average salary.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Passes)	O(n)	O(1)	Find min and max separately, then calculate sum excluding them
One-Pass Optimal Solution	O(n)	O(1)	Track min, max, and sum simultaneously in a single pass

Brute Force (Multiple Passes) — Algorithm Steps

First pass: Find the minimum salary
Second pass: Find the maximum salary
Third pass: Sum all salaries except min and max
Calculate average by dividing sum by (n-2)

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Minimum

Scan array to find the lowest salary

Find Maximum

Scan array again to find the highest salary

Calculate Sum

Third scan to sum all salaries except min and max

Code -

solution.c — C

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

double averageSalary(int* salary, int salarySize) {
    // First pass: find minimum
    int minSalary = salary[0];
    for (int i = 0; i < salarySize; i++) {
        if (salary[i] < minSalary) {
            minSalary = salary[i];
        }
    }
    
    // Second pass: find maximum
    int maxSalary = salary[0];
    for (int i = 0; i < salarySize; i++) {
        if (salary[i] > maxSalary) {
            maxSalary = salary[i];
        }
    }
    
    // Third pass: sum excluding min and max
    int total = 0;
    for (int i = 0; i < salarySize; i++) {
        if (salary[i] != minSalary && salary[i] != maxSalary) {
            total += salary[i];
        }
    }
    
    return (double) total / (salarySize - 2);
}

int main() {
    int salary[] = {4000, 3000, 1000, 2000};
    int size = sizeof(salary) / sizeof(salary[0]);
    printf("%.5f\n", averageSalary(salary, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three separate passes through the array: O(n) + O(n) + O(n) = O(3n) = O(n)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to store min, max, and sum values

✓ Linear Space

56.4K Views

Medium Frequency

~8 min Avg. Time

1.8K 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 (Multiple Passes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler