Minimum Replacements to Sort the Array

Minimum Replacements to Sort the Array - Problem

You are given a 0-indexed integer array nums. In one operation you can replace any element of the array with any two elements that sum to it.

For example, consider nums = [5,6,7]. In one operation, we can replace nums[1] with 2 and 4 and convert nums to [5,2,4,7].

Return the minimum number of operations to make an array that is sorted in non-decreasing order.

Input & Output

Example 1 — Basic Split Case

$ Input: nums = [3,9,4]

› Output: 2

💡 Note: 9 > 4, so we need to split 9. Optimal split: 9 → 3+3+3 (2 operations). Array becomes [3,3,3,3,4] which is sorted.

Example 2 — Already Sorted

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

› Output: 0

💡 Note: Array is already in non-decreasing order, no operations needed.

Example 3 — Multiple Splits

$ Input: nums = [2,10,20]

› Output: 6

💡 Note: 20→5+5+5+5 (3 ops), then 10→3+3+4 (2 ops), then 2→1+1 (1 op). Total: 6 operations.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to work backwards from right to left, greedily splitting each element into the minimum number of pieces needed. When we encounter nums[i] > nums[i+1], we split nums[i] into ⌈nums[i]/nums[i+1]⌉ equal parts. Best approach is Greedy. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force with Recursion

⏱️ Time: O(2^n) Space: O(n)

For each element that violates the non-decreasing order, recursively try all possible ways to split it into two parts and count total operations needed.

Greedy (Optimal)

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

Process array from right to left. For each element that's too large, split it optimally to minimize operations while ensuring the result fits within the constraint of the next element.

Brute Force with Recursion — Algorithm Steps

Start from left, check if current element ≤ next element
If not, try all ways to split current element into two parts
Recursively solve for each split possibility
Return minimum operations across all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Order

Find first element violating non-decreasing order

Try Splits

Recursively try all ways to split that element

Count Operations

Return minimum operations across all possibilities

Code -

solution.c — C

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

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int solution(int* nums, int size) {
    int n = size;
    if (n <= 1) {
        return 0;
    }
    
    int operations = 0;
    
    // Work from right to left
    for (int i = n - 2; i >= 0; i--) {
        if (nums[i] > nums[i + 1]) {
            // Need to split nums[i] so that largest part <= nums[i + 1]
            int limit = nums[i + 1];
            // Minimum number of parts needed
            int parts_needed = (int)ceil((double)nums[i] / limit);
            // Number of operations = parts_needed - 1
            int ops = parts_needed - 1;
            operations += ops;
            // Update nums[i] to be the largest part after splitting
            nums[i] = nums[i] / parts_needed;
        }
    }
    
    return operations;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int size = 0;
    parseArray(line, nums, &size);
    
    int result = solution(nums, size);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each element can be split in multiple ways, leading to exponential branching

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth up to array length

✓ Linear Space

25.0K Views

Medium Frequency

~35 min Avg. Time

850 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 with Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler