Minimum Pair Removal to Sort Array I - Practice Coding Problems

Minimum Pair Removal to Sort Array I - Problem

Array Hash Table Linked List Heap (Priority Queue) Simulation Doubly-Linked List Ordered Set Easy

You are given an array nums and need to make it non-decreasing (sorted) using a special operation.

Operation Rules:

Find all adjacent pairs with the minimum sum in the current array
If multiple pairs have the same minimum sum, choose the leftmost one
Replace this pair with their sum (merge them into one element)
Repeat until the array is non-decreasing

Goal: Return the minimum number of operations needed to make the array non-decreasing.

Example: For [3, 2, 1, 4]:
• Find min sum pairs: (2,1) has sum 3
• Replace → [3, 3, 4] (1 operation)
• Array is now sorted! Answer: 1

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: The adjacent pair (2, 1) has minimum sum of 3. Replace with their sum to get [3, 3, 4], which is non-decreasing.

example_2.py — Multiple Operations

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

› Output: 3

💡 Note: Step 1: Min sum pair (2,1)=3 → [4,3,3]. Step 2: Min sum pair (3,3)=6 → [4,6]. Step 3: Min sum pair (4,6)=10 → [10]. Total: 3 operations.

example_3.py — Already Sorted

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

› Output: 0

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

Visualization

Tap to expand

Understanding the Visualization

Scan for Pairs

Look at all adjacent building blocks and calculate their combined weight

Find Minimum

Identify which pairs have the minimum combined weight

Merge Leftmost

Among minimum weight pairs, merge the leftmost one first

Check Progress

See if blocks are now in increasing order of weight

Key Takeaway

🎯 Key Insight: The problem requires faithful simulation of the described process - find minimum sum adjacent pairs, pick leftmost on ties, merge, and repeat until sorted.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n) operations in worst case, each taking O(n²) to find minimum and merge

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for tracking indices and values

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁴
The array will always be sortable using the given operations

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

This problem requires direct simulation of the merging process. The optimal approach is to repeatedly find adjacent pairs with minimum sum, select the leftmost one, and merge them until the array becomes non-decreasing. The key insight is that there's no mathematical shortcut - we must simulate the exact process described in the problem.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation with Linear Search	O(n³)	O(1)	Simulate the process by repeatedly finding minimum sum pairs and merging them

Simulation with Linear Search — Algorithm Steps

Check if array is already non-decreasing
Find all adjacent pairs and their sums
Identify the minimum sum among all pairs
Find the leftmost pair with this minimum sum
Replace this pair with their sum
Increment operation count and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Min Sum Pairs

Scan array to find adjacent pairs with minimum sum

Select Leftmost

Among pairs with min sum, choose the leftmost one

Merge Pair

Replace the pair with their sum, reducing array size by 1

Check Sorted

Check if array is now non-decreasing, repeat if not

Code -

solution.c — C

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

int minimumOperations(int* nums, int numsSize) {
    int operations = 0;
    int* arr = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        arr[i] = nums[i];
    }
    int size = numsSize;
    
    while (1) {
        // Check if array is non-decreasing
        int isSorted = 1;
        for (int i = 0; i < size - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                isSorted = 0;
                break;
            }
        }
        
        if (isSorted) break;
        
        // Find minimum sum among adjacent pairs
        int minSum = INT_MAX;
        for (int i = 0; i < size - 1; i++) {
            int pairSum = arr[i] + arr[i + 1];
            if (pairSum < minSum) {
                minSum = pairSum;
            }
        }
        
        // Find leftmost pair with minimum sum
        int mergeIndex = -1;
        for (int i = 0; i < size - 1; i++) {
            if (arr[i] + arr[i + 1] == minSum) {
                mergeIndex = i;
                break;
            }
        }
        
        // Merge the pair
        arr[mergeIndex] = arr[mergeIndex] + arr[mergeIndex + 1];
        for (int i = mergeIndex + 1; i < size - 1; i++) {
            arr[i] = arr[i + 1];
        }
        size--;
        operations++;
    }
    
    free(arr);
    return operations;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n) operations in worst case, each taking O(n²) to find minimum and merge

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for tracking indices and values

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁴
The array will always be sortable using the given operations

24.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Simulation with Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler