Rearrange Array to Maximize Prefix Score

Rearrange Array to Maximize Prefix Score - Problem

You are given a 0-indexed integer array nums. You can rearrange the elements of nums to any order (including the given order).

Let prefix be the array containing the prefix sums of nums after rearranging it. In other words, prefix[i] is the sum of the elements from 0 to i in nums after rearranging it. The score of nums is the number of positive integers in the array prefix.

Return the maximum score you can achieve.

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,-1,-3,4]

› Output: 4

💡 Note: After sorting to [4,2,-1,-3], prefix sums are [4,6,5,2]. All 4 are positive, so score is 4.

Example 2 — Mixed Values

$ Input: nums = [-1,-2,-3]

› Output: 0

💡 Note: All numbers are negative. After sorting to [-1,-2,-3], prefix sums are [-1,-3,-6]. None are positive, so score is 0.

Example 3 — Single Element

$ Input: nums = [5]

› Output: 1

💡 Note: Single positive element gives prefix sum [5], which is positive. Score is 1.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁶ ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to use a greedy approach: sort the array in descending order to place larger values first, maximizing the number of positive prefix sums. Best approach is greedy sorting with Time: O(n log n), Space: O(1)

Common Approaches

✓ Greedy Sorting Approach

⏱️ Time: O(n log n) Space: O(1)

The key insight is that to maximize the number of positive prefix sums, we should place the largest elements first. Sort the array in descending order, then calculate prefix sums and count how many are positive.

Try All Permutations

⏱️ Time: O(n! × n) Space: O(n)

Generate every possible permutation of the array, calculate prefix sums for each permutation, count positive prefix sums, and return the maximum count found.

Greedy Sorting Approach — Algorithm Steps

Sort the array in descending order
Calculate prefix sums from left to right
Count how many prefix sums are positive
Return the count

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Descending

Arrange largest elements first

Calculate Prefix Sums

Accumulate sums from left to right

Count Positive

Count how many prefix sums are positive

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)b - *(int*)a); // Descending order
}

int solution(int* nums, int n) {
    // Sort in descending order to maximize positive prefix sums
    qsort(nums, n, sizeof(int), compare);
    
    long long prefixSum = 0;
    int positiveCount = 0;
    
    // Calculate prefix sums and count positive ones
    for (int i = 0; i < n; i++) {
        prefixSum += nums[i];
        if (prefixSum > 0) {
            positiveCount++;
        }
    }
    
    return positiveCount;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse JSON array manually
    int nums[100];
    int n = 0;
    char* token = strtok(line + 1, ",]"); // Skip opening bracket
    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 log n)

Dominated by sorting the array, prefix sum calculation is O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables, sorting can be done in-place

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

845 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

Greedy Sorting Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler