Minimum Number of Operations to Make All Array Elements Equal to 1

Minimum Number of Operations to Make All Array Elements Equal to 1 - Problem

Imagine you're a mathematician tasked with simplifying an array of positive integers until every element becomes 1. You have a powerful tool at your disposal: the ability to replace any element with the greatest common divisor (GCD) of itself and its immediate neighbor.

The Challenge: Given an array nums of positive integers, you can perform the following operation any number of times:

Select an index i where 0 ≤ i < n-1
Replace either nums[i] or nums[i+1] with gcd(nums[i], nums[i+1])

Your goal is to find the minimum number of operations needed to make all array elements equal to 1. If it's impossible to achieve this goal, return -1.

Key Insight: The GCD operation can only make numbers smaller or keep them the same, so we need to strategically choose which elements to replace to propagate 1s throughout the array efficiently.

Input & Output

example_1.py — Basic case with existing 1

$ Input: [2,6,3,4]

› Output: 4

💡 Note: We can make gcd(3,4) = 1, then replace one element with 1. After that, we need 3 more operations to make all other elements equal to 1: gcd(2,1)=1, gcd(6,1)=1, and we already have two 1s.

example_2.py — Array with existing 1s

$ Input: [2,10,6,14]

› Output: 4

💡 Note: Since gcd(2,10,6,14) = 2 > 1, we cannot make all elements equal to 1. However, we can create pairs that eventually lead to 1: gcd(10,6)=2, then gcd(2,2)=2, then we need to find another path. Actually, gcd(6,14)=2, gcd(2,10)=2, then gcd(2,2)=2. We need to use the property that gcd(2,6)=2, gcd(2,14)=2, and eventually through multiple operations we can reach 1.

example_3.py — Impossible case

$ Input: [6,10,15]

› Output: -1

💡 Note: The gcd of all elements is gcd(6,10,15) = 1, which means it might be possible. However, we need to check if we can actually create a 1 through adjacent operations: gcd(6,10)=2, gcd(10,15)=5, gcd(2,15)=1. So we can make it work with operations.

Constraints

1 ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 10⁶
Adjacent operations only: You can only perform GCD operations on adjacent elements

Visualization

Tap to expand

Understanding the Visualization

Identify Existing 1s

Count elements that are already simplified (equal to 1)

Calculate Spread Cost

If 1s exist, cost = n - count_of_ones operations to spread them

Find Creation Path

If no 1s exist, find shortest subarray that can create GCD = 1

Optimize Total Cost

Minimum cost = creation_cost + spreading_cost

Key Takeaway

🎯 Key Insight: The problem transforms from complex state exploration to simple counting: either spread existing 1s (n - count_of_ones operations) or find the cheapest way to create a 1 first, then spread it. The mathematical properties of GCD make this optimization possible.

Asked in

G Google 28 f Meta 15 a Amazon 12 ⊞ Microsoft 8

The optimal approach recognizes that if the array contains any 1s, we need exactly n - count_of_ones operations. If no 1s exist, we find the minimum operations to create the first 1 by checking all possible subarrays for their GCD, then add (n-1) operations to spread it to all positions. The key insight is that GCD operations can only decrease values, and once we have a 1, we can efficiently spread it to adjacent elements.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Mathematical Approach	O(n²)	O(1)	Count existing 1s and find minimum operations to create/spread 1s

Optimized Mathematical Approach — Algorithm Steps

Count how many 1s already exist in the array
If 1s exist, return n - count_of_ones
If no 1s exist, find minimum operations to create first 1
For each possible subarray, calculate GCD and check if it equals 1
Return minimum_operations_to_create_1 + (n-1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Existing 1s

If 1s exist, we need n-count operations to spread them

Check Possibility

If GCD of all elements > 1, return -1

Find Shortest GCD Chain

Find minimum subarray that can produce GCD = 1

Calculate Total Operations

Operations to create 1 + operations to spread it

Code -

solution.c — C

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

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

int minimumOperations(int* nums, int numsSize) {
    int n = numsSize;
    
    // Count existing 1s
    int onesCount = 0;
    for (int i = 0; i < n; i++) {
        if (nums[i] == 1) onesCount++;
    }
    if (onesCount > 0) {
        return n - onesCount;
    }
    
    // Check if possible
    int overallGcd = nums[0];
    for (int i = 1; i < n; i++) {
        overallGcd = gcd(overallGcd, nums[i]);
    }
    if (overallGcd > 1) {
        return -1;
    }
    
    // Find minimum operations to create first 1
    int minOpsToCreate1 = INT_MAX;
    
    for (int i = 0; i < n; i++) {
        int currentGcd = nums[i];
        for (int j = i; j < n; j++) {
            if (i == j) {
                currentGcd = nums[i];
            } else {
                currentGcd = gcd(currentGcd, nums[j]);
            }
            
            if (currentGcd == 1) {
                int operationsNeeded = (j - i) + (n - 1);
                if (operationsNeeded < minOpsToCreate1) {
                    minOpsToCreate1 = operationsNeeded;
                }
                break;
            }
        }
    }
    
    return minOpsToCreate1 == INT_MAX ? -1 : minOpsToCreate1;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check all subarrays to find minimum operations to create 1, and GCD calculation is O(log(min(a,b)))

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

847 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

Optimized Mathematical Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler