Set is an abstract data type that only stores unique elements. In C++ sets are implemented as a binary search tree and the elements can be accessed in a sorted order.

In Python sets are unordered.

In general, operation complexity in a set is as follows:

insert : O(logn)
delete : O(logn)
lookup : O(logn) 

In Python sets are mathematical sets which also support set difference and set intersection.

Sets have a varient Multiset that also stores multiple values.

Set ADT can be used in computations where you are dealing with unique elements.

The greatest common divisor (gcd) of two or more integers, when at least one of them is not zero, is the largest positive integer that divides the numbers without a remainder.

The GCD of more than two numbers can be calculated as

GCD(a,b,c) = GCD(GCD(a,b),c)

The most famous method of finding GCD is the Euclidean GCD Algorithm:

Euclidean GCD Algorithm

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

    Recursive version  

    int gcd(a, b) {
        if (b = 0) 
            return a
        else
            return gcd(b, a mod b)
    }

Divisors of a number are numbers , where and .
Depending on the requirement of the challenge, we have two good methods to calculate divisors.

When we have , and we have few numbers to calculate the divisors of, we can check every number from to , and if , we add and to our set of divisors.

set<int> arr;
for (int i = 1;i < sqrt(N) + 1; i++) {
    if (N % i == 0) {
        arr.insert(i);
        arr.insert(N / i);
    }
}

If and we have a lot of queries, we can build a sieve such that Ar[x] contains the divisors.

vector <vector <int> > divisors(1000001, vector<int> ());
for (int k = 1; k < 1000001; k++) {
    for (int i = 1; i < 1000001/k; i++) {
        divisors[i * k].push_back(k);
    }
}

Now for each query Q, divisors[Q] contains all the divisors.