Minimum Operations to Make the Array Increasing

Minimum Operations to Make the Array Increasing - Problem

Array Greedy Easy

You have an integer array nums that you want to transform into a strictly increasing sequence. The only operation allowed is to increment any element by 1.

Your goal is to find the minimum number of operations needed to make the array strictly increasing, where each element must be smaller than the next one: nums[i] < nums[i+1].

Example: If nums = [1, 2, 3], it's already strictly increasing, so 0 operations are needed. But if nums = [1, 1, 1], you need to make it [1, 2, 3], requiring 3 operations total.

Remember: You can only increase values, never decrease them, and single-element arrays are automatically valid!

Input & Output

example_1.py — Basic Increasing Array

$ Input: nums = [1,1,1]

› Output: 3

💡 Note: We need to transform [1,1,1] to [1,2,3]. Operations: increment nums[1] once (1→2) and nums[2] twice (1→3), totaling 3 operations.

example_2.py — Partially Sorted

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

› Output: 14

💡 Note: Transform to [1,5,6,7,8]. nums[2]: 2→6 (4 ops), nums[3]: 4→7 (3 ops), nums[4]: 1→8 (7 ops). Total: 14 operations.

example_3.py — Already Sorted

$ Input: nums = [8]

› Output: 0

💡 Note: Single element arrays are automatically strictly increasing, so no operations needed.

Constraints

1 ≤ nums.length ≤ 5000
1 ≤ nums[i] ≤ 10⁵
You can only increment elements, never decrement
Array must become strictly increasing: nums[i] < nums[i+1]

Visualization

Tap to expand

Understanding the Visualization

Inspection Start

Begin with the first building as reference

Check Violation

If next building is too short, calculate floors needed

Add Floors

Increment height to minimum required (previous + 1)

Continue Inspection

Move to next building and repeat process

Key Takeaway

🎯 Key Insight: The greedy approach works because fixing each violation with the minimum required increment ensures no future conflicts while minimizing total operations.

Asked in

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

The optimal greedy solution makes a single pass through the array, ensuring each element is strictly greater than its predecessor. When a violation is found, we increment the element to be exactly previous + 1, which is the minimum required. This approach guarantees optimality because any smaller increment would necessitate additional operations later.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Single Pass (Optimal)	O(n)	O(1)	Traverse array once, ensuring each element is larger than the previous
Brute Force (Check All Possibilities)	O(2^n)	O(n)	Try all possible increment combinations until array becomes strictly increasing

Greedy Single Pass (Optimal) — Algorithm Steps

Initialize operations counter to 0
Iterate through array starting from index 1
For each element, check if it's greater than the previous
If not, calculate minimum increments needed: prev_element - current_element + 1
Add required operations to counter and update current element
Return total operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Initialize with first element

Check Next

Compare with previous element

Fix Violations

Increment to maintain order

Continue

Move to next element

Code -

solution.c — C

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

int minimumOperations(int* nums, int numsSize) {
    if (numsSize <= 1) return 0;
    
    int operations = 0;
    
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] <= nums[i-1]) {
            int incrementsNeeded = nums[i-1] - nums[i] + 1;
            operations += incrementsNeeded;
            nums[i] = nums[i-1] + 1;
        }
    }
    
    return operations;
}

int main() {
    int nums[1000];
    int size = 0;
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", minimumOperations(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array visiting each element exactly once

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant amount of extra space for counters and variables

✓ Linear Space

89.2K Views

High Frequency

~15 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 Single Pass (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler