Replace Non-Coprime Numbers in Array

Replace Non-Coprime Numbers in Array - Problem

You are given an array of integers nums. Perform the following steps:

Find any two adjacent numbers in nums that are non-coprime.
If no such numbers are found, stop the process.
Otherwise, delete the two numbers and replace them with their LCM (Least Common Multiple).
Repeat this process as long as you keep finding two adjacent non-coprime numbers.

Return the final modified array. It can be shown that replacing adjacent non-coprime numbers in any arbitrary order will lead to the same result.

Two values x and y are non-coprime if GCD(x, y) > 1 where GCD(x, y) is the Greatest Common Divisor of x and y.

Input & Output

Example 1 — Basic Merging

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

› Output: [84]

💡 Note: Using stack approach: 6→[6], then 4 merges with 6 to get LCM(6,4)=12→[12], then 3 merges with 12 to get LCM(12,3)=12→[12], then 2 merges with 12 to get LCM(12,2)=12→[12], finally 21 merges with 12 to get LCM(12,21)=84→[84].

Example 2 — Simple Case

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

› Output: [2,3,4]

💡 Note: GCD(2,3)=1 and GCD(3,4)=1, all pairs are coprime, so no merging occurs. Return original array.

Example 3 — Complete Merge

$ Input: nums = [4,6,15,35]

› Output: [420]

💡 Note: GCD(6,15)=3>1, merge to get [4,30,35]. Then GCD(4,30)=2>1, merge to get [60,35]. Finally GCD(60,35)=5>1, merge to get [420].

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
The final array values are ≤ 10⁸

Visualization

Tap to expand

Asked in

G Google 15 f Meta 8 M Microsoft 6

The key insight is that adjacent non-coprime numbers (GCD > 1) must be merged into their LCM, and this process cascades. The optimal approach uses a stack to handle cascading merges efficiently in a single pass. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Repeated Scanning

⏱️ Time: O(n²) Space: O(1)

Keep scanning the array from start to end. When we find the first pair of adjacent non-coprime numbers, merge them into their LCM and start over. Repeat until no more merges are possible.

Stack-Based Approach

⏱️ Time: O(n) Space: O(n)

Process elements left to right using a stack. For each element, check if it can merge with stack top. If yes, merge and continue checking (handle cascading merges). If no, push to stack.

Brute Force - Repeated Scanning — Algorithm Steps

Step 1: Scan array for first adjacent non-coprime pair
Step 2: If found, replace pair with their LCM
Step 3: Repeat from beginning until no pairs found

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Array

Look for first adjacent non-coprime pair

Merge Found

Replace pair with their LCM

Restart

Start scanning from beginning again

Code -

solution.c — C

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

static int nums[1000];

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

long long lcm(int a, int b) {
    return ((long long)a * b) / gcd(a, b);
}

int* solution(int* nums, int* size) {
    while (1) {
        int merged = 0;
        for (int i = 0; i < *size - 1; i++) {
            if (gcd(nums[i], nums[i + 1]) > 1) {
                long long newVal = lcm(nums[i], nums[i + 1]);
                nums[i] = (int)newVal;
                // Shift elements left
                for (int j = i + 1; j < *size - 1; j++) {
                    nums[j] = nums[j + 1];
                }
                (*size)--;
                merged = 1;
                break;
            }
        }
        if (!merged) break;
    }
    return nums;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int size = 0;
    
    // Handle empty array
    if (strcmp(line, "[]") == 0) {
        printf("[]\n");
        return 0;
    }
    
    // Parse JSON array manually
    int len = strlen(line);
    int i = 1; // skip '['
    
    while (i < len - 1) { // stop before ']'
        while (i < len && (line[i] == ' ' || line[i] == ',')) i++;
        if (i >= len - 1) break;
        
        int num = 0;
        while (i < len && line[i] != ',' && line[i] != ']') {
            if (line[i] >= '0' && line[i] <= '9') {
                num = num * 10 + (line[i] - '0');
            }
            i++;
        }
        nums[size++] = num;
    }
    
    solution(nums, &size);
    
    printf("[");
    for (int i = 0; i < size; i++) {
        printf("%d", nums[i]);
        if (i < size - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, each merge requires full array scan, and we may need O(n) merges

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.0K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Repeated Scanning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler