# Abundant Number

Last Updated : 19 Oct, 2023

A number n is said to be an Abundant Number if the sum of all the proper divisors of the number denoted by sum(n) is greater than the value of the number n. And the difference between these two values is called abundance
Mathematically, if the below condition holds the number is said to be an Abundant number:

`sum(n)> nabundance =  sum(n) - nsum(n): aliquot sum - The sum of all proper divisors of n`

Given a number n, our task is to find if this number is an Abundant number or not.
The first few Abundant Numbers are: 12, 18, 20, 24, 30, 36, 40, 42, 48, 54, 56, 60, 66 …..

Examples:

`Input: 21Output: NOInput: 12Output: YESInput: 17Output: NO`

Method 1: A Simple solution is to iterate all the numbers from 1 to n-1 and check if the number divides n and calculate the sum. Check if this sum is greater than n or not.

## C++

 `// C++ program to find if a given` `// number is Abundant number or not.` `#include ` `using` `namespace` `std;`   `// Returns true if the given number is Abundant` `bool` `isAbundantNumber(``int` `n)` `{` `    ``// To store the sum of divisors` `    ``int` `sum = 0;`   `    ``// Loop through the numbers [1,n-1]` `    ``for` `(``int` `i = 1; i < n; i++) {` `        ``if` `(n % i == 0) {` `            ``sum += i;` `        ``}` `    ``}`   `    ``// A number n is said to be Abundant Number if` `    ``// sum of all the proper divisors of the number` `    ``// is greater than the value of the number n.` `    ``if` `(sum > n) {` `        ``return` `true``;` `    ``}` `    ``else` `{` `        ``return` `false``;` `    ``}` `}`   `// Driver program` `int` `main()` `{` `    ``// Function call` `    ``if` `(isAbundantNumber(12)) {` `        ``cout << ``"YES"` `<< endl;` `        ``;` `    ``}` `    ``else` `{` `        ``cout << ``"NO"` `<< endl;` `        ``;` `    ``}` `}`   `// This code is contributed by phasing17`

## Java

 `// Java program to find if a given` `// number is Abundant number or not.`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``// Returns true if the given number is Abundant` `    ``public` `static` `boolean` `isAbundantNumber(``int` `n)` `    ``{` `        ``// To store the sum of divisors` `        ``int` `sum = ``0``;`   `        ``// Loop through the numbers [1,n-1]` `        ``for` `(``int` `i = ``1``; i < n; i++) {` `            ``if` `(n % i == ``0``) {` `                ``sum += i;` `            ``}` `        ``}`   `        ``// A number n is said to be Abundant Number if` `        ``// sum of all the proper divisors of the number` `        ``// is greater than the value of the number n.` `        ``if` `(sum > n) {` `            ``return` `true``;` `        ``}` `        ``else` `{` `            ``return` `false``;` `        ``}` `    ``}`   `    ``// Driver program` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Function call` `        ``if` `(isAbundantNumber(``12``)) {` `            ``System.out.println(``"YES"``);` `        ``}` `        ``else` `{` `            ``System.out.println(``"NO"``);` `        ``}` `    ``}` `}` `// This code is contributed by shruti456rawal`

## Python3

 `# code`   `n ``=` `12` `s ``=` `0` `# iterating loop n times` `for` `i ``in` `range``(``1``, n):` `    ``# finding proper divisors` `    ``if` `n ``%` `i ``=``=` `0``:` `        ``# adding proper divisors to the sum s` `        ``s ``+``=` `i` `# checking if sum is greater than the` `# given number then it is called` `# anundant so print yes otherwise no` `if` `s > n:` `    ``print``(``"Yes"``)` `else``:` `    ``print``(``"No"``)`   `    ``# this code is contributed by gangarajula laxmi`

## C#

 `// C# program to find if a given` `// number is Abundant number or not.` `using` `System;`   `class` `GFG {`   `    ``// Returns true if the given number is Abundant` `    ``public` `static` `bool` `isAbundantNumber(``int` `n)` `    ``{` `        ``// To store the sum of divisors` `        ``int` `sum = 0;`   `        ``// Loop through the numbers [1,n-1]` `        ``for` `(``int` `i = 1; i < n; i++) {` `            ``if` `(n % i == 0) {` `                ``sum += i;` `            ``}` `        ``}`   `        ``// A number n is said to be Abundant Number if` `        ``// sum of all the proper divisors of the number` `        ``// is greater than the value of the number n.` `        ``if` `(sum > n) {` `            ``return` `true``;` `        ``}` `        ``else` `{` `            ``return` `false``;` `        ``}` `    ``}`   `    ``// Driver program` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``// Function call` `        ``if` `(isAbundantNumber(12)) {` `            ``Console.WriteLine(``"YES"``);` `        ``}` `        ``else` `{` `            ``Console.WriteLine(``"NO"``);` `        ``}` `    ``}` `}`   `// This code is contributed by phasing17`

## Javascript

 ``

## PHP

 ` ``\$n``) {` `                ``echo` `"Yes"` `;` `            ``}` `            ``else` `{` `                ``echo` `"No"``;` `            ``}` `        `  `// This code is contributed by laxmigangarajula03`   `?>`

Output

```YES

```

Time Complexity: O(n) for a given number n.
Auxiliary Space: O(1)

Optimized Solution:
If we observe carefully, the divisors of the number n are present in pairs. For example if n = 100, then all the pairs of divisors are: (1,100), (2,50), (4,25), (5,20), (10,10)
Using this fact we can speed up our program. While checking divisors we will have to be careful if there are two equal divisors as in the case of (10, 10). In such a case, we will take only one of them in the calculation of the sum.
Subtract the number n from the sum of all divisors to get the sum of proper divisors.

## C++

 `// An Optimized Solution to check Abundant Number` `#include ` `using` `namespace` `std;`   `// Function to calculate sum of divisors` `int` `getSum(``int` `n)` `{` `    ``int` `sum = 0;`   `    ``// Note that this loop runs till square root` `    ``// of n` `    ``for` `(``int` `i=1; i<=``sqrt``(n); i++)` `    ``{` `        ``if` `(n%i==0)` `        ``{` `            ``// If divisors are equal,take only one` `            ``// of them` `            ``if` `(n/i == i)` `                ``sum = sum + i;`   `            ``else` `// Otherwise take both` `            ``{` `                ``sum = sum + i;` `                ``sum = sum + (n / i);` `            ``}` `        ``}` `    ``}`   `    ``// calculate sum of all proper divisors only` `    ``sum = sum - n;` `    ``return` `sum;` `}`   `// Function to check Abundant Number` `bool` `checkAbundant(``int` `n)` `{` `    ``// Return true if sum of divisors is greater` `    ``// than n.` `    ``return` `(getSum(n) > n);` `}`   `/* Driver program to test above function */` `int` `main()` `{` `    ``checkAbundant(12)? cout << ``"YES\n"` `: cout << ``"NO\n"``;` `    ``checkAbundant(15)? cout << ``"YES\n"` `: cout << ``"NO\n"``;` `    ``return` `0;` `}`

## Java

 `// An Optimized Solution to check Abundant Number ` `// in JAVA` `import` `java.io.*; ` `import` `java.math.*;`   `// Function to calculate sum of divisors` `class` `GFG{` `    ``static` `int` `getSum(``int` `n)` `    ``{` `        ``int` `sum = ``0``;` `  `  `       ``// Note that this loop runs till square ` `       ``// root of n` `        ``for` `(``int` `i=``1``; i<=(Math.sqrt(n)); i++)` `        ``{` `            ``if` `(n%i==``0``)` `            ``{` `             ``// If divisors are equal,take only ` `             ``// one of them` `                ``if` `(n/i == i)` `                   ``sum = sum + i;` `  `  `                ``else` `// Otherwise take both` `                ``{` `                   ``sum = sum + i;` `                   ``sum = sum + (n / i);` `                ``}` `            ``}` `        ``}` `  `  `        ``// calculate sum of all proper divisors ` `       ``// only` `        ``sum = sum - n;` `        ``return` `sum;` `    ``}` `  `  `    ``// Function to check Abundant Number` `    ``static` `boolean` `checkAbundant(``int` `n)` `    ``{` `      ``// Return true if sum of divisors is ` `      ``// greater than n.` `      ``return` `(getSum(n) > n);` `    ``}` `  `  `    ``/* Driver program to test above function */` `    ``public` `static` `void` `main(String args[])``throws` `                                   ``IOException` `    ``{` `      ``if``(checkAbundant(``12``))` `          ``System.out.println(``"YES"``);` `      ``else` `          ``System.out.println(``"NO"``);` `      ``if``(checkAbundant(``15``))` `          ``System.out.println(``"YES"``);` `      ``else` `          ``System.out.println(``"NO"``);` `    ``}` `}` ` `  `// This code is contributed by Nikita Tiwari.`

## Python3

 `# An Optimized Solution to check Abundant Number` `# in PYTHON` `import` `math`   `# Function to calculate sum of divisors` `def` `getSum(n) :` `    ``sum` `=` `0` `    `  `    ``# Note that this loop runs till square root` `    ``# of n` `    ``i ``=` `1` `    ``while` `i <``=` `(math.sqrt(n)) :` `        ``if` `n``%``i ``=``=` `0` `:` `            `  `        ``# If divisors are equal,take only one` `        ``# of them ` `            ``if` `n``/``/``i ``=``=` `i :` `                ``sum` `=` `sum` `+` `i` `            ``else` `: ``# Otherwise take both` `                ``sum` `=` `sum` `+` `i` `                ``sum` `=` `sum` `+` `(n ``/``/` `i )` `        ``i ``=` `i ``+` `1` `    `  `    ``# calculate sum of all proper divisors only` `    ``sum` `=` `sum` `-` `n` `    ``return` `sum`   `# Function to check Abundant Number` `def` `checkAbundant(n) :` `    `  `    ``# Return true if sum of divisors is greater` `    ``# than n.` `    ``if` `(getSum(n) > n) :` `        ``return` `1` `    ``else` `:` `        ``return` `0` `        `  `# Driver program to test above function */` `if``(checkAbundant(``12``) ``=``=` `1``) :` `    ``print` `(``"YES"``)` `else` `:` `    ``print` `(``"NO"``)` `    `  `if``(checkAbundant(``15``) ``=``=` `1``) :` `    ``print` `(``"YES"``)` `else` `:` `    ``print` `(``"NO"``)` `    `  `# This code is contributed by Nikita Tiwari.`

## C#

 `// An Optimized Solution to check Abundant Number` `// in C#` `// Function to calculate sum of divisors` `using` `System;`   `class` `GFG {` `    `  `    ``// Function to calculate sum of divisors` `    ``static` `int` `getSum(``int` `n)` `    ``{` `        ``int` `sum = 0;`   `        ``// Note that this loop runs till square` `        ``// root of n` `        ``for` `(``int` `i = 1; i <= (Math.Sqrt(n)); i++) {` `            ``if` `(n % i == 0) {` `                `  `                ``// If divisors are equal, take only` `                ``// one of them` `                ``if` `(n / i == i)` `                    ``sum = sum + i;`   `                ``else` `// Otherwise take both` `                ``{` `                    ``sum = sum + i;` `                    ``sum = sum + (n / i);` `                ``}` `            ``}` `        ``}`   `        ``// calculate sum of all proper divisors` `        ``// only` `        ``sum = sum - n;` `        ``return` `sum;` `    ``}`   `    ``// Function to check Abundant Number` `    ``static` `bool` `checkAbundant(``int` `n)` `    ``{` `        `  `        ``// Return true if sum of divisors is` `        ``// greater than n.` `        ``return` `(getSum(n) > n);` `    ``}`   `    ``/* Driver program to test above function */` `    ``public` `static` `void` `Main()` `    ``{` `        ``if` `(checkAbundant(12))` `            ``Console.WriteLine(``"YES"``);` `        ``else` `            ``Console.WriteLine(``"NO"``);` `            `  `        ``if` `(checkAbundant(15))` `            ``Console.WriteLine(``"YES"``);` `        ``else` `            ``Console.WriteLine(``"NO"``);` `    ``}` `}`   `// This code is contributed by vt_m.`

## Javascript

 ``

## PHP

 ` ``\$n``);` `}`   `// Driver Code` `\$k` `= checkAbundant(12) ? ``"YES\n"` `: ``"NO\n"``;` `echo``(``\$k``);`   `\$k` `= checkAbundant(15) ? ``"YES\n"` `: ``"NO\n"``;` `echo``(``\$k``);`   `// This code is contributed by Ajit.` `?>`

Output

```YES
NO

```

Time Complexity: O(sqrt(n))
Auxiliary Space: O(1)

Approach 3: Dynamic Programming:

The approach uses dynamic programming to determine if a number is abundant or not.

• The idea is to create a boolean array of size n+1, where n is the number whose abundance needs to be checked. This boolean array is used to store the result of whether a number is abundant or not. Initially, all the elements in the array are set to false.
• Then, the program loops through all the numbers from 1 to n, and for each number, it calculates the sum of its divisors. If the sum of divisors is greater than the number itself, the number is marked as abundant in the boolean array.
• Finally, the function returns the value at index n in the boolean array, which tells whether the number n is abundant or not.
• This approach uses dynamic programming because it stores the results of previously computed subproblems in the boolean array and uses them to compute the abundance of larger numbers. This avoids redundant computations and makes the program more efficient.

Here is the Code of above approach:

## C++

 `#include ` `#include ` `using` `namespace` `std;`   `// Returns true if the given number is Abundant` `bool` `isAbundantNumber(``int` `n)` `{` `    ``// To store the sum of divisors` `    ``int` `sum = 1;`   `    ``// Loop through the numbers [2,sqrt(n)]` `    ``for` `(``int` `i = 2; i * i <= n; i++) {` `        ``if` `(n % i == 0) {` `            ``if` `(i * i != n) {` `                ``sum += i + n / i;` `            ``} ``else` `{` `                ``sum += i;` `            ``}` `        ``}` `    ``}`   `    ``// A number n is said to be Abundant Number if` `    ``// sum of all the proper divisors of the number` `    ``// is greater than the value of the number n.` `    ``if` `(sum > n) {` `        ``return` `true``;` `    ``}` `    ``else` `{` `        ``return` `false``;` `    ``}` `}`   `// Function to find all abundant numbers up to n using DP` `vector<``int``> getAllAbundantNumbers(``int` `n)` `{` `    ``vector<``int``> abundantNumbers;` `    ``vector<``int``> dp(n + 1, 0);`   `    ``// Calculate the sum of divisors for all numbers [1, n]` `    ``for` `(``int` `i = 1; i <= n; i++) {` `        ``for` `(``int` `j = i * 2; j <= n; j += i) {` `            ``dp[j] += i;` `        ``}` `    ``}`   `    ``// Find all abundant numbers up to n` `    ``for` `(``int` `i = 12; i <= n; i++) {` `        ``if` `(dp[i] > i) {` `            ``abundantNumbers.push_back(i);` `        ``}` `    ``}`   `    ``return` `abundantNumbers;` `}`   `// Driver program` `int` `main()` `{` `    ``// Check if 12 is an abundant number` `    ``if` `(isAbundantNumber(12)) {` `        ``cout << ``"YES"` `<< endl;` `    ``} ``else` `{` `        ``cout << ``"NO"` `<< endl;` `    ``}` `    `  `    ``return` `0;` `}`

## Java

 `import` `java.util.ArrayList;` `import` `java.util.List;`   `class` `GFG {`   `    ``// Returns true if the given number is Abundant` `    ``static` `boolean` `isAbundantNumber(``int` `n) {` `        ``// To store the sum of divisors` `        ``int` `sum = ``1``;`   `        ``// Loop through the numbers [2, sqrt(n)]` `        ``for` `(``int` `i = ``2``; i * i <= n; i++) {` `            ``if` `(n % i == ``0``) {` `                ``if` `(i * i != n) {` `                    ``sum += i + n / i;` `                ``} ``else` `{` `                    ``sum += i;` `                ``}` `            ``}` `        ``}`   `        ``// A number n is said to be Abundant Number if` `        ``// the sum of all the proper divisors of the number` `        ``// is greater than the value of the number n.` `        ``return` `sum > n;` `    ``}`   `    ``// Function to find all abundant numbers up to n using DP` `    ``static` `List getAllAbundantNumbers(``int` `n) {` `        ``List abundantNumbers = ``new` `ArrayList<>();` `        ``int``[] dp = ``new` `int``[n + ``1``];`   `        ``// Calculate the sum of divisors for all numbers [1, n]` `        ``for` `(``int` `i = ``1``; i <= n; i++) {` `            ``for` `(``int` `j = i * ``2``; j <= n; j += i) {` `                ``dp[j] += i;` `            ``}` `        ``}`   `        ``// Find all abundant numbers up to n` `        ``for` `(``int` `i = ``12``; i <= n; i++) {` `            ``if` `(dp[i] > i) {` `                ``abundantNumbers.add(i);` `            ``}` `        ``}`   `        ``return` `abundantNumbers;` `    ``}`   `    ``// Driver program` `    ``public` `static` `void` `main(String[] args) {` `        ``// Check if 12 is an abundant number` `        ``if` `(isAbundantNumber(``12``)) {` `            ``System.out.println(``"YES"``);` `        ``} ``else` `{` `            ``System.out.println(``"NO"``);` `        ``}` `    ``}` `}`   `// by phasing17`

## Python3

 `# Function to check if the given number is Abundant` `def` `isAbundantNumber(n):` `    ``# To store the sum of divisors` `    ``sum_divisors ``=` `1`   `    ``# Loop through the numbers [2, sqrt(n)]` `    ``i ``=` `2` `    ``while` `i ``*` `i <``=` `n:` `        ``if` `n ``%` `i ``=``=` `0``:` `            ``if` `i ``*` `i !``=` `n:` `                ``sum_divisors ``+``=` `i ``+` `n ``/``/` `i` `            ``else``:` `                ``sum_divisors ``+``=` `i` `        ``i ``+``=` `1`   `    ``# A number n is said to be Abundant Number if` `    ``# the sum of all proper divisors of the number` `    ``# is greater than the value of the number n.` `    ``if` `sum_divisors > n:` `        ``return` `True` `    ``else``:` `        ``return` `False`   `# Function to find all abundant numbers up to n using DP` `def` `getAllAbundantNumbers(n):` `    ``abundantNumbers ``=` `[]` `    ``dp ``=` `[``0``] ``*` `(n ``+` `1``)`   `    ``# Calculate the sum of divisors for all numbers [1, n]` `    ``for` `i ``in` `range``(``1``, n ``+` `1``):` `        ``for` `j ``in` `range``(i ``*` `2``, n ``+` `1``, i):` `            ``dp[j] ``+``=` `i`   `    ``# Find all abundant numbers up to n` `    ``for` `i ``in` `range``(``12``, n ``+` `1``):` `        ``if` `dp[i] > i:` `            ``abundantNumbers.append(i)`   `    ``return` `abundantNumbers`   `# Driver program` `# Check if 12 is an abundant number` `if` `isAbundantNumber(``12``):` `    ``print``(``"YES"``)` `else``:` `    ``print``(``"NO"``)`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `class` `Program` `{` `    ``// Returns true if the given number is Abundant` `    ``static` `bool` `IsAbundantNumber(``int` `n)` `    ``{` `        ``// To store the sum of divisors` `        ``int` `sum = 1;`   `        ``// Loop through the numbers [2,sqrt(n)]` `        ``for` `(``int` `i = 2; i * i <= n; i++)` `        ``{` `            ``if` `(n % i == 0)` `            ``{` `                ``if` `(i * i != n)` `                ``{` `                    ``sum += i + n / i;` `                ``}` `                ``else` `                ``{` `                    ``sum += i;` `                ``}` `            ``}` `        ``}`   `        ``// A number n is said to be Abundant Number if` `        ``// sum of all the proper divisors of the number` `        ``// is greater than the value of the number n.` `        ``return` `sum > n;` `    ``}`   `    ``// Function to find all abundant numbers up to n using DP` `    ``static` `List<``int``> GetAllAbundantNumbers(``int` `n)` `    ``{` `        ``List<``int``> abundantNumbers = ``new` `List<``int``>();` `        ``int``[] dp = ``new` `int``[n + 1];`   `        ``// Calculate the sum of divisors for all numbers [1, n]` `        ``for` `(``int` `i = 1; i <= n; i++)` `        ``{` `            ``for` `(``int` `j = i * 2; j <= n; j += i)` `            ``{` `                ``dp[j] += i;` `            ``}` `        ``}`   `        ``// Find all abundant numbers up to n` `        ``for` `(``int` `i = 12; i <= n; i++)` `        ``{` `            ``if` `(dp[i] > i)` `            ``{` `                ``abundantNumbers.Add(i);` `            ``}` `        ``}`   `        ``return` `abundantNumbers;` `    ``}`   `    ``// Driver program` `    ``static` `void` `Main()` `    ``{` `        ``// Check if 12 is an abundant number` `        ``if` `(IsAbundantNumber(12))` `        ``{` `            ``Console.WriteLine(``"YES"``);` `        ``}` `        ``else` `        ``{` `            ``Console.WriteLine(``"NO"``);` `        ``}`   `     `  `    ``}` `}`

## Javascript

 `// Returns true if the given number is Abundant` `function` `isAbundantNumber(n) {` `    ``// To store the sum of divisors` `    ``let sum = 1;`   `    ``// Loop through the numbers [2,sqrt(n)]` `    ``for` `(let i = 2; i * i <= n; i++) {` `        ``if` `(n % i == 0) {` `            ``if` `(i * i != n) {` `                ``sum += i + n / i;` `            ``} ``else` `{` `                ``sum += i;` `            ``}` `        ``}` `    ``}`   `    ``// A number n is said to be Abundant Number if` `    ``// sum of all the proper divisors of the number` `    ``// is greater than the value of the number n.` `    ``if` `(sum > n) {` `        ``return` `true``;` `    ``} ``else` `{` `        ``return` `false``;` `    ``}` `}`   `// Function to find all abundant numbers up to n using DP` `function` `getAllAbundantNumbers(n) {` `    ``let abundantNumbers = [];` `    ``let dp = ``new` `Array(n + 1).fill(0);`   `    ``// Calculate the sum of divisors for all numbers [1, n]` `    ``for` `(let i = 1; i <= n; i++) {` `        ``for` `(let j = i * 2; j <= n; j += i) {` `            ``dp[j] += i;` `        ``}` `    ``}`   `    ``// Find all abundant numbers up to n` `    ``for` `(let i = 12; i <= n; i++) {` `        ``if` `(dp[i] > i) {` `            ``abundantNumbers.push(i);` `        ``}` `    ``}`   `    ``return` `abundantNumbers;` `}`   `// Driver program` `// Check if 12 is an abundant number` `if` `(isAbundantNumber(12)) {` `    ``console.log(``"YES"``);` `} ``else` `{` `    ``console.log(``"NO"``);` `}`

Output

`YES`

Time Complexity: O(n*sqrt(n)). for a given number n.
Auxiliary Space: O(N)

References:
https://en.wikipedia.org/wiki/Abundant_number

-“

Share your thoughts in the comments