Replace Non-Coprime Numbers in Array - Practice Coding Problems

Replace Non-Coprime Numbers in Array - Problem

🔢 Replace Non-Coprime Numbers in Array

Imagine you have an array of integers, and you need to perform a merging process that combines adjacent numbers that share common factors!

Your Task: Given an array of integers nums, repeatedly find any two adjacent numbers that are non-coprime (meaning they share a common factor greater than 1), and replace them with their LCM (Least Common Multiple).

🎯 The Process:

Find any two adjacent numbers in nums that are non-coprime
If no such pair exists, stop the process
Otherwise, delete both numbers and replace them with their LCM
Repeat until no more adjacent non-coprime pairs exist

Key Concept: Two numbers x and y are non-coprime if GCD(x, y) > 1, meaning they share a common factor other than 1.

Example: [6, 4, 3, 2, 6]
• 6 and 4 are non-coprime (GCD = 2), replace with LCM = 12
• Result: [12, 3, 2, 6]
• Continue until no more merges possible...

🎉 Fascinating Property: The order of processing doesn't matter - you'll always get the same final result!

Input & Output

example_1.py — Basic Merging

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

› Output: [12, 12]

💡 Note: Step 1: GCD(6,4) = 2 > 1, so merge to LCM(6,4) = 12, array becomes [12, 3, 2, 6]. Step 2: GCD(12,3) = 3 > 1, merge to LCM(12,3) = 12, array becomes [12, 2, 6]. Step 3: GCD(2,6) = 2 > 1, merge to LCM(2,6) = 6, array becomes [12, 6]. Step 4: GCD(12,6) = 6 > 1, merge to LCM(12,6) = 12, final array is [12]. Wait, let me recalculate: After [12, 2, 6], no adjacent pairs are non-coprime initially, but we need to check systematically.

example_2.py — No Merges Needed

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

› Output: [2, 3, 5]

💡 Note: All adjacent pairs are coprime: GCD(2,3) = 1, GCD(3,5) = 1. Since no pairs share common factors greater than 1, no merging occurs and the array remains unchanged.

example_3.py — Complete Collapse

$ Input: nums = [4, 6, 12, 18]

› Output: [36]

💡 Note: Step 1: GCD(4,6) = 2 > 1, merge to LCM(4,6) = 12, array becomes [12, 12, 18]. Step 2: GCD(12,12) = 12 > 1, merge to LCM(12,12) = 12, array becomes [12, 18]. Step 3: GCD(12,18) = 6 > 1, merge to LCM(12,18) = 36, final array is [36].

Visualization

Tap to expand

Understanding the Visualization

Initialize Stack

Start with empty result stack to build our final array

Add Element

Add current input element to top of stack

Check Merge

Check if top two stack elements are non-coprime (GCD > 1)

Merge if Possible

Replace non-coprime pair with their LCM and repeat check

Continue Process

Move to next input element and repeat until array complete

Key Takeaway

🎯 Key Insight: Stack-based processing with backward merging ensures we handle all possible combinations efficiently in O(n) time while maintaining the correct order of operations.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped at most once, GCD operations are O(log min(a,b)) but bounded

✓ Linear Growth

Space Complexity

O(n)

Stack can hold up to n elements in worst case when no merges occur

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
Values in final array ≤ 10⁸
Two numbers are non-coprime if their GCD > 1

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses a stack-based approach to process elements sequentially while checking for backward merging opportunities. For each new element, we add it to our result stack and then repeatedly check if the top two elements are non-coprime (GCD > 1). When non-coprime adjacent elements are found, we replace them with their LCM and continue checking backwards until no more merges are possible. This achieves O(n) time complexity by processing each element at most twice (once when added, once when potentially merged).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Repeated Scanning)	O(n³)	O(1)	Repeatedly scan the entire array to find and merge the first non-coprime adjacent pair
Stack-Based Optimal Solution	O(n)	O(n)	Use stack to maintain result and check backward merging possibilities

Brute Force (Repeated Scanning) — Algorithm Steps

Scan array from left to right looking for adjacent non-coprime pairs
When found, calculate GCD to confirm they're non-coprime (GCD > 1)
Replace the pair with their LCM and remove one element
Restart scanning from the beginning of the modified array
Repeat until no more non-coprime adjacent pairs exist

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Scan

Scan from left to right looking for first non-coprime pair

Merge Found

Replace pair with LCM and restart from beginning

Repeat Process

Continue until no more merges possible

Code -

solution.c — C

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

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

int* replaceNonCoprimes(int* nums, int numsSize, int* returnSize) {
    int* result = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        result[i] = nums[i];
    }
    int size = numsSize;
    
    while (1) {
        int merged = 0;
        for (int i = 0; i < size - 1; i++) {
            int g = gcd(result[i], result[i + 1]);
            if (g > 1) {
                long long lcmVal = (long long)result[i] * result[i + 1] / g;
                result[i] = (int)lcmVal;
                for (int j = i + 1; j < size - 1; j++) {
                    result[j] = result[j + 1];
                }
                size--;
                merged = 1;
                break;
            }
        }
        if (!merged) break;
    }
    
    *returnSize = size;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

In worst case, we might need O(n) merging operations, each requiring O(n) scan, and each GCD/LCM calculation takes O(log min(a,b))

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for GCD/LCM calculations and loop variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
Values in final array ≤ 10⁸
Two numbers are non-coprime if their GCD > 1

28.5K Views

Medium Frequency

~25 min Avg. Time

892 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

🔢 Replace Non-Coprime Numbers in Array

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Repeated Scanning) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler