All Divisions With the Highest Score of a Binary Array

All Divisions With the Highest Score of a Binary Array - Problem

Array Medium

Imagine you're a strategic analyst tasked with finding the optimal division points in a binary array to maximize your scoring potential!

Given a binary array nums of length n, you can divide it at any index i (where 0 ≤ i ≤ n) into two parts:

Left part: Elements from index 0 to i-1
Right part: Elements from index i to n-1

Your division score is calculated as:

Score = (Number of 0's in left part) + (Number of 1's in right part)

Your mission is to find all indices that produce the highest possible division score. The strategy is to reward having more 0's on the left and more 1's on the right!

Special cases:

If i = 0: Left part is empty, right part contains all elements
If i = n: Left part contains all elements, right part is empty

Input & Output

example_1.py — Basic Case

$ Input: [0,0,1,0]

› Output: [2,4]

💡 Note: Division at i=2: Left=[0,0] has 2 zeros, Right=[1,0] has 1 one → Score=3. Division at i=4: Left=[0,0,1,0] has 3 zeros, Right=[] has 0 ones → Score=3. Both achieve maximum score of 3.

example_2.py — All Ones

$ Input: [1,1,1]

› Output: [0]

💡 Note: Division at i=0: Left=[] has 0 zeros, Right=[1,1,1] has 3 ones → Score=3. Any other division reduces the number of ones on right without gaining zeros on left, so i=0 is optimal.

example_3.py — All Zeros

$ Input: [0,0,0]

› Output: [3]

💡 Note: Division at i=3: Left=[0,0,0] has 3 zeros, Right=[] has 0 ones → Score=3. This maximizes zeros on left since there are no ones to put on right.

Visualization

Tap to expand

Understanding the Visualization

Setup the Array

Place binary array elements and consider all possible division points

Calculate Initial Score

Start at division point 0 with score = total ones (all on right)

Move Division Point

As we move right, update score based on element type we're moving

Track Maximum

Keep track of all division points that achieve maximum score

Key Takeaway

🎯 Key Insight: The optimal solution leverages the fact that moving the division point by one position only changes the score by ±1, enabling efficient O(n) incremental calculation.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count initial ones, then one pass to check all division points

✓ Linear Growth

Space Complexity

O(1)

Only using variables for tracking score and maximum, plus result array

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
Division point i can range from 0 to n (inclusive)

Asked in

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

The optimal solution uses incremental score updates in O(n) time. Start with initial score at division point 0, then update the score by ±1 as we move the division point right, tracking all indices that achieve the maximum score.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Prefix Sum (Optimal)	O(n)	O(1)	Calculate initial score and update incrementally as we move division point
Brute Force (Check All Division Points)	O(n²)	O(1)	Calculate score for each possible division point by counting 0's and 1's

One-Pass Prefix Sum (Optimal) — Algorithm Steps

Calculate initial score at division point 0: score = total ones in array
For each position i from 1 to n, update score based on nums[i-1]
If nums[i-1] == 0: moving 0 to left increases score by 1
If nums[i-1] == 1: moving 1 to left decreases score by 1
Track maximum score and collect all indices achieving it

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State (i=0)

Left: empty, Right: all elements. Score = total ones = 1

Move to i=1

Move nums[0]=0 to left. Gain +1 zero. Score = 2

Move to i=2

Move nums[1]=0 to left. Gain +1 zero. Score = 3

Continue Pattern

Each move changes score by ±1 based on element type

Code -

solution.c — C

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

int* maxScoreIndices(int* nums, int numsSize, int* returnSize) {
    // Initial score at division point 0: no zeros on left, all ones on right
    int score = 0;
    for (int i = 0; i < numsSize; i++) {
        score += nums[i];
    }
    int maxScore = score;
    int* result = malloc((numsSize + 1) * sizeof(int));
    result[0] = 0;
    *returnSize = 1;
    
    // Move division point from 1 to n
    for (int i = 1; i <= numsSize; i++) {
        // Moving nums[i-1] from right side to left side
        if (nums[i - 1] == 0) {
            score += 1; // Gained a zero on left
        } else {
            score -= 1; // Lost a one on right
        }
        
        if (score > maxScore) {
            maxScore = score;
            result[0] = i;
            *returnSize = 1;
        } else if (score == maxScore) {
            result[*returnSize] = i;
            (*returnSize)++;
        }
    }
    
    return result;
}

int main() {
    int nums[] = {0, 0, 1, 0}; // Example input
    int returnSize;
    int* result = maxScoreIndices(nums, 4, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count initial ones, then one pass to check all division points

✓ Linear Growth

Space Complexity

O(1)

Only using variables for tracking score and maximum, plus result array

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
Division point i can range from 0 to n (inclusive)

42.0K Views

Medium Frequency

~18 min Avg. Time

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

One-Pass Prefix Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler