原始大量数

如果N是一个富余数，并且所有它的适当除数都是不足数，则将数字N称为原始富余数。
前几个原始大量数字是：

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

检查N是否为原始数量

给定数字N ，任务是查找此数字是否为原始大量数字。
例子：

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 
 

方法：

1. 检查该数字是否为一个充裕的数字，即，由sum(N)表示的数字的所有适当除数的总和大于数字N的值
2. 如果数量不多，则返回false，否则请执行以下操作
3. 检查N的所有适当除数是否为不足数，即，由divisorsSum(n)表示的数字的所有除数的总和小于数字N的值的两倍。
4. 如果以上两个条件都满足，则打印“是”，否则打印“否” 。

下面是上述方法的实现：

C++

// C++ implementation of the above
// approach
 
#include 
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
    // retuen 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
    // retuen 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
    # retuen 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
    // retuen 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

// 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
        // retuen 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

输出：

Yes

参考： https : //en.wikipedia.org/wiki/Primitive_abundant_number