Finding abundant numbers from 1 to 10 million using a sum my task is to implement algorithm in C of finding abudant numbers from 1 to 10 million. Fistly I don't really understand mathematics.
There is several ways how to do it, but efficient and fast (for that BIG input 10 mil) might be by summing - NOT dividing, NOT multiplying, NOT EVEN using remainder after the division. Just sum.
But I'm really confused WHAT to sum. Please guys help, appreciate every single answer.
 A: The following naive sieve approach takes only 30 seconds on my modest PC.
#define abLimit 10000000
int i, j, *xp;

xp = (int*) calloc(abLimit, 4);

for (i=2; i<abLimit, i++)
    for (j=i*2; j<abLimit; j+= i)
        xp[j] += i;

for (i=2; i<abLimit; i++)
    if (xp[i] > i)
        printf("%d is abundant\n", i);

free(xp);

Basically, it builds a table of $\sigma(n)$. It does not require any factorisation into primes, which makes it quick. I suggest you dry run it for a small value of abLimit to see what it's doing. Some pruning may reduce the run-time to under a second.
A: A modern computer can factor the integers from 1 to 10 million in well under an hour, using even the most naive algorithms. Maybe post the code you've already written that is too slow, and we can help you spot problems with it?
However, if you're looking for something more efficient than computing $\sigma(n)$ directly, you could try a sieve approach: let's suppose you want to find all integers less than $N$ that are abundant.
First, you will need all of the primes less than $N$. You can compute these yourself, or use any of the several large tables available on the Internet. Let $p_i$ denote the $i$th prime. For each prime, compute the set $S_i$ of all nonnegative powers of that prime that are less than $N$.
Now, systematically examine all numbers formed by taking an element of $S_1$, multiplying it by an element of $S_2$, an element from $S_3$, etc. As you construct this product $n$, also construct $\sigma$ of that product, using the fact that $\sigma$ is multiplicative. If during the construction process the product ever exceeds $N$, skip it. Otherwise, compare $\sigma(n)$ to $2n$ and accumulate a list of the numbers you have constructed that are abundant.
If implemented poorly the above will be slower than brute-force search, so ask here or on Stackoverflow if you need any help.
