# Sum of all proper divisors of natural numbers in an array

Given an array of natural numbers count the sum of its proper divisors for every element in array.

```Input  : int arr[] = {8, 13, 24, 36, 59, 75, 87}
Output : 7 1 36 55 1 49 21
Number 8 has 3 proper divisors 1, 2, 4
and their sum comes out to be 7.
```

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

A naive solution to this problem has been discussed in below post.
Sum of all proper divisors of a natural number

We can do this more efficiently by making use of sieve of Eratosthenes.

The idea is based on prime factorization of a number. By using sieve we can store all the prime factors of a number and their powers.

```To find all divisors, we need to consider
all powers of a prime factor and multiply
it with all all powers of other prime factors.
(For example, if the number is 36, its prime
factors are 2 and 3 and all divisors are 1,
2, 3, 4, 6, 9, 12 and 18.

Consider a number N can be written
as P1^Q1 * P2^Q2 * P3^Q3 (here only 3
prime factors are considered but there can
be more than that) then sum of its divisors
will be written as:
= P1^0 * P2^0 * P3^0 + P1^0 * P2^0 * P3^1 +
P1^0 * P2^0 * P3^2 + ................ +
P1^0 * P2^0 * P3^Q3 + P1^0 * P2^1 * P3^0 +
P1^0 * P2^1 * P3^1 + P1^0 * P2^1 * P3^2 +
................ + P1^0 * P2^1 * P3^Q3 +
.
.
.
P1^Q1 * P2^Q2 * P3^0 + P1^Q1 * P2^Q2 * P3^1 +
P1^Q1 * P2^Q2 * P3^2 + .......... +
P1^Q1 * P2^Q2 * P3^Q3

Above can be written as,
(((P1^(Q1+1)) - 1) /
(P1 - 1)) * (((P2^(Q2+1)) - 1) /
(P2 - 1)) * (((P3^(Q3 + 1)) - 1) /
(P3 - 1))
```

Below is implementation based on above formula.

 `// C++ program to find sum of proper divisors for ` `// every element in an array. ` `#include ` `using` `namespace` `std; ` `#define MAX 1000001 ` `#define pii pair ` `#define F first ` `#define S second ` ` `  `// To store prime factors and their ` `// powers ` `vector factors[MAX]; ` ` `  `// Fills factors such that factors[i] is ` `// a vector of pairs containing prime factors ` `// (of i) and their powers. ` `// Also sets values in isPrime[] ` `void` `sieveOfEratothenese() ` `{ ` `    ``// To check if a number is prime ` `    ``bool` `isPrime[MAX]; ` `    ``memset``(isPrime, ``true``, ``sizeof``(isPrime)); ` `    ``isPrime = isPrime = ``false``; ` ` `  `    ``for` `(``int` `i = 2; i < MAX; i++) ` `    ``{ ` `        ``// If i is prime, then update its ` `        ``// powers in all multiples of it. ` `        ``if` `(isPrime[i]) ` `        ``{ ` `            ``for` `(``int` `j = i; j < MAX; j += i) ` `            ``{ ` `                ``int` `k, l; ` `                ``isPrime[j] = ``false``; ` `                ``for` `(k = j, l = 0; k % i == 0; l++, k /= i) ` `                    ``; ` `                ``factors[j].push_back(make_pair(i, l)); ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// Returns sum of proper divisors of num ` `// using factors[] ` `int` `sumOfProperDivisors(``int` `num) ` `{ ` `    ``// Applying above discussed formula for every ` `    ``// array element ` `    ``int` `mul = 1; ` `    ``for` `(``int` `i = 0; i < factors[num].size(); i++) ` `        ``mul *= ((``pow``(factors[num][i].F, ` `                     ``factors[num][i].S + 1) - 1) / ` `                ``(factors[num][i].F - 1)); ` `    ``return` `mul - num; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``sieveOfEratothenese(); ` `    ``int` `arr[] = { 8, 13, 24, 36, 59, 75, 91 }; ` `    ``for` `(``int` `i = 0; i < ``sizeof``(arr) / ``sizeof``(``int``); i++) ` `        ``cout << sumOfProperDivisors(arr[i]) << ``" "``; ` `    ``cout << endl; ` `    ``return` `0; ` `} `

Output:

```7 1 36 55 1 49 21
```

This article is contributed by Shubham Singh (singh_8). If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.