Hallo.

Thanks for the contribution. (and sorry for the long wait)

While the implementation works, I'm not particularly happy about it.
What I don't like:

• The input parameter num is a long long, which kinda suggests that this function works also for numbers that are bigger than ints.
  However, this function needs to know all prime numbers until the num, which you probably don't have for such big numbers.
• And also this method presented here is kinda slow, as it also needs to visit all primes that exist up to num. E.g. if num ~= 10^9, than there are ~50 000 000 prime numbers that you visit every time.

A better implementation would be something like the following. It actually doesn't require a list of prime numbers, and also requires a lot less modulo tests. E.g. for num ~= 10^9 your code does ~50 000 000 modulo operations, while the following code only does $\sqrt{10^9} ~= 34 000$ many as it uses the typical trick of factorizing the prime number by going up to the root of the number (https://cp-algorithms.com/algebra/factorization.html#trial-division). It also works reasonable fast for larger numbers.
(and it could even be improved, if you skip the even numbers).

long long numberOfDivisors(long long num) {
    long long total = 1;
    for (int i = 2; (long long)i * i <= num; i++) {
        if (num % i == 0) {
            int e = 0;
            do {
                e++;
                num /= i;
            } while (num % i == 0);
            total *= e + 1;
        }
    }
    // handle the last prime
    if (num > 1) {
        total *= 2;
    }
    return total;
}

As comparison, your code runs in $O(n / \log{n})$ (as there are that many primes up to $n$), and my code runs in $O(\sqrt{n})$.

Alternatively, you could even do it a lot faster, if you precompute a lot of stuff.
If you precompute the largest prime factor of every number, you can compute the the number of divisors in $O(\log{n})$ time. See https://github.com/jakobkogler/Algorithm-DataStructures/blob/master/Math/Divisors.h
This thou has the disadvantage, that it requires a lot of memory. So it also doesn't work for large numbers.

Would you be interested in adding that code (the $O(\sqrt{n})$ one) and also adapting it to the sum of divisors?

Btw, for the sum of divisors you don't need to use the pow function, you can instead just multiple by p in the loop instead of incrementing the counter.

Awesome. Thanks.