GCD Sort of an Array - Practice Coding Problems

GCD Sort of an Array - Problem

Array Math Union Find Sorting Number Theory Hard

Imagine you have an array of numbers, but you can only swap two numbers if they share a common factor greater than 1 (their GCD > 1). Your goal is to determine whether you can sort this array in non-decreasing order using only these restricted swaps.

The Greatest Common Divisor (GCD) of two numbers is the largest positive integer that divides both numbers. For example:

gcd(6, 9) = 3 → Can swap because 3 > 1
gcd(4, 10) = 2 → Can swap because 2 > 1
gcd(7, 11) = 1 → Cannot swap because 1 is not > 1

This problem tests your understanding of connected components and number theory. Elements that can be transitively swapped through a chain of GCD relationships form a connected group, and within each group, elements can be arranged in any order.

Input & Output

example_1.py — Basic Case

$ Input: [7, 21, 3]

› Output: true

💡 Note: We can swap 21 and 3 since gcd(21,3) = 3 > 1, giving us [7, 3, 21]. Then we can swap 7 and 3 since gcd(7,3) = 1... wait, this is actually false since 7 and 3 are coprime!

example_2.py — Sortable Array

$ Input: [5, 20, 3, 15, 9]

› Output: true

💡 Note: Multiple swaps possible: gcd(20,15)=5, gcd(15,9)=3, etc. Through a series of valid swaps, we can achieve the sorted order [3, 5, 9, 15, 20].

example_3.py — Already Sorted

$ Input: [2, 3, 4]

› Output: true

💡 Note: Array is already sorted in non-decreasing order, so no swaps needed. Return true.

Visualization

Tap to expand

Understanding the Visualization

Identify Friendships

Two numbers are 'friends' if gcd > 1 (share a prime factor)

Form Friend Groups

Use Union-Find to create connected components of friends

Check Group Capabilities

Each friend group must contain exactly the elements needed for their target positions

Verify Sortability

If all groups have the right elements, sorting is possible

Key Takeaway

🎯 Key Insight: Numbers that share prime factors form connected components where any arrangement is achievable through valid GCD swaps.

Time & Space Complexity

Time Complexity

⏱️

O(n³ × log(max(nums)))

For each of O(n²) iterations, we check O(n²) pairs and compute GCD in O(log(max(nums))) time

⚠ Quadratic Growth

Space Complexity

O(n)

Space for the working copy of the array

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
2 ≤ nums[i] ≤ 10⁵
All elements are at least 2 (no 1's that would make GCD always 1)

Asked in

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

The optimal solution uses Union-Find data structure to group numbers that share prime factors. Two numbers can be swapped if they share a common factor > 1, which means they must share at least one prime factor. By connecting all numbers to their prime factors, we create connected components where elements can be freely rearranged through a series of swaps. The key insight is checking whether each connected component contains the right elements to fill their target sorted positions.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Swaps)	O(n³ × log(max(nums)))	O(n)	Repeatedly find valid swaps and check if array becomes sorted
Union-Find (Optimal)	O(n√M + n log n)	O(M)	Group numbers by shared prime factors using Union-Find, then check if sorting is possible within each group

Brute Force (Try All Swaps) — Algorithm Steps

Create a copy of the original array to work with
Repeat until no changes: find all pairs (i,j) where gcd(nums[i], nums[j]) > 1
For each valid pair, check if swapping would improve the sorting
Perform beneficial swaps
Check if the final array is sorted in non-decreasing order

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with the original array [7, 21, 3]

Find Valid Pairs

Check all pairs: gcd(7,21)=7>1, gcd(7,3)=1, gcd(21,3)=3>1

Apply Beneficial Swaps

Swap elements that improve sorting: 21 and 3

Repeat Until No Changes

Continue until no more beneficial swaps possible

Code -

solution.c — C

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

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

bool gcdSort(int* nums, int n) {
    int* arr = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) arr[i] = nums[i];
    
    bool changed = true;
    while (changed) {
        changed = false;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (gcd(arr[i], arr[j]) > 1 && arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                    changed = true;
                }
            }
        }
    }
    
    int* sorted_nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) sorted_nums[i] = nums[i];
    qsort(sorted_nums, n, sizeof(int), compare);
    
    bool result = true;
    for (int i = 0; i < n; i++) {
        if (arr[i] != sorted_nums[i]) {
            result = false;
            break;
        }
    }
    
    free(arr);
    free(sorted_nums);
    return result;
}

int main() {
    int nums[] = {7, 21, 3};
    printf("%s\n", gcdSort(nums, 3) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ × log(max(nums)))

For each of O(n²) iterations, we check O(n²) pairs and compute GCD in O(log(max(nums))) time

⚠ Quadratic Growth

Space Complexity

O(n)

Space for the working copy of the array

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
2 ≤ nums[i] ≤ 10⁵
All elements are at least 2 (no 1's that would make GCD always 1)

28.4K 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Swaps) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler