Minimum Average Difference - Practice Coding Problems

Minimum Average Difference - Problem

Find the Optimal Split Point!

You're given an array of integers, and your task is to find the best place to "split" it. For any index i, you can divide the array into two parts:

🔹 Left part: First i + 1 elements
🔹 Right part: Remaining n - i - 1 elements

Calculate the average difference at index i as the absolute difference between:
• Average of left part (rounded down)
• Average of right part (rounded down)

Goal: Return the index with the minimum average difference. If there are ties, return the smallest index.

Special cases:
• Use integer division (round down) for averages
• If right part is empty, its average is considered 0

Example: For array [2,5,3,9,5,3], at index 2:
• Left: [2,5,3] → average = 10/3 = 3
• Right: [9,5,3] → average = 17/3 = 5
• Difference = |3 - 5| = 2

Input & Output

example_1.py — Basic Case

$ Input: nums = [2,5,3,9,5,3]

› Output: 3

💡 Note: At index 3: Left part [2,5,3,9] has average 19/4=4, Right part [5,3] has average 8/2=4. Difference = |4-4| = 0, but we need to check all positions. At index 3, we get the minimum difference.

example_2.py — Single Element

$ Input: nums = [0]

› Output: 0

💡 Note: Only one element, so we can only split at index 0. Left part [0] has average 0, right part is empty (average 0). Difference = 0.

example_3.py — Two Elements

$ Input: nums = [1,2]

› Output: 1

💡 Note: Index 0: Left=[1] avg=1, Right=[2] avg=2, diff=1. Index 1: Left=[1,2] avg=1, Right=[] avg=0, diff=1. Both have same difference, return smaller index 0... wait, let me recalculate. Actually index 1 gives diff=1, index 0 gives diff=1, so return 0.

Visualization

Tap to expand

Understanding the Visualization

Calculate Total

First, calculate the total sum of all elements: 2+5+3+9+5+3 = 27

Try Each Split

For each position, calculate left and right averages using prefix sums

Track Minimum

Keep track of the position with minimum absolute difference

Return Result

Return the index with minimum difference (smallest index if tied)

Key Takeaway

🎯 Key Insight: Using prefix sums eliminates redundant calculations, reducing time complexity from O(n²) to O(n) while maintaining O(1) space complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we sum up to n elements, giving us n × n operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track sums and minimum difference

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁵
All averages are calculated using integer division (rounded down)
If there are multiple indices with the same minimum difference, return the smallest one

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses prefix sums to avoid recalculating array segments. We compute the total sum first, then maintain a running prefix sum. For each position, the left average uses the prefix sum, and the right average uses total_sum - prefix_sum. This achieves O(n) time complexity compared to the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recalculate Everything)	O(n²)	O(1)	For each split point, recalculate both left and right sums from scratch
Prefix Sum Optimization (Optimal)	O(n)	O(1)	Use prefix sums to calculate averages in O(1) time for each position

Brute Force (Recalculate Everything) — Algorithm Steps

Iterate through each possible split index i from 0 to n-1
For each i, calculate sum of first i+1 elements (left part)
Calculate sum of remaining n-i-1 elements (right part)
Compute averages using integer division
Calculate absolute difference between averages
Track minimum difference and corresponding index

Visualization

Tap to expand

Step-by-Step Walkthrough

Position 0

Calculate left sum [2], right sum [5,3,9,5,3]

Position 1

Calculate left sum [2,5], right sum [3,9,5,3]

Continue

Repeat for all positions, recalculating each time

Code -

solution.c — C

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

int minimumAverageDifference(int* nums, int numsSize) {
    int minDiff = INT_MAX;
    int result = 0;
    
    for (int i = 0; i < numsSize; i++) {
        // Calculate left sum
        long long leftSum = 0;
        for (int j = 0; j <= i; j++) {
            leftSum += nums[j];
        }
        int leftAvg = leftSum / (i + 1);
        
        // Calculate right sum
        int rightAvg = 0;
        if (i != numsSize - 1) {
            long long rightSum = 0;
            for (int j = i + 1; j < numsSize; j++) {
                rightSum += nums[j];
            }
            rightAvg = rightSum / (numsSize - i - 1);
        }
        
        // Calculate difference
        int diff = abs(leftAvg - rightAvg);
        
        // Update minimum
        if (diff < minDiff) {
            minDiff = diff;
            result = i;
        }
    }
    
    return result;
}

int main() {
    // Simple input parsing for demo
    int nums[] = {2, 5, 3, 9, 5, 3};
    int size = 6;
    printf("%d\n", minimumAverageDifference(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we sum up to n elements, giving us n × n operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track sums and minimum difference

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁵
All averages are calculated using integer division (rounded down)
If there are multiple indices with the same minimum difference, return the smallest one

21.7K Views

Medium Frequency

~15 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

Brute Force (Recalculate Everything) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler