Abundant Number

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)> n
abundance =  sum(n) - n
sum(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: 21
Output: NO

Input: 12
Output: YES

Input: 17
Output: 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 <bits/stdc++.h>
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

<script>
        // JavaScript code for the above approach

        // Returns true if the given number is Abundant
        function isAbundantNumber(n) {
            // To store the sum of divisors
            let sum = 0;

            // Loop through the numbers [1,n-1]
            for (let 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

        // Function call
        if (isAbundantNumber(12)) {
            document.write("YES");
        }
        else {
            document.write("NO");
        }



    // This code is contributed by Potta Lokesh
    </script>

PHP

<?php
            $n=12;
            $s=0;

        // Loop through the numbers [1,n-1]
            for ($i = 1; $i < $n; $i++) {
                if ($n % $i == 0) {
                    $s += $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 ($s > $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 <bits/stdc++.h>
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.

PHP

<?php
// PHP program for an Optimized
// solution to check Abundant Number

// Function to calculate
// sum of divisors
function getSum($n)
{
    $sum = 0;

    // Note that this loop runs
    // till square root of n
    for ($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;

            // Otherwise take both
            else
            {
                $sum = $sum + $i;
                $sum = $sum + ($n / $i);
            }
        }
    }

    // calculate sum of all
    // proper divisors only
    $sum = $sum - $n;
    return $sum;
}

// Function to check Abundant Number
function checkAbundant($n)
{
    // Return true if sum of
    // divisors is greater than n.
    return (getSum($n) > $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.
?>

Javascript

<script>
// Javascript program for an Optimized
// solution to check Abundant Number

// Function to calculate
// sum of divisors
function getSum(n)
{
    let sum = 0;

    // Note that this loop runs
    // till square root of n
    for (let 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;

            // Otherwise take both
            else
            {
                sum = sum + i;
                sum = sum + (n / i);
            }
        }
    }

    // calculate sum of all
    // proper divisors only
    sum = sum - n;
    return sum;
}

// Function to check Abundant Number
function checkAbundant(n)
{
    // Return true if sum of
    // divisors is greater than n.
    return (getSum(n) > n);
}

// Driver Code
let k = checkAbundant(12) ? "YES<br>" : "NO<br>";
document.write(k);

k = checkAbundant(15) ? "YES<br>" : "NO<br>";
document.write(k);

// This code is contributed by _saurabh_jaiswal
</script>

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 <iostream>
#include <vector>
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;
}

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
This article is contributed by Harsh Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
-Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.”