Minimum Average of Smallest and Largest Elements

Minimum Average of Smallest and Largest Elements - Problem

Imagine you're organizing a tournament elimination system! You have an array nums of n integers where n is even. Your task is to repeatedly pair up the smallest and largest remaining elements, calculate their average, and find the minimum average among all pairs.

The Process:

Start with an empty averages array
Repeat n/2 times:
- Find and remove the smallest element (minElement)
- Find and remove the largest element (maxElement)
- Calculate (minElement + maxElement) / 2.0 and add to averages
Return the minimum value in the averages array

Goal: Find the smallest possible average when pairing extremes optimally.

Input & Output

example_1.py — 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)→avg=8.0, (3,13)→avg=8.0, (4,8)→avg=6.0, (4,7)→avg=5.5. Minimum is 5.5.

example_2.py — Small Array

$ Input: nums = [1,9,8,3,10,5]

› Output: 5.5

💡 Note: After sorting: [1,3,5,8,9,10]. Pairs: (1,10)→avg=5.5, (3,9)→avg=6.0, (5,8)→avg=6.5. Minimum is 5.5.

example_3.py — Two Elements

$ Input: nums = [1,2]

› Output: 1.5

💡 Note: Only one pair possible: (1,2) → average = (1+2)/2 = 1.5. This is the minimum and only average.

Constraints

2 ≤ nums.length ≤ 50
nums.length is even
1 ≤ nums[i] ≤ 50
All elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Line Up Players

Sort all players by skill level from weakest to strongest

Pair Extremes

Always pair the weakest remaining player with the strongest remaining player

Calculate Team Strength

The team strength is the average of both players' skills

Track Minimum

Keep track of the weakest team strength across all pairings

Key Takeaway

🎯 Key Insight: Sort the array once to avoid repeatedly searching for minimum and maximum elements, reducing time complexity from O(n²) to O(n log n)

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution is to sort the array first, then use two pointers from both ends. This allows us to efficiently pair the smallest and largest remaining elements in O(n log n) time instead of the brute force O(n²) approach. The key insight is that sorting once eliminates the need for repeated linear searches.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n log n)	O(n)	Sort array once, then use two pointers from both ends
Brute Force (Repeated Linear Search)	O(n²)	O(n)	Find min/max elements by linear search in each iteration

Two Pointers (Optimal) — Algorithm Steps

Sort the input array in ascending order
Initialize left pointer at start (0) and right pointer at end (n-1)
While left < right: calculate average of nums[left] and nums[right]
Store the average and move both pointers inward
Continue until all pairs are processed
Return the minimum average from all calculated averages

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort the array: [1,3,4,4,7,8,13,15]

Initialize Pointers

Set left=0, right=7 pointing to smallest and largest

Calculate & Move

avg=(1+15)/2=8.0, move left++, right--

Continue Process

Next: avg=(3+13)/2=8.0, then avg=(4+8)/2=6.0, avg=(4+7)/2=5.5

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

double minimumAverage(int* nums, int numsSize) {
    qsort(nums, numsSize, sizeof(int), compare);  // Sort array
    
    double* averages = (double*)malloc(numsSize / 2 * sizeof(double));
    int avgCount = 0;
    int left = 0, right = numsSize - 1;
    
    while (left < right) {
        // Calculate average of min and max elements
        double avg = (nums[left] + nums[right]) / 2.0;
        averages[avgCount++] = avg;
        
        // Move pointers inward
        left++;
        right--;
    }
    
    // Find minimum average
    double minAvg = averages[0];
    for (int i = 1; i < avgCount; i++) {
        if (averages[i] < minAvg) {
            minAvg = averages[i];
        }
    }
    
    free(averages);
    return minAvg;
}

int main() {
    int nums[1000], size = 0, num;
    while (scanf("%d", &num) == 1) {
        nums[size++] = num;
    }
    printf("%.1f\n", minimumAverage(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), then O(n) for two-pointer traversal

⚡ Linearithmic

Space Complexity

O(n)

O(n) space for storing averages, plus O(log n) for sorting if not in-place

⚡ Linearithmic Space

28.2K 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

Constraints

Visualization

Related Problems

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler