Minimum Average Difference - Practice Coding Problems

Minimum Average Difference - Problem

You are given a 0-indexed integer array nums of length n.

The average difference of the index i is the absolute difference between the average of the first i + 1 elements of nums and the average of the last n - i - 1 elements. Both averages should be rounded down to the nearest integer.

Return the index with the minimum average difference. If there are multiple such indices, return the smallest one.

Note:

The absolute difference of two numbers is the absolute value of their difference.
The average of n elements is the sum of the n elements divided (integer division) by n.
The average of 0 elements is considered to be 0.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: At index 3: left = [2,5,3,9] (avg=4), right = [5,3] (avg=4), difference = 0 (minimum possible)

Example 2 — Single Element

$ Input: nums = [0]

› Output: 0

💡 Note: Only one element, so left avg = 0, right avg = 0 (no right elements), difference = 0

Example 3 — Two Elements

$ Input: nums = [2,8]

› Output: 0

💡 Note: Index 0: left avg = 2, right avg = 8, diff = 6. Index 1: left avg = 5, right avg = 0, diff = 5. Choose index 1

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Input Array

Given array [2,5,3,9,5,3] with indices 0-5

Calculate Differences

For each index, find |left_avg - right_avg|

Output Index

Return index with minimum difference

Key Takeaway

🎯 Key Insight: Use prefix sums to efficiently calculate left and right averages without recalculation

Asked in

a Amazon 12 M Microsoft 8

The key insight is to use prefix sums to avoid recalculating left and right sums for each position. Best approach uses a single pass with running totals. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force	O(n²)	O(1)	Calculate left and right averages from scratch for each index
Prefix Sum Optimization	O(n)	O(1)	Use running sums to avoid recalculating left and right parts

Brute Force — Algorithm Steps

Iterate through each index i
Calculate sum of left part (0 to i)
Calculate sum of right part (i+1 to n-1)
Compute averages and absolute difference
Track minimum difference and its index

Visualization

Tap to expand

Step-by-Step Walkthrough

Position i=0

Calculate left sum [2], right sum [7,11,15]

Position i=1

Recalculate left sum [2,7], right sum [11,15]

Result

Find minimum difference across all positions

Code -

solution.c — C

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

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

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n indices, we calculate sums in O(n) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track sums and minimum

✓ Linear Space

32.0K Views

Medium Frequency

~15 min Avg. Time

850 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler