# 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++

 `// 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; ` `} `

## Java

 `// Java program to find sum of proper divisors for ` `// every element in an array. ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` `     `  `static` `final` `int` `MAX = ``100001``; ` ` `  `static` `class` `pair ` `{  ` `    ``int` `F, S; ` ` `  `    ``public` `pair(``int` `f, ``int` `s) { ` `        ``F = f; ` `        ``S = s; ` `    ``}  ` `     `  `}  ` `// To store prime factors and their ` `// powers ` `static` `Vector []factors = ``new` `Vector[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[] ` `static` `void` `sieveOfEratothenese() ` `{ ` `    ``// To check if a number is prime ` `    ``boolean` `[]isPrime = ``new` `boolean``[MAX]; ` `    ``Arrays.fill(isPrime, ``true``); ` `    ``isPrime[``0``] = isPrime[``1``] = ``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].add(``new` `pair(i, l)); ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// Returns sum of proper divisors of num ` `// using factors[] ` `static` `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 *= ((Math.pow(factors[num].get(i).F, ` `                    ``factors[num].get(i).S + ``1``) - ``1``) / ` `                ``(factors[num].get(i).F - ``1``)); ` `    ``return` `mul - num; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``for` `(``int` `i = ``0``; i < MAX; i++) ` `        ``factors[i] = ``new` `Vector(); ` `    ``sieveOfEratothenese(); ` `    ``int` `arr[] = { ``8``, ``13``, ``24``, ``36``, ``59``, ``75``, ``91` `}; ` `    ``for` `(``int` `i = ``0``; i < arr.length; i++) ` `        ``System.out.print(sumOfProperDivisors(arr[i])+ ``" "``); ` `    ``System.out.println(); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

## C#

 `// C# program to find sum of proper divisors for ` `// every element in an array. ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG ` `{ ` `     `  `static` `readonly` `int` `MAX = 100001; ` ` `  `class` `pair ` `{  ` `    ``public` `int` `F, S; ` ` `  `    ``public` `pair(``int` `f, ``int` `s)  ` `    ``{ ` `        ``F = f; ` `        ``S = s; ` `    ``}  ` `     `  `}  ` ` `  `// To store prime factors and their ` `// powers ` `static` `List []factors = ``new` `List[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[] ` `static` `void` `sieveOfEratothenese() ` `{ ` `    ``// To check if a number is prime ` `    ``bool` `[]isPrime = ``new` `bool``[MAX]; ` `    ``for` `(``int` `i = 0; i < MAX; i++) ` `        ``isPrime[i] = ``true``; ` `    ``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].Add(``new` `pair(i, l)); ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// Returns sum of proper divisors of num ` `// using factors[] ` `static` `int` `sumOfProperDivisors(``int` `num) ` `{ ` `    ``// Applying above discussed formula for every ` `    ``// array element ` `    ``int` `mul = 1; ` `    ``for` `(``int` `i = 0; i < factors[num].Count; i++) ` `        ``mul *= (``int``)((Math.Pow(factors[num][i].F, ` `                    ``factors[num][i].S + 1) - 1) / ` `                ``(factors[num][i].F - 1)); ` `    ``return` `mul - num; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``for` `(``int` `i = 0; i < MAX; i++) ` `        ``factors[i] = ``new` `List(); ` `    ``sieveOfEratothenese(); ` `    ``int` `[]arr = { 8, 13, 24, 36, 59, 75, 91 }; ` `    ``for` `(``int` `i = 0; i < arr.Length; i++) ` `        ``Console.Write(sumOfProperDivisors(arr[i])+ ``" "``); ` `    ``Console.WriteLine(); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Improved By : 29AjayKumar

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.