Open In App
Related Articles

Primitive Abundant Number

Improve Article
Improve
Save Article
Save
Like Article
Like

A number N is said to be Primitive Abundant Number if N is an Abundant number and all it’s proper divisors are Deficient Numbers. 
The first few Primitive Abundant Numbers are:
 

20, 70, 88, 104, 272, 304……… 
 

Check if N is a Primitive Abundant Number

Given a number N, the task is to find if this number is Primitive Abundant Number or not. 
Examples: 
 

Input: N = 20 
Output: YES 
Explanation: 
Sum of 20’s proper divisors is – 1 + 2 + 4 + 5 + 10 = 22 > 20, 
So, 20 is an abundant number. 
The proper divisors of 1, 2, 4, 5 and 10 are0, 1, 3, 1 and 8 respectively, 
Each of these numbers is a deficient number 
Therefore, 20 is a primitive abundant number.
Input: N = 17 
Output: No 
 

 

Approach: 
 

  1. Check if the number is an Abundant number or not, i.e, sum of all the proper divisors of the number denoted by sum(N) is greater than the value of the number N
  2. If the number is not abundant then return false else do the following
  3. Check if all proper divisors of N are Deficient Numbers or not, i.e, sum of all the divisors of the number denoted by divisorsSum(n) is less than twice the value of the number N.
  4. If both above conditions are true print “Yes” else print “No.

Below is the implementation of the above approach:
 

C++




// C++ implementation of the above
// approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to 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);
            }
        }
    }
 
    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 > n);
}
 
// Function to check Deficient Number
bool isDeficient(int n)
{
    // Check if sum(n) < 2 * n
    return (getSum(n) < (2 * n));
}
 
// Function to check all proper divisors
// of N is deficient number or not
bool checkPrimitiveAbundant(int num)
{
    // if number itself is not abundant
    // return false
    if (!checkAbundant(num)) {
        return false;
    }
 
    // find all divisors which divides 'num'
    for (int i = 2; i <= sqrt(num); i++) {
 
        // if 'i' is divisor of 'num'
        if (num % i == 0 && i != num) {
 
            // if both divisors are same then add
            // it only once else add both
            if (i * i == num) {
                if (!isDeficient(i)) {
                    return false;
                }
            }
            else if (!isDeficient(i) || !isDeficient(num / i)) {
                return false;
            }
        }
    }
 
    return true;
}
 
// Driver Code
int main()
{
 
    int n = 20;
    if (checkPrimitiveAbundant(n)) {
        cout << "Yes";
    }
    else {
        cout << "No";
    }
    return 0;
}

Java



// Java implementation of the above
// approach
class GFG{
     
// Function to 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;
                
           // Otherwise take both
           else
           {
               sum = sum + i;
               sum = sum + (n / i);
           }
       }
    }
    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 > n);
}
 
// Function to check Deficient Number
static boolean isDeficient(int n)
{
     
    // Check if sum(n) < 2 * n
    return (getSum(n) < (2 * n));
}
 
// Function to check all proper divisors
// of N is deficient number or not
static boolean checkPrimitiveAbundant(int num)
{
     
    // If number itself is not abundant
    // return false
    if (!checkAbundant(num))
    {
        return false;
    }
 
    // Find all divisors which divides 'num'
    for(int i = 2; i <= Math.sqrt(num); i++)
    {
         
       // if 'i' is divisor of 'num'
       if (num % i == 0 && i != num)
       {
            
           // if both divisors are same then
           // add it only once else add both
           if (i * i == num)
           {
               if (!isDeficient(i))
               {
                   return false;
               }
           }
           else if (!isDeficient(i) ||
                    !isDeficient(num / i))
           {
               return false;
           }
       }
    }
    return true;
}
 
// Driver Code
public static void main(String[] args)
{
    int n = 20;
     
    if (checkPrimitiveAbundant(n))
    {
        System.out.print("Yes");
    }
    else
    {
        System.out.print("No");
    }
}
}
 
// This code is contributed by Ritik Bansal
Python3



# Python3 implementation of the above
# approach
import math
 
# Function to sum of divisors
def getSum(n):
    sum = 0
     
    # Note that this loop
    # runs till square root of N
    for i in range(1, int(math.sqrt(n) + 1)):
        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)
    return sum
 
# Function to check Abundant Number
def checkAbundant(n):
     
    # Return True if sum
    # of divisors is greater
    # than N.
    if (getSum(n) - n > n):
        return True
    return False
 
# Function to check Deficient Number
def isDeficient(n):
     
    # Check if sum(n) < 2 * n
    if (getSum(n) < (2 * n)):
        return True
    return False
 
# Function to check all proper divisors
# of N is deficient number or not
def checkPrimitiveAbundant(num):
     
    # if number itself is not abundant
    # return False
    if not checkAbundant(num):
        return False
     
    # find all divisors which divides 'num'
    for i in range(2, int(math.sqrt(num) + 1)):
         
        # if 'i' is divisor of 'num'
        if (num % i == 0 and i != num):
            # if both divisors are same then add
            # it only once else add both
            if (i * i == num):
                if (not isDeficient(i)):
                    return False
            elif (not isDeficient(i) or
                  not isDeficient(num // i)):
                return False
    return True
 
# Driver Code
n = 20
if (checkPrimitiveAbundant(n)):
    print("Yes")
else:
    print("No")
 
# This code is contributed by shubhamsingh10
C#



// C# implementation of the above
// approach
using System;
class GFG{
     
// Function to 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;
            
           // Otherwise take both
           else
           {
               sum = sum + i;
               sum = sum + (n / i);
           }
       }
    }
    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 > n);
}
 
// Function to check Deficient Number
static bool isDeficient(int n)
{
     
    // Check if sum(n) < 2 * n
    return (getSum(n) < (2 * n));
}
 
// Function to check all proper divisors
// of N is deficient number or not
static bool checkPrimitiveAbundant(int num)
{
     
    // If number itself is not abundant
    // return false
    if (!checkAbundant(num))
    {
        return false;
    }
 
    // Find all divisors which divides 'num'
    for(int i = 2; i <= Math.Sqrt(num); i++)
    {
        
       // If 'i' is divisor of 'num'
       if (num % i == 0 && i != num)
       {
            
           // If both divisors are same then
           // add it only once else add both
           if (i * i == num)
           {
               if (!isDeficient(i))
               {
                   return false;
               }
           }
           else if (!isDeficient(i) ||
                    !isDeficient(num / i))
           {
               return false;
           }
       }
    }
    return true;
}
 
// Driver Code
public static void Main()
{
    int n = 20;
     
    if (checkPrimitiveAbundant(n))
    {
        Console.Write("Yes");
    }
    else
    {
        Console.Write("No");
    }
}
}
 
// This code is contributed by Code_Mech
Javascript



<script>
// Javascript implementation of the above
// approach
 
 
    // Function to 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);
                }
            }
        }
        return sum;
    }
 
    // Function to check Abundant Number
    function checkAbundant( n) {
 
        // Return true if sum
        // of divisors is greater
        // than N.
        return (getSum(n) - n > n);
    }
 
    // Function to check Deficient Number
    function isDeficient( n) {
 
        // Check if sum(n) < 2 * n
        return (getSum(n) < (2 * n));
    }
 
    // Function to check all proper divisors
    // of N is deficient number or not
    function checkPrimitiveAbundant( num) {
 
        // If number itself is not abundant
        // return false
        if (!checkAbundant(num)) {
            return false;
        }
 
        // Find all divisors which divides 'num'
        for ( let i = 2; i <= Math.sqrt(num); i++) {
 
            // if 'i' is divisor of 'num'
            if (num % i == 0 && i != num) {
 
                // if both divisors are same then
                // add it only once else add both
                if (i * i == num) {
                    if (!isDeficient(i)) {
                        return false;
                    }
                } else if (!isDeficient(i) || !isDeficient(num / i)) {
                    return false;
                }
            }
        }
        return true;
    }
 
    // Driver Code
      
        let n = 20;
 
        if (checkPrimitiveAbundant(n)) {
            document.write("Yes");
        } else {
            document.write("No");
        }
 
// This code contributed by aashish1995
</script>
Output
Yes




Time Complexity: O(N1/2)
Auxiliary Space: O(1)
Approach 2: Dynamic Programming:
  • In this approach, we use dynamic programming to memoize the results of whether a number is abundant or not. We first initialize a DP array dp with all elements set to -1 to indicate that we haven’t computed the result for that number yet.
  • We then define a sum_of_divisors function that computes the sum of divisors of a given number. We use this function to check whether a number is abundant or not. If the result for a particular number n is already present in the DP array, we return that result directly. Otherwise, we compute the result using the sum_of_divisors function and store it in the DP array for future use.
  • Finally, we check if the given number is abundant or not using the is_abundant function and print “Yes” or “No” accordingly.
Here is the code below:
C++



#include<bits/stdc++.h>
using namespace std;
 
const int N = 1e5 + 5;
int dp[N];
 
// Function to calculate sum of divisors
int sum_of_divisors(int n) {
    int sum = 1;
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            sum += i;
            if (n / i != i) {
                sum += n / i;
            }
        }
    }
    return sum;
}
 
// Function to check if a number is Abundant or not
bool checkPrimitiveAbundant(int n) {
    if (dp[n] != -1) {
        return dp[n];
    }
    return dp[n] = (sum_of_divisors(n) > n);
}
 
int main() {
    memset(dp, -1, sizeof(dp));
 
    int n = 20;
    if (checkPrimitiveAbundant(n)) {
        cout << "Yes";
    }
    else {
        cout << "No";
    }
    return 0;
}
Java



import java.util.*;
 
public class Main {
    static final int N = 100000;
    static int[] dp = new int[N];
 
    // Function to calculate sum of divisors
    static int sumOfDivisors(int n) {
        int sum = 1;
        for (int i = 2; i * i <= n; i++) {
            if (n % i == 0) {
                sum += i;
                if (n / i != i) {
                    sum += n / i;
                }
            }
        }
        return sum;
    }
 
    // Function to check if a number is Abundant or not
    static boolean checkPrimitiveAbundant(int n) {
        if (dp[n] != 0) {
            return dp[n] == 1;
        }
        return (dp[n] = (sumOfDivisors(n) > n) ? 1 : -1) == 1;
    }
 
    public static void main(String[] args) {
        Arrays.fill(dp, 0);
 
        int n = 20;
        if (checkPrimitiveAbundant(n)) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }
    }
}
Python



N = 100005
dp = [-1] * N
 
# Function to calculate sum of divisors
def sum_of_divisors(n):
    sum = 1
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            sum += i
            if n // i != i:
                sum += n // i
    return sum
 
# Function to check if a number is Abundant or not
def checkPrimitiveAbundant(n):
    if dp[n] != -1:  # Check if the result is already calculated and stored in dp array
        return dp[n]
    dp[n] = sum_of_divisors(n) > n  # Store the result of abundant check in dp array
    return dp[n]
 
if __name__ == "__main__":
    n = 20
    if checkPrimitiveAbundant(n):
        print("Yes")  # If n is primitive abundant, print "Yes"
    else:
        print("No")  # Otherwise, print "No"
C#



using System;
 
public class GFG
{
    const int N = 100000;
    static int[] dp = new int[N];
 
    // Function to calculate sum of divisors
    static int SumOfDivisors(int n)
    {
        int sum = 1;
        for (int i = 2; i * i <= n; i++)
        {
            if (n % i == 0)
            {
                sum += i;
                if (n / i != i)
                {
                    sum += n / i;
                }
            }
        }
        return sum;
    }
 
    // Function to check if a number is Abundant or not
    static bool CheckPrimitiveAbundant(int n)
    {
        if (dp[n] != 0)
        {
            return dp[n] == 1;
        }
        return (dp[n] = (SumOfDivisors(n) > n) ? 1 : -1) == 1;
    }
 
    public static void Main(string[] args)
    {
        Array.Fill(dp, 0);
 
        int n = 20;
        if (CheckPrimitiveAbundant(n))
        {
            Console.WriteLine("Yes");
        }
        else
        {
            Console.WriteLine("No");
        }
    }
}
 
// This Code is Contributed by Dwaipayan Bandyopadhyay
Javascript



const N = 1e5 + 5;
let dp = new Array(N);
 
// Function to calculate sum of divisors
function sum_of_divisors(n) {
    let sum = 1;
    for (let i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            sum += i;
            if (n / i != i) {
                sum += n / i;
            }
        }
    }
    return sum;
}
 
// Function to check if a number is Abundant or not
function checkPrimitiveAbundant(n) {
    if (dp[n] != undefined) {
        return dp[n];
    }
    return dp[n] = (sum_of_divisors(n) > n);
}
 
let n = 20;
if (checkPrimitiveAbundant(n)) {
    console.log("Yes");
} else {
    console.log("No");
}
Output: 
Yes
Time Complexity: O(N log log N), where N is the input number.
Auxiliary Space: O(N), as we need to create an array of size N to store the sum of divisors for all numbers from 1 to N.
References: https://en.wikipedia.org/wiki/Primitive_abundant_number
 

Last Updated :
04 Aug, 2023
Like Article

Save Article

Similar Reads
Similar read thumbnail
Check if a number can be expressed as sum two abundant numbers
Similar read thumbnail
Abundant Number
Similar read thumbnail
Primitive root of a prime number n modulo n
Similar read thumbnail
Find the number of primitive roots modulo prime
Similar read thumbnail
Reduce string by removing outermost parentheses from each primitive substring
Similar read thumbnail
Is String a Primitive or a Derived Type?
Similar read thumbnail
Check Whether a Number is an Anti Prime Number(Highly Composite Number)
Similar read thumbnail
Number of factors of very large number N modulo M where M is any prime number
Similar read thumbnail
Permutation of a number whose sum with the original number is equal to another given number
Similar read thumbnail
Minimum number of moves to make M and N equal by repeatedly adding any divisor of number to itself except 1 and the number
Related Tutorials
Similar read thumbnail
Mathematical and Geometric Algorithms - Data Structure and Algorithm Tutorials
Similar read thumbnail
Learn Data Structures with Javascript | DSA Tutorial
Similar read thumbnail
Introduction to Max-Heap – Data Structure and Algorithm Tutorials
Similar read thumbnail
Introduction to Set – Data Structure and Algorithm Tutorials
Similar read thumbnail
Introduction to Map – Data Structure and Algorithm Tutorials
Previous
Sum of the first N Pronic Numbers
Next

Beatty sequence
Article Contributed By :
author
spp____
spp____
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue 
We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox