Maximum Sum Score of Array - Practice Coding Problems

Maximum Sum Score of Array - Problem

🎯 Maximum Sum Score of Array

Imagine you're a data analyst looking for the optimal position to analyze an array! You need to find the index that gives you the maximum sum score.

Given a 0-indexed integer array nums of length n, the sum score at index i is defined as the maximum of:

🔵 Left sum: Sum of the first i + 1 elements (from start to index i)
🔴 Right sum: Sum of the last n - i elements (from index i to end)

Goal: Return the maximum sum score among all possible indices.

Example: For array [4, 3, -2, 5], at index 1:

Left sum = 4 + 3 = 7
Right sum = 3 + (-2) + 5 = 6
Sum score = max(7, 6) = 7

Input & Output

example_1.py — Basic Case

$ Input: [4, 3, -2, 5]

› Output: 10

💡 Note: At index 0: left_sum = 4, right_sum = 4+3+(-2)+5 = 10, score = max(4,10) = 10. At index 3: left_sum = 4+3+(-2)+5 = 10, right_sum = 5, score = max(10,5) = 10. Maximum score is 10.

example_2.py — All Negative

$ Input: [-3, -5]

› Output: -3

💡 Note: At index 0: left_sum = -3, right_sum = -3+(-5) = -8, score = max(-3,-8) = -3. At index 1: left_sum = -8, right_sum = -5, score = max(-8,-5) = -5. Maximum score is -3.

example_3.py — Single Element

$ Input: [5]

› Output: 5

💡 Note: At index 0: left_sum = 5, right_sum = 5, score = max(5,5) = 5. Maximum score is 5.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁶ ≤ nums[i] ≤ 10⁶
Note: Elements can be negative, requiring careful handling of minimum values

Visualization

Tap to expand

Understanding the Visualization

Survey the Trail

Pre-calculate cumulative distances (prefix sums) to know total progress at each position

Evaluate Each Position

At each position, calculate backward view (prefix sum) and forward view (total - prefix + current)

Choose Best Position

Select the position that gives the maximum of the two viewing options

Key Takeaway

🎯 Key Insight: Prefix sums transform an O(n²) problem into O(n) by eliminating redundant sum calculations!

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal approach uses prefix sums to avoid redundant calculations. By pre-computing cumulative sums, we can calculate both left and right sums in O(1) time for each index, achieving overall O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Calculate left and right sums from scratch for each index
Prefix Sum Approach	O(n)	O(n)	Pre-compute prefix sums, then calculate scores efficiently

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each index i from 0 to n-1
For each index i, calculate left sum (sum of first i+1 elements)
For each index i, calculate right sum (sum of last n-i elements)
Take maximum of left sum and right sum as score for index i
Track the maximum score seen so far

Visualization

Tap to expand

Step-by-Step Walkthrough

Index 0

Calculate left sum [4] = 4, right sum [4,3,-2,5] = 10, score = 10

Index 1

Calculate left sum [4,3] = 7, right sum [3,-2,5] = 6, score = 7

Index 2

Calculate left sum [4,3,-2] = 5, right sum [-2,5] = 3, score = 5

Index 3

Calculate left sum [4,3,-2,5] = 10, right sum [5] = 5, score = 10

Code -

solution.c — C

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

long long maxSumScore(int* nums, int n) {
    long long maxScore = LLONG_MIN;
    
    for (int i = 0; i < n; i++) {
        // Calculate left sum (first i+1 elements)
        long long leftSum = 0;
        for (int j = 0; j <= i; j++) {
            leftSum += nums[j];
        }
        
        // Calculate right sum (last n-i elements)
        long long rightSum = 0;
        for (int j = i; j < n; j++) {
            rightSum += nums[j];
        }
        
        // Score is maximum of left and right sums
        long long score = (leftSum > rightSum) ? leftSum : rightSum;
        maxScore = (score > maxScore) ? score : maxScore;
    }
    
    return maxScore;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Parse input
    int nums[1000];
    int n = 0;
    char* token = strtok(input, "[],\n");
    
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%lld\n", maxSumScore(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

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

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track sums and maximum

✓ Linear Space

42.0K Views

Medium Frequency

~15 min Avg. Time

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

🎯 Maximum Sum Score of Array

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler