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)> 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 …..
![Abundant Numbers](https://media.geeksforgeeks.org/wp-content/uploads/Abundant-Numbers.png)
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++
#include <bits/stdc++.h>
using namespace std;
bool isAbundantNumber( int n)
{
int sum = 0;
for ( int i = 1; i < n; i++) {
if (n % i == 0) {
sum += i;
}
}
if (sum > n) {
return true ;
}
else {
return false ;
}
}
int main()
{
if (isAbundantNumber(12)) {
cout << "YES" << endl;
;
}
else {
cout << "NO" << endl;
;
}
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
public static boolean isAbundantNumber( int n)
{
int sum = 0 ;
for ( int i = 1 ; i < n; i++) {
if (n % i == 0 ) {
sum += i;
}
}
if (sum > n) {
return true ;
}
else {
return false ;
}
}
public static void main(String[] args)
{
if (isAbundantNumber( 12 )) {
System.out.println( "YES" );
}
else {
System.out.println( "NO" );
}
}
}
|
Python3
n = 12
s = 0
for i in range ( 1 , n):
if n % i = = 0 :
s + = i
if s > n:
print ( "Yes" )
else :
print ( "No" )
|
C#
using System;
class GFG {
public static bool isAbundantNumber( int n)
{
int sum = 0;
for ( int i = 1; i < n; i++) {
if (n % i == 0) {
sum += i;
}
}
if (sum > n) {
return true ;
}
else {
return false ;
}
}
public static void Main( string [] args)
{
if (isAbundantNumber(12)) {
Console.WriteLine( "YES" );
}
else {
Console.WriteLine( "NO" );
}
}
}
|
Javascript
<script>
function isAbundantNumber(n) {
let sum = 0;
for (let i = 1; i < n; i++) {
if (n % i == 0) {
sum += i;
}
}
if (sum > n) {
return true ;
}
else {
return false ;
}
}
if (isAbundantNumber(12)) {
document.write( "YES" );
}
else {
document.write( "NO" );
}
</script>
|
PHP
<?php
$n =12;
$s =0;
for ( $i = 1; $i < $n ; $i ++) {
if ( $n % $i == 0) {
$s += $i ;
}
}
if ( $s > $n ) {
echo "Yes" ;
}
else {
echo "No" ;
}
?>
|
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++
#include <bits/stdc++.h>
using namespace std;
int getSum( int n)
{
int sum = 0;
for ( int i=1; i<= sqrt (n); i++)
{
if (n%i==0)
{
if (n/i == i)
sum = sum + i;
else
{
sum = sum + i;
sum = sum + (n / i);
}
}
}
sum = sum - n;
return sum;
}
bool checkAbundant( int n)
{
return (getSum(n) > n);
}
int main()
{
checkAbundant(12)? cout << "YES\n" : cout << "NO\n" ;
checkAbundant(15)? cout << "YES\n" : cout << "NO\n" ;
return 0;
}
|
Java
import java.io.*;
import java.math.*;
class GFG{
static int getSum( int n)
{
int sum = 0 ;
for ( int i= 1 ; i<=(Math.sqrt(n)); i++)
{
if (n%i== 0 )
{
if (n/i == i)
sum = sum + i;
else
{
sum = sum + i;
sum = sum + (n / i);
}
}
}
sum = sum - n;
return sum;
}
static boolean checkAbundant( int n)
{
return (getSum(n) > n);
}
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" );
}
}
|
Python3
import math
def getSum(n) :
sum = 0
i = 1
while i < = (math.sqrt(n)) :
if n % i = = 0 :
if n / / i = = i :
sum = sum + i
else :
sum = sum + i
sum = sum + (n / / i )
i = i + 1
sum = sum - n
return sum
def checkAbundant(n) :
if (getSum(n) > n) :
return 1
else :
return 0
if (checkAbundant( 12 ) = = 1 ) :
print ( "YES" )
else :
print ( "NO" )
if (checkAbundant( 15 ) = = 1 ) :
print ( "YES" )
else :
print ( "NO" )
|
C#
using System;
class GFG {
static int getSum( int n)
{
int sum = 0;
for ( int i = 1; i <= (Math.Sqrt(n)); i++) {
if (n % i == 0) {
if (n / i == i)
sum = sum + i;
else
{
sum = sum + i;
sum = sum + (n / i);
}
}
}
sum = sum - n;
return sum;
}
static bool checkAbundant( int n)
{
return (getSum(n) > n);
}
public static void Main()
{
if (checkAbundant(12))
Console.WriteLine( "YES" );
else
Console.WriteLine( "NO" );
if (checkAbundant(15))
Console.WriteLine( "YES" );
else
Console.WriteLine( "NO" );
}
}
|
Javascript
<script>
function getSum(n)
{
let sum = 0;
for (let i = 1; i <= Math.sqrt(n); i++)
{
if (n % i == 0)
{
if (n / i == i)
sum = sum + i;
else
{
sum = sum + i;
sum = sum + (n / i);
}
}
}
sum = sum - n;
return sum;
}
function checkAbundant(n)
{
return (getSum(n) > n);
}
let k = checkAbundant(12) ? "YES<br>" : "NO<br>" ;
document.write(k);
k = checkAbundant(15) ? "YES<br>" : "NO<br>" ;
document.write(k);
</script>
|
PHP
<?php
function getSum( $n )
{
$sum = 0;
for ( $i = 1; $i <= sqrt( $n ); $i ++)
{
if ( $n % $i == 0)
{
if ( $n / $i == $i )
$sum = $sum + $i ;
else
{
$sum = $sum + $i ;
$sum = $sum + ( $n / $i );
}
}
}
$sum = $sum - $n ;
return $sum ;
}
function checkAbundant( $n )
{
return (getSum( $n ) > $n );
}
$k = checkAbundant(12) ? "YES\n" : "NO\n" ;
echo ( $k );
$k = checkAbundant(15) ? "YES\n" : "NO\n" ;
echo ( $k );
?>
|
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;
bool isAbundantNumber( int n)
{
int sum = 1;
for ( int i = 2; i * i <= n; i++) {
if (n % i == 0) {
if (i * i != n) {
sum += i + n / i;
} else {
sum += i;
}
}
}
if (sum > n) {
return true ;
}
else {
return false ;
}
}
vector< int > getAllAbundantNumbers( int n)
{
vector< int > abundantNumbers;
vector< int > dp(n + 1, 0);
for ( int i = 1; i <= n; i++) {
for ( int j = i * 2; j <= n; j += i) {
dp[j] += i;
}
}
for ( int i = 12; i <= n; i++) {
if (dp[i] > i) {
abundantNumbers.push_back(i);
}
}
return abundantNumbers;
}
int main()
{
if (isAbundantNumber(12)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
|
Java
import java.util.ArrayList;
import java.util.List;
class GFG {
static boolean isAbundantNumber( int n) {
int sum = 1 ;
for ( int i = 2 ; i * i <= n; i++) {
if (n % i == 0 ) {
if (i * i != n) {
sum += i + n / i;
} else {
sum += i;
}
}
}
return sum > n;
}
static List<Integer> getAllAbundantNumbers( int n) {
List<Integer> abundantNumbers = new ArrayList<>();
int [] dp = new int [n + 1 ];
for ( int i = 1 ; i <= n; i++) {
for ( int j = i * 2 ; j <= n; j += i) {
dp[j] += i;
}
}
for ( int i = 12 ; i <= n; i++) {
if (dp[i] > i) {
abundantNumbers.add(i);
}
}
return abundantNumbers;
}
public static void main(String[] args) {
if (isAbundantNumber( 12 )) {
System.out.println( "YES" );
} else {
System.out.println( "NO" );
}
}
}
|
Python3
def isAbundantNumber(n):
sum_divisors = 1
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
if sum_divisors > n:
return True
else :
return False
def getAllAbundantNumbers(n):
abundantNumbers = []
dp = [ 0 ] * (n + 1 )
for i in range ( 1 , n + 1 ):
for j in range (i * 2 , n + 1 , i):
dp[j] + = i
for i in range ( 12 , n + 1 ):
if dp[i] > i:
abundantNumbers.append(i)
return abundantNumbers
if isAbundantNumber( 12 ):
print ( "YES" )
else :
print ( "NO" )
|
C#
using System;
using System.Collections.Generic;
class Program
{
static bool IsAbundantNumber( int n)
{
int sum = 1;
for ( int i = 2; i * i <= n; i++)
{
if (n % i == 0)
{
if (i * i != n)
{
sum += i + n / i;
}
else
{
sum += i;
}
}
}
return sum > n;
}
static List< int > GetAllAbundantNumbers( int n)
{
List< int > abundantNumbers = new List< int >();
int [] dp = new int [n + 1];
for ( int i = 1; i <= n; i++)
{
for ( int j = i * 2; j <= n; j += i)
{
dp[j] += i;
}
}
for ( int i = 12; i <= n; i++)
{
if (dp[i] > i)
{
abundantNumbers.Add(i);
}
}
return abundantNumbers;
}
static void Main()
{
if (IsAbundantNumber(12))
{
Console.WriteLine( "YES" );
}
else
{
Console.WriteLine( "NO" );
}
}
}
|
Javascript
function isAbundantNumber(n) {
let sum = 1;
for (let i = 2; i * i <= n; i++) {
if (n % i == 0) {
if (i * i != n) {
sum += i + n / i;
} else {
sum += i;
}
}
}
if (sum > n) {
return true ;
} else {
return false ;
}
}
function getAllAbundantNumbers(n) {
let abundantNumbers = [];
let dp = new Array(n + 1).fill(0);
for (let i = 1; i <= n; i++) {
for (let j = i * 2; j <= n; j += i) {
dp[j] += i;
}
}
for (let i = 12; i <= n; i++) {
if (dp[i] > i) {
abundantNumbers.push(i);
}
}
return abundantNumbers;
}
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
Please Login to comment...