Number of Distinct Averages - Practice Coding Problems

Number of Distinct Averages - Problem

You're given an array of integers with even length. Your task is to perform a unique pairing operation that reveals how many distinct averages can be formed!

The Process:

Find the minimum number in the array and remove it
Find the maximum number in the remaining array and remove it
Calculate the average of these two numbers: (min + max) / 2
Repeat until the array is empty

Goal: Return the count of distinct averages you calculated.

Example: For array [4,1,4,0,3,5]:

Remove 0 (min) and 5 (max) → average = 2.5
Remove 1 (min) and 4 (max) → average = 2.5
Remove 3 (min) and 4 (max) → average = 3.5

Result: 2 distinct averages (2.5 and 3.5)

Input & Output

example_1.py — Basic Case

$ Input: nums = [4,1,4,0,3,5]

› Output: 2

💡 Note: After sorting: [0,1,3,4,4,5]. Pairs: (0,5)→avg=2.5, (1,4)→avg=2.5, (3,4)→avg=3.5. Distinct averages: {2.5, 3.5}, so return 2.

example_2.py — All Same Average

$ Input: nums = [1,100]

› Output: 1

💡 Note: Only one pair possible: (1,100). Average = (1+100)/2 = 50.5. Only one distinct average, so return 1.

example_3.py — Multiple Distinct

$ Input: nums = [9,5,7,8,7,9,8,2,0,7]

› Output: 5

💡 Note: After sorting: [0,2,5,7,7,7,8,8,9,9]. Pairs create averages: 4.5, 5.5, 6, 7.5, 8. Five distinct values.

Visualization

Tap to expand

Understanding the Visualization

Line Up by Personality

Sort everyone from most introverted to most extroverted

Pair from Extremes

Always pair the person at the left end with the person at the right end

Record Compatibility

Calculate their compatibility score (average) and add to our unique scores set

Move Inward

Remove the paired people and repeat with the next extremes

Count Unique Scores

Return the total number of distinct compatibility scores found

Key Takeaway

🎯 Key Insight: By sorting first and using two pointers from opposite ends, we eliminate the need for repeated searching and achieve optimal time complexity while maintaining clean, readable code!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting step. The two-pointer traversal is O(n), but sorting takes O(n log n)

⚡ Linearithmic

Space Complexity

O(n)

Space for the set to store distinct averages, plus potential space for sorting depending on implementation

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 100
nums.length is even
0 ≤ nums[i] ≤ 100

Asked in

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

The optimal approach is to sort the array first, then use two pointers from both ends. This automatically pairs the smallest remaining element with the largest remaining element in each iteration, achieving O(n log n) time complexity with clean, efficient code.

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)	Repeatedly find min and max by scanning entire array each time

Two Pointers (Optimal) — Algorithm Steps

Sort the input array in ascending order
Initialize left pointer at start (index 0) and right pointer at end (index n-1)
While left pointer < right pointer:
Calculate average of elements at left and right pointers
Add average to set of distinct averages
Move left pointer right and right pointer left
Return size of the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Transform [4,1,4,0,3,5] to [0,1,3,4,4,5]

Initialize Pointers

Left pointer at index 0, right pointer at last index

First Pairing

Pair elements at positions 0 and 5: (0 + 5)/2 = 2.5

Move Pointers

Move left right and right left: now at positions 1 and 4

Continue Process

Repeat until pointers meet in the middle

Code -

solution.c — C

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

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

typedef struct {
    double value;
    int exists;
} Average;

int distinctAverages(int* nums, int numsSize) {
    qsort(nums, numsSize, sizeof(int), compare);  // Sort the array
    
    Average averages[1000]; // Assuming max 1000 distinct averages
    int avgCount = 0;
    
    int left = 0, right = numsSize - 1;
    while (left < right) {
        // Calculate average of min (left) and max (right)
        double avg = (nums[left] + nums[right]) / 2.0;
        
        // Check if average already exists
        int found = 0;
        for (int i = 0; i < avgCount; i++) {
            if (averages[i].value == avg) {
                found = 1;
                break;
            }
        }
        
        if (!found) {
            averages[avgCount].value = avg;
            avgCount++;
        }
        
        // Move pointers inward
        left++;
        right--;
    }
    
    return avgCount;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    
    scanf("%c", &c); // Read '['
    while (scanf("%d", &nums[size]) == 1) {
        size++;
        scanf("%c", &c); // Read ',' or ']'
        if (c == ']') break;
    }
    
    printf("%d\n", distinctAverages(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting step. The two-pointer traversal is O(n), but sorting takes O(n log n)

⚡ Linearithmic

Space Complexity

O(n)

Space for the set to store distinct averages, plus potential space for sorting depending on implementation

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 100
nums.length is even
0 ≤ nums[i] ≤ 100

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

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler