Minimum Average of Smallest and Largest Elements

Minimum Average of Smallest and Largest Elements - Problem

You have an array of floating point numbers averages which is initially empty. You are given an array nums of n integers where n is even.

You repeat the following procedure n / 2 times:

Remove the smallest element, minElement, and the largest element maxElement, from nums.
Add (minElement + maxElement) / 2 to averages.

Return the minimum element in averages.

Input & Output

Example 1 — Basic Case

$ Input: nums = [7,8,3,4,15,13,4,1]

› Output: 5.5

💡 Note: After sorting: [1,3,4,4,7,8,13,15]. Pairs: (1,15)→8.0, (3,13)→8.0, (4,8)→6.0, (4,7)→5.5. Minimum average is 5.5.

Example 2 — Even Distribution

$ Input: nums = [1,9,8,2,3,7]

› Output: 5.0

💡 Note: After sorting: [1,2,3,7,8,9]. Pairs: (1,9)→5.0, (2,8)→5.0, (3,7)→5.0. All averages are 5.0, so minimum is 5.0.

Example 3 — Minimum Size

$ Input: nums = [1,2]

› Output: 1.5

💡 Note: Only one pair possible: (1,2) with average (1+2)/2 = 1.5.

Constraints

2 ≤ nums.length ≤ 10⁵
nums.length is even
1 ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8

The key insight is to sort the array first, then use two pointers to efficiently pair minimum and maximum elements. The optimal approach sorts once O(n log n) then tracks the minimum average directly without extra storage. Time: O(n log n), Space: O(1).

Common Approaches

✓ Brute Force - Repeated Min/Max Finding

⏱️ Time: O(n³) Space: O(n)

For each iteration, scan the entire array to find minimum and maximum elements, remove them, calculate their average, and repeat until array is empty.

Optimized - Direct Minimum Tracking

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

Sort the array and use two pointers, but instead of storing all averages, directly track the minimum average as we compute each pair.

Sort First - Two Pointers

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

Sort the array first, then use two pointers from the beginning and end to pair the smallest with largest elements iteratively.

Brute Force - Repeated Min/Max Finding — Algorithm Steps

Step 1: Scan array to find minimum element
Step 2: Scan array to find maximum element
Step 3: Remove both elements and calculate average
Step 4: Repeat until array is empty
Step 5: Return minimum average

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan for Min/Max

Linear search through entire array

Remove Elements

Remove found min and max

Calculate Average

Store (min + max) / 2

Code -

solution.c — C

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

double solution(int* nums, int numsSize) {
    double* averages = (double*)malloc((numsSize / 2) * sizeof(double));
    int* tempNums = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        tempNums[i] = nums[i];
    }
    
    int avgCount = 0;
    int currentSize = numsSize;
    
    while (currentSize > 0) {
        // Find minimum
        int minVal = tempNums[0];
        int minIdx = 0;
        for (int i = 1; i < currentSize; i++) {
            if (tempNums[i] < minVal) {
                minVal = tempNums[i];
                minIdx = i;
            }
        }
        // Remove minimum
        for (int i = minIdx; i < currentSize - 1; i++) {
            tempNums[i] = tempNums[i + 1];
        }
        currentSize--;
        
        // Find maximum
        int maxVal = tempNums[0];
        int maxIdx = 0;
        for (int i = 1; i < currentSize; i++) {
            if (tempNums[i] > maxVal) {
                maxVal = tempNums[i];
                maxIdx = i;
            }
        }
        // Remove maximum
        for (int i = maxIdx; i < currentSize - 1; i++) {
            tempNums[i] = tempNums[i + 1];
        }
        currentSize--;
        
        // Calculate average
        double avg = (minVal + maxVal) / 2.0;
        averages[avgCount++] = avg;
    }
    
    // Find minimum average
    double minAvg = averages[0];
    for (int i = 1; i < avgCount; i++) {
        if (averages[i] < minAvg) {
            minAvg = averages[i];
        }
    }
    
    free(averages);
    free(tempNums);
    return minAvg;
}

int main() {
    // Simple parsing for array input
    int nums[1000];
    int size = 0;
    
    scanf("%*c"); // Skip '['
    while (1) {
        int num;
        scanf("%d", &num);
        nums[size++] = num;
        
        char c;
        scanf("%c", &c);
        if (c == ']') break;
    }
    
    double result = solution(nums, size);
    printf("%f\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

n/2 iterations, each requiring O(n) to find min, O(n) to find max, O(n) to remove elements

⚡ Linearithmic

Space Complexity

O(n)

Storing averages array and working with input array modifications

✓ Linear Space

8.5K Views

Medium Frequency

~15 min Avg. Time

234 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 - Repeated Min/Max Finding — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler