Rearrange Array to Maximize Prefix Score - Practice Coding Problems

Rearrange Array to Maximize Prefix Score - Problem

Rearrange Array to Maximize Prefix Score

You're given an array of integers and need to find the optimal arrangement that maximizes the number of positive prefix sums.

🎯 The Challenge: Given a 0-indexed integer array nums, you can rearrange its elements in any order. After rearrangement, create a prefix sum array where prefix[i] represents the sum of all elements from index 0 to i.

Your score is the count of positive values in this prefix array. Return the maximum possible score.

Example: For [2, -1, 0, 1, -3, 3, -3], one optimal arrangement is [3, 2, 1, 0, -1, -3, -3] giving prefix sums [3, 5, 6, 6, 5, 2, -1] with 6 positive values.

Input & Output

example_1.py — Basic Case

$ Input: [2, -1, 0, 1, -3, 3, -3]

› Output: 6

💡 Note: Optimal arrangement is [3, 2, 1, 0, -1, -3, -3] giving prefix sums [3, 5, 6, 6, 5, 2, -1]. The first 6 values are positive.

example_2.py — All Negative

$ Input: [-2, -3, 0]

› Output: 0

💡 Note: Best arrangement is [0, -2, -3] with prefix sums [0, -2, -5]. No positive values, so score is 0.

example_3.py — All Positive

$ Input: [1, 3, 2, 1]

› Output: 4

💡 Note: Any arrangement works since all numbers are positive. Prefix sums will always all be positive, giving maximum score of 4.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁶ ≤ nums[i] ≤ 10⁶
Important: Use long/long long for prefix sum calculations to avoid integer overflow

Visualization

Tap to expand

Understanding the Visualization

Collect All Transactions

You have various income (+) and expense (-) items to schedule

Schedule Largest Income First

Arrange to receive your biggest payments early to build up buffer

Add Remaining in Descending Order

Continue with smaller income, then zero, then expenses smallest to largest

Track Positive Months

Count how many months your running balance stays positive

Key Takeaway

🎯 Key Insight: Greedy scheduling works! Arrange positive cash flows first (largest to smallest) to maximize the number of profitable periods.

Asked in

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

The optimal solution uses a greedy approach: sort the array in descending order and count positive prefix sums. This works because larger values placed first maximize the chances of keeping prefix sums positive. Time complexity is O(n log n) due to sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Permutations)	O(n! × n)	O(n)	Generate all possible arrangements and find the one with maximum positive prefix sums
Greedy Sorting (Optimal)	O(n log n)	O(1)	Sort elements in descending order to maximize positive prefix sums

Brute Force (All Permutations) — Algorithm Steps

Generate all permutations of the input array
For each permutation, calculate prefix sums
Count positive values in each prefix sum array
Return the maximum count across all permutations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutation

Create one possible arrangement of elements

Calculate Prefix Sums

Compute running totals from left to right

Count Positives

Count how many prefix sums are positive

Track Maximum

Keep track of the best score seen so far

Code -

solution.c — C

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

int maxScore = 0;

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void calculateScore(int* nums, int n) {
    long long prefixSum = 0;
    int score = 0;
    
    for (int i = 0; i < n; i++) {
        prefixSum += nums[i];
        if (prefixSum > 0) score++;
    }
    
    if (score > maxScore) maxScore = score;
}

void permute(int* nums, int start, int n) {
    if (start == n - 1) {
        calculateScore(nums, n);
        return;
    }
    
    for (int i = start; i < n; i++) {
        swap(&nums[start], &nums[i]);
        permute(nums, start + 1, n);
        swap(&nums[start], &nums[i]);
    }
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // Read '['
    
    while (scanf("%d", &nums[n]) == 1) {
        n++;
        scanf("%c", &c);
        if (c == ']') break;
    }
    
    maxScore = 0;
    permute(nums, 0, n);
    printf("%d\n", maxScore);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each requiring O(n) time to calculate prefix sums

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation and prefix sums

⚡ Linearithmic Space

28.5K Views

Medium-High Frequency

~15 min Avg. Time

847 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 (All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler