Minimum Replacements to Sort the Array - Practice Coding Problems

Minimum Replacements to Sort the Array - Problem

Transform an Array into Sorted Order Through Strategic Element Splitting

You are given a 0-indexed integer array nums. Your goal is to make the array non-decreasing (sorted) using a special operation.

In one operation, you can replace any element of the array with any two elements that sum to it. This effectively "splits" one element into two smaller parts.

For example:
• Given nums = [5,6,7]
• You can replace nums[1] = 6 with 2 and 4
• Result: [5,2,4,7]

The key insight is that you can only split elements (make them smaller), but you cannot combine them or make them larger. Your task is to find the minimum number of operations needed to create a non-decreasing array.

Challenge: This requires working backwards from the end of the array and using greedy optimization to minimize splits while maintaining the sorted property.

Input & Output

example_1.py — Basic splitting example

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

› Output: 3

💡 Note: Working from right to left: 6 > 1, so split into [3,3] (1 op). 4 > 2, so split into [2,2] (1 op). 3 > 2, so split into [1,2] (1 op). Total: 3 operations resulting in [1,2,2,2,3,3,1]

example_2.py — Already sorted

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

› Output: 0

💡 Note: Array is already non-decreasing, so no operations are needed

example_3.py — Single large element

$ Input: nums = [20,1]

› Output: 19

💡 Note: Need to split 20 into 20 parts of size 1 each: [1,1,1,...,1,1]. This requires 19 operations (20 parts = 19 splits)

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
Each operation splits one element into exactly two elements
The sum of split elements must equal the original element

Visualization

Tap to expand

Understanding the Visualization

Right-to-Left Scan

Start from the end - the last element sets our constraint

Check Violation

If current element > max_allowed from right, we need to split

Optimal Split

Split into minimum parts: k = ceil(current/max_allowed)

Update Constraint

New max_allowed = current/k (maximize for next element)

Key Takeaway

🎯 Key Insight: Work backwards with greedy optimal splitting - each element determines the maximum constraint for elements to its left, and we split to minimize operations while maximizing the next constraint.

Asked in

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

The optimal approach uses greedy right-to-left traversal. Starting from the rightmost element, for each violating element, calculate the minimum splits needed using k = ceil(nums[i] / max_allowed), add k-1 operations, and update max_allowed = nums[i] / k. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Right-to-Left Optimal Splitting	O(n)	O(1)	Work backwards optimally splitting elements to minimize total operations
Recursive Brute Force with All Possible Splits	O(2^n)	O(n * max_value)	Try all possible ways to split each element and recursively find minimum operations

Greedy Right-to-Left Optimal Splitting — Algorithm Steps

Start from the rightmost element and move left
Maintain the maximum allowed value for current position
If current element ≤ max allowed, no split needed, update max allowed
If current element > max allowed, calculate minimum splits needed
Split into k parts where k = ceil(current/max_allowed)
New maximum allowed becomes floor(current/k) to maximize next element
Add (k-1) to operation count (k parts means k-1 operations)

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from Right

Begin with rightmost element as maximum allowed

Check Constraint

If current ≤ max_allowed, no split needed

Calculate Splits

If violation, find minimum k where k = ceil(current/max_allowed)

Update Maximum

Set new max_allowed = floor(current/k) for optimal next split

Code -

solution.c — C

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

long long minimumReplacement(int* nums, int numsSize) {
    long long operations = 0;
    int maxAllowed = nums[numsSize - 1];
    
    for (int i = numsSize - 2; i >= 0; i--) {
        if (nums[i] <= maxAllowed) {
            maxAllowed = nums[i];
        } else {
            int k = (nums[i] + maxAllowed - 1) / maxAllowed;
            operations += k - 1;
            maxAllowed = nums[i] / k;
        }
    }
    
    return operations;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array from right to left

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track operations and maximum allowed value

✓ Linear Space

43.2K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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 Right-to-Left Optimal Splitting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler