Sorted GCD Pair Queries

Sorted GCD Pair Queries - Problem

Array Hash Table Math Binary Search Combinatorics Counting Number Theory Prefix Sum Hard

You are given an integer array nums of length n and an integer array queries.

Let gcdPairs denote an array obtained by calculating the GCD of all possible pairs (nums[i], nums[j]), where 0 <= i < j < n, and then sorting these values in ascending order.

For each query queries[i], you need to find the element at index queries[i] in gcdPairs.

Return an integer array answer, where answer[i] is the value at gcdPairs[queries[i]] for each query.

The term gcd(a, b) denotes the greatest common divisor of a and b.

Input & Output

Example 1 — Basic Case

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

› Output: [1,2,2]

💡 Note: All pairs: (2,3)→gcd=1, (2,4)→gcd=2, (3,4)→gcd=1. Sorted gcdPairs = [1,1,2]. Query results: gcdPairs[0]=1, gcdPairs[2]=2, gcdPairs[2]=2

Example 2 — Duplicates

$ Input: nums = [4,4,2,1], queries = [5,3,1,0]

› Output: [4,2,1,1]

💡 Note: All pairs: (4,4)→gcd=4, (4,2)→gcd=2, (4,1)→gcd=1, (4,2)→gcd=2, (4,1)→gcd=1, (2,1)→gcd=1. Sorted gcdPairs = [1,1,1,2,2,4]. Results: [4,2,1,1]

Example 3 — Small Array

$ Input: nums = [6,9], queries = [0]

› Output: [3]

💡 Note: Only one pair: (6,9)→gcd=3. So gcdPairs = [3] and gcdPairs[0] = 3

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 5 × 10⁴
1 ≤ queries.length ≤ 10⁵
0 ≤ queries[i] < nums.length × (nums.length - 1) / 2

Visualization

Tap to expand

Asked in

G Google 42 M Meta 38 a Amazon 35 m Microsoft 28

The key insight is that instead of generating all O(n²) pairs explicitly, we can use frequency counting and mathematical properties to calculate GCD pair counts efficiently. The brute force approach generates all pairs directly, while the optimized approach uses divisor enumeration and inclusion-exclusion principle. Best approach depends on input size: brute force is simpler for small inputs, optimized is better for large arrays with many duplicates. Time: O(n² log n) brute force vs O(n log n + d² log d) optimized, Space: O(n²) vs O(d)

Common Approaches

✓ Brute Force - Calculate All Pairs

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

Calculate GCD for every possible pair (i,j) where i < j, store all results in an array, sort the array, then for each query simply return the element at the requested index.

Frequency Counting with Divisor Enumeration

⏱️ Time: O(n log n + d² log d) Space: O(d)

Instead of generating all pairs explicitly, count frequency of each unique number, then for each possible GCD value, calculate how many pairs would have that GCD using mathematical properties and inclusion-exclusion principle.

Brute Force - Calculate All Pairs — Algorithm Steps

Generate all pairs (i,j) where i < j
Calculate GCD for each pair
Sort all GCD values
Answer each query by direct indexing

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Pairs

Create all (i,j) pairs where i < j

Calculate GCD

Find GCD for each pair

Sort & Query

Sort GCDs and answer queries

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.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);
}

int* solution(int* nums, int numsSize, int* queries, int queriesSize, int* returnSize) {
    int pairsCount = (numsSize * (numsSize - 1)) / 2;
    int* gcdPairs = (int*)malloc(pairsCount * sizeof(int));
    int idx = 0;
    
    // Generate all GCD pairs
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            gcdPairs[idx++] = gcd(nums[i], nums[j]);
        }
    }
    
    // Sort the GCD pairs
    qsort(gcdPairs, pairsCount, sizeof(int), compare);
    
    // Answer queries
    int* result = (int*)malloc(queriesSize * sizeof(int));
    for (int i = 0; i < queriesSize; i++) {
        result[i] = gcdPairs[queries[i]];
    }
    
    *returnSize = queriesSize;
    free(gcdPairs);
    return result;
}

int main() {
    char line[10000];
    int nums[1000], queries[1000];
    int numsSize = 0, queriesSize = 0;
    
    // Read first line (nums array)
    if (fgets(line, sizeof(line), stdin)) {
        char* ptr = line;
        // Skip '['
        while (*ptr && *ptr != '[') ptr++;
        if (*ptr == '[') ptr++;
        
        // Parse numbers
        char* endptr;
        while (*ptr && *ptr != ']') {
            while (*ptr == ' ' || *ptr == ',') ptr++;
            if (*ptr == ']') break;
            nums[numsSize++] = (int)strtol(ptr, &endptr, 10);
            ptr = endptr;
        }
    }
    
    // Read second line (queries array)
    if (fgets(line, sizeof(line), stdin)) {
        char* ptr = line;
        // Skip '['
        while (*ptr && *ptr != '[') ptr++;
        if (*ptr == '[') ptr++;
        
        // Parse numbers
        char* endptr;
        while (*ptr && *ptr != ']') {
            while (*ptr == ' ' || *ptr == ',') ptr++;
            if (*ptr == ']') break;
            queries[queriesSize++] = (int)strtol(ptr, &endptr, 10);
            ptr = endptr;
        }
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, queries, queriesSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

O(n²) to generate all pairs, O(log max_value) for each GCD calculation, O(n² log n²) for sorting

⚡ Linearithmic

Space Complexity

O(n²)

Storage for all n²/2 GCD pairs in the result array

✓ Linear Space

25.0K Views

Medium Frequency

~35 min Avg. Time

856 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 - Calculate All Pairs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler