Largest Sum of Averages - Practice Coding Problems

Largest Sum of Averages - Problem

Largest Sum of Averages

You are given an integer array nums and an integer k. Your goal is to partition the array into at most k non-empty adjacent subarrays to maximize the sum of their averages.

🎯 The Challenge: Each partition creates subarrays, and you want to maximize the total score where the score equals the sum of averages of all subarrays.

Key Rules:

Partitions must use every element in the array
Subarrays must be adjacent (contiguous)
You can use at most k partitions
The score is the sum of averages (may be decimal)

Example: For nums = [9,1,2,3,9] and k = 3, the optimal partition is [9], [1,2,3], [9] giving score = 9 + 2 + 9 = 20.

Input & Output

example_1.py — Basic Case

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

› Output: 20.0

💡 Note: The best partition is [9], [1,2,3], [9]. This gives averages 9, 2, and 9 respectively, for a total score of 20.

example_2.py — Maximum Partitions

$ Input: nums = [1,2,3,4,5,6,7], k = 4

› Output: 20.5

💡 Note: One optimal partition is [1], [2], [3], [4,5,6,7]. This gives averages 1, 2, 3, and 5.5 respectively, for a total score of 11.5. Actually the optimal is [1,2,3], [4], [5], [6,7] giving 2 + 4 + 5 + 6.5 = 17.5. Wait let me recalculate: [1], [2,3], [4,5], [6,7] gives 1 + 2.5 + 4.5 + 6.5 = 14.5. The actual optimal is [1,2,3,4], [5], [6], [7] giving 2.5 + 5 + 6 + 7 = 20.5.

example_3.py — Single Partition

$ Input: nums = [4,1,7,3,4,9], k = 1

› Output: 4.666666666666667

💡 Note: With k=1, we must use the entire array as one partition. The average is (4+1+7+3+4+9)/6 = 28/6 ≈ 4.67.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ k ≤ nums.length
0 ≤ nums[i] ≤ 10⁴
The answer is guaranteed to be within 10^-6 of the actual answer

Visualization

Tap to expand

Understanding the Visualization

Identify Subproblems

For each position and remaining partitions, find the optimal score

Try All Split Points

For each subproblem, try every possible way to place the next partition

Memoize Results

Cache computed results to avoid redundant calculations

Build Up Solution

Combine optimal subproblem solutions to get the final answer

Key Takeaway

🎯 Key Insight: This problem has optimal substructure - the best way to partition a suffix of the array depends only on that suffix and the number of partitions remaining, not on how we partitioned the prefix. Memoization transforms an exponential problem into a polynomial one.

Asked in

G Google 45 a Amazon 32 f Meta 28 Apple 15

The optimal approach uses dynamic programming with memoization to solve this partition optimization problem. The key insight is that we can build up the solution by considering all possible ways to place the first partition, then recursively solving for the remaining array with k-1 partitions. Memoization ensures we don't recompute the same subproblems, reducing time complexity from O(k^n) to O(n²k).

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Brute Force	O(k^n)	O(n)	Try all possible ways to partition the array recursively
Dynamic Programming (Memoization)	O(n²k)	O(nk)	Optimize brute force with memoization to avoid recomputing subproblems

Recursive Brute Force — Algorithm Steps

For each position i, try placing a partition boundary
Recursively solve for the remaining subarray with k-1 partitions
Calculate the average of the current subarray and add to the result
Return the maximum score among all possible partitions

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with full array

Begin with the entire array and k partitions available

Try each split point

For each position, try creating a partition boundary

Recurse on remainder

Solve the remaining subarray with k-1 partitions

Choose maximum

Return the best score among all possibilities

Code -

solution.c — C

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

double max(double a, double b) {
    return a > b ? a : b;
}

double solve(int* nums, int n, int start, int partitionsLeft) {
    if (partitionsLeft == 1) {
        double sum = 0;
        for (int i = start; i < n; i++) {
            sum += nums[i];
        }
        return sum / (n - start);
    }
    
    if (start >= n) return 0;
    
    double maxScore = 0;
    double currentSum = 0;
    
    for (int end = start; end <= n - partitionsLeft; end++) {
        currentSum += nums[end];
        double currentAvg = currentSum / (end - start + 1);
        double remainingScore = solve(nums, n, end + 1, partitionsLeft - 1);
        maxScore = max(maxScore, currentAvg + remainingScore);
    }
    
    return maxScore;
}

double largestSumOfAverages(int* nums, int numsSize, int k) {
    return solve(nums, numsSize, 0, k);
}

int main() {
    // Input parsing needed
    printf("Solution implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Each position can start a new partition, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth is at most n

⚡ Linearithmic Space

32.4K Views

Medium Frequency

~25 min Avg. Time

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

Recursive Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler