Sorted GCD Pair Queries - Practice Coding Problems

Sorted GCD Pair Queries - Problem

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

Given an integer array nums of length n and an array of queries, you need to answer queries about GCD pairs.

Here's how it works:

Calculate the Greatest Common Divisor (GCD) of all possible pairs (nums[i], nums[j]) where 0 ≤ i < j < n
Sort all these GCD values in ascending order to form the gcdPairs array
For each query queries[i], return the element at index queries[i] in the sorted gcdPairs array

Example: If nums = [2, 3, 4], the pairs are (2,3), (2,4), (3,4) with GCDs [1, 2, 1]. After sorting: [1, 1, 2].

Return an array answer where answer[i] corresponds to gcdPairs[queries[i]].

Input & Output

example_1.py — Basic Example

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

› Output: [1, 2, 2]

💡 Note: Pairs are (2,3), (2,4), (3,4) with GCDs [1, 2, 1]. After sorting: [1, 1, 2]. Query 0→1, Query 2→2, Query 2→2.

example_2.py — Larger Array

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

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

💡 Note: 6 pairs: (4,4)→4, (4,2)→2, (4,1)→1, (4,2)→2, (4,1)→1, (2,1)→1. Sorted: [1,1,1,2,2,4]. Queries return [4,2,1,1].

example_3.py — Edge Case

$ Input: nums = [1, 1], queries = [0]

› Output: [1]

💡 Note: Only one pair (1,1) with GCD=1. Query 0 returns the first (and only) element: 1.

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 2 × 10⁴
1 ≤ queries.length ≤ 10⁵
0 ≤ queries[i] < nums.length × (nums.length - 1) / 2
All query indices are valid (within bounds of gcdPairs array)

Visualization

Tap to expand

Understanding the Visualization

Brute Force Approach

Generate all pairs and calculate GCDs - simple but inefficient O(n²)

Frequency Analysis

Count occurrences of each number to avoid redundant calculations

Mathematical Insight

Use number theory: count pairs by GCD value using divisibility

Inclusion-Exclusion

Remove overcounted pairs to get exact counts for each GCD

Key Takeaway

🎯 Key Insight: The breakthrough comes from realizing we don't need to generate all pairs. Instead, we can mathematically count how many pairs will have each possible GCD value, dramatically reducing complexity from O(n²) to O(M log M).

Asked in

G Google 45 a Amazon 32 ⊞ Microsoft 28 f Meta 18

The optimal approach uses frequency counting and the inclusion-exclusion principle to avoid generating all O(n²) pairs. Instead of calculating GCD for each pair, we count how many pairs have each possible GCD value using mathematical properties. This reduces time complexity from O(n²) to O(M log M) where M is the maximum value in the array.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Pairs)	O(n² log(max(nums)) + n² log(n²))	O(n²)	Generate all possible pairs, calculate their GCDs, sort, and answer queries
Frequency Counting + Binary Search (Optimal)	O(M log M + Q log M)	O(M)	Count GCD frequencies using number theory, then use binary search on cumulative counts

Brute Force (Generate All Pairs) — Algorithm Steps

Generate all pairs (nums[i], nums[j]) where i < j
Calculate GCD for each pair using Euclidean algorithm
Store all GCD values in an array
Sort the GCD array in ascending order
Answer each query by accessing gcdPairs[queries[i]]

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Pairs

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

Calculate GCDs

Use Euclidean algorithm for each pair

Sort Results

Sort all GCD values in ascending order

Answer Queries

Direct index access to answer each query

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.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* gcdQueries(int* nums, int numsSize, int* queries, int queriesSize, int* returnSize) {
    int pairCount = numsSize * (numsSize - 1) / 2;
    int* gcdPairs = (int*)malloc(pairCount * sizeof(int));
    int idx = 0;
    
    // Generate all pairs and calculate GCDs
    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 values
    qsort(gcdPairs, pairCount, 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;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log(max(nums)) + n² log(n²))

O(n²) pairs × O(log(max)) for GCD + O(n² log n) for sorting

⚠ Quadratic Growth

Space Complexity

O(n²)

Need to store all n×(n-1)/2 GCD values

⚠ Quadratic Space

23.2K 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 (Generate All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler