Minimum Division Operations to Make Array Non Decreasing

Minimum Division Operations to Make Array Non Decreasing - Problem

You are given an integer array nums and your task is to transform it into a non-decreasing (sorted) array using a special mathematical operation.

The Operation: You can select any element and divide it by its greatest proper divisor. A proper divisor of a number x is any positive divisor that is strictly less than x.

Examples of proper divisors:

For 12: proper divisors are 1, 2, 3, 4, 6 (greatest is 6)
For 15: proper divisors are 1, 3, 5 (greatest is 5)
For prime numbers like 7: only proper divisor is 1

Your goal is to find the minimum number of operations needed to make the array non-decreasing. If it's impossible, return -1.

Key insight: When you divide a number by its greatest proper divisor, you're essentially reducing it to its smallest prime factor!

Input & Output

example_1.py — Basic Case

$ Input: nums = [25, 7]

› Output: 1

💡 Note: We need to reduce 25 since 25 > 7. The greatest proper divisor of 25 is 5 (since 25 = 5 × 5), so 25 ÷ 5 = 5. Now we have [5, 7] which is non-decreasing. Total operations: 1.

example_2.py — Impossible Case

$ Input: nums = [7, 7, 6]

› Output: -1

💡 Note: We need 7 ≤ 6 at index 1, but 7 is prime (only proper divisor is 1), so 7 ÷ 1 = 7. We cannot reduce 7 further, making it impossible to satisfy 7 ≤ 6. Return -1.

example_3.py — Already Sorted

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

› Output: 0

💡 Note: The array is already non-decreasing, so no operations are needed. Return 0.

Visualization

Tap to expand

Understanding the Visualization

Identify Violations

Find elements that are larger than their right neighbors

Calculate Greatest Proper Divisor

For each violation, find the largest divisor less than the number itself

Apply Division

Divide the number by its GPD to get the smallest possible reduction

Repeat Until Sorted

Continue until the array becomes non-decreasing or impossible

Key Takeaway

🎯 Key Insight: The problem reduces to finding the minimum operations to make each element small enough relative to its right neighbor, which is optimally solved by processing right-to-left and applying only necessary reductions.

Time & Space Complexity

Time Complexity

⏱️

O(n × √max(nums))

For each element, we might need to find greatest proper divisor multiple times. Finding GPD takes O(√n) time.

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
2 ≤ nums[i] ≤ 10⁶
All elements are at least 2 (no need to handle 1 or negative numbers)

Asked in

G Google 15 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a greedy right-to-left approach. Process the array from right to left, and for each element that violates the non-decreasing property, apply the minimum operations needed by repeatedly dividing by its greatest proper divisor until it becomes small enough or irreducible (prime). This greedy strategy guarantees the minimum number of operations.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Right-to-Left (Optimal)	O(n × √max(nums))	O(1)	Process array from right to left, applying minimum operations needed
Brute Force (Try All Combinations)	O(k^n)	O(k^n)	Try all possible combinations of operations on each element

Greedy Right-to-Left (Optimal) — Algorithm Steps

Start from the rightmost element (no constraints on it)
For each element from right to left, apply minimum operations needed
An element needs operations only if it's greater than the element to its right
Keep reducing until it's ≤ right neighbor or becomes irreducible (prime)
If still greater than right neighbor after all possible operations, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from Right

Begin with rightmost element - no constraints

Check Left Neighbor

If left element > right element, reduce left element

Apply Operations

Divide by greatest proper divisor until satisfied

Move Left

Continue with next element to the left

Code -

solution.c — C

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

int getGreatestProperDivisor(int n) {
    if (n <= 1) return 1;
    // Find the greatest proper divisor
    for (int i = 2; i <= sqrt(n); i++) {
        if (n % i == 0) {
            return n / i;
        }
    }
    return 1; // n is prime
}

int minOperations(int* nums, int numsSize) {
    int operations = 0;
    
    // Process from right to left
    for (int i = numsSize - 2; i >= 0; i--) {
        // While current element > next element, try to reduce it
        while (nums[i] > nums[i + 1]) {
            int gpd = getGreatestProperDivisor(nums[i]);
            if (gpd == 1) {
                // Cannot reduce further
                return -1;
            }
            nums[i] /= gpd;
            operations++;
        }
    }
    
    return operations;
}

int main() {
    int test1[] = {25, 7};
    int test2[] = {7, 7, 6};
    int test3[] = {1, 2, 3, 4, 5};
    
    printf("%d\n", minOperations(test1, 2));  // 1
    printf("%d\n", minOperations(test2, 3));  // -1
    printf("%d\n", minOperations(test3, 5));  // 0
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × √max(nums))

For each element, we might need to find greatest proper divisor multiple times. Finding GPD takes O(√n) time.

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
2 ≤ nums[i] ≤ 10⁶
All elements are at least 2 (no need to handle 1 or negative numbers)

21.0K Views

Medium Frequency

~25 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

Greedy Right-to-Left (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler