GCD Sort of an Array

GCD Sort of an Array - Problem

Array Math Union Find Sorting Number Theory Hard

You are given an integer array nums, and you can perform the following operation any number of times on nums:

Swap the positions of two elements nums[i] and nums[j] if gcd(nums[i], nums[j]) > 1 where gcd(nums[i], nums[j]) is the greatest common divisor of nums[i] and nums[j].

Return true if it is possible to sort nums in non-decreasing order using the above swap method, or false otherwise.

Input & Output

Example 1 — Numbers with Common Factors

$ Input: nums = [7,21,3]

› Output: true

💡 Note: We can swap 21 and 3 since gcd(21,3) = 3 > 1, giving us [7,3,21]. This is sorted in non-decreasing order.

Example 2 — Numbers without Sufficient Connections

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

› Output: false

💡 Note: gcd(5,2)=1, gcd(5,6)=1, gcd(2,6)=2>1, gcd(2,2)=2>1. The 5 cannot be moved from position 0, but it needs to be at position 2 in the sorted array [2,2,5,6].

Example 3 — Already Sorted

$ Input: nums = [10,5,9,3,15]

› Output: false

💡 Note: gcd(10,5)=5>1, gcd(9,3)=3>1, gcd(9,15)=3>1, gcd(3,15)=3>1. However, the components are [10,5] and [9,3,15]. Number 5 needs to be at position 1 in sorted array [3,5,9,10,15], but it can only reach positions in component with 10.

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
2 ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 12 F Facebook 8

The key insight is that numbers can only be swapped if their GCD > 1, creating connected components. Each number must be able to reach its target sorted position within its connected component. The optimal approach uses Union-Find to efficiently identify these components and verify sortability. Time: O(n² × log(max)), Space: O(n).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force Simulation

⏱️ Time: O(n³ × log(max)) Space: O(n)

Keep attempting swaps between elements with GCD > 1 until either the array becomes sorted or we can't make any more valid swaps. This simulates the actual swapping process.

Union-Find Connected Components

⏱️ Time: O(n² × log(max)) Space: O(n)

Build a Union-Find structure to identify connected components of numbers that can be swapped with each other. Then verify that each number's current position and target position belong to the same component.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_SIZE 1000

static int parent[MAX_SIZE];
static int rank_arr[MAX_SIZE];
static int nums[MAX_SIZE];
static int sorted_nums[MAX_SIZE];

void init_union_find(int size) {
    for (int i = 0; i < size; i++) {
        parent[i] = i;
        rank_arr[i] = 0;
    }
}

int find(int x) {
    if (parent[x] != x) {
        parent[x] = find(parent[x]);
    }
    return parent[x];
}

void union_sets(int x, int y) {
    int px = find(x);
    int py = find(y);
    if (px == py) return;
    
    if (rank_arr[px] < rank_arr[py]) {
        int temp = px;
        px = py;
        py = temp;
    }
    parent[py] = px;
    if (rank_arr[px] == rank_arr[py]) {
        rank_arr[px]++;
    }
}

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);
}

int solution(int n) {
    // Copy nums to sorted_nums and sort
    for (int i = 0; i < n; i++) {
        sorted_nums[i] = nums[i];
    }
    qsort(sorted_nums, n, sizeof(int), compare);
    
    init_union_find(n);
    
    // Union positions that can be swapped
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (gcd(nums[i], nums[j]) > 1) {
                union_sets(i, j);
            }
        }
    }
    
    // For each unique value, check if current positions can reach target positions
    for (int val_idx = 0; val_idx < n; val_idx++) {
        int val = nums[val_idx];
        
        // Find all current positions of this value
        int current_positions[MAX_SIZE];
        int current_count = 0;
        for (int i = 0; i < n; i++) {
            if (nums[i] == val) {
                current_positions[current_count++] = i;
            }
        }
        
        // Find all target positions of this value
        int target_positions[MAX_SIZE];
        int target_count = 0;
        for (int i = 0; i < n; i++) {
            if (sorted_nums[i] == val) {
                target_positions[target_count++] = i;
            }
        }
        
        if (current_count != target_count) {
            return 0;
        }
        
        // Group by connected components
        int current_components[MAX_SIZE] = {0};
        int target_components[MAX_SIZE] = {0};
        
        for (int i = 0; i < current_count; i++) {
            int root = find(current_positions[i]);
            current_components[root]++;
        }
        
        for (int i = 0; i < target_count; i++) {
            int root = find(target_positions[i]);
            target_components[root]++;
        }
        
        // Check if components match
        for (int i = 0; i < n; i++) {
            if (current_components[i] != target_components[i]) {
                return 0;
            }
        }
    }
    
    return 1;
}

int main() {
    char line[10000];
    if (fgets(line, sizeof(line), stdin) == NULL) {
        printf("false");
        return 0;
    }
    
    // Parse JSON array
    int n = 0;
    char *ptr = line;
    
    // Find opening bracket
    while (*ptr && *ptr != '[') ptr++;
    if (!*ptr) {
        printf("false");
        return 0;
    }
    ptr++; // skip '['
    
    // Parse numbers
    while (*ptr && *ptr != ']') {
        while (*ptr == ' ' || *ptr == ',') ptr++;
        if (*ptr == ']') break;
        
        nums[n] = (int)strtol(ptr, &ptr, 10);
        n++;
        
        while (*ptr == ' ') ptr++;
    }
    
    if (n == 0) {
        printf("true");
        return 0;
    }
    
    int result = solution(n);
    printf("%s", result ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~25 min Avg. Time

485 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