Java 中的 Brilliant 数

2025年3月17日 | 阅读 7 分钟

在本节中，我们将学习什么是完美数，并创建 Java 程序 来检查给定的数字是否为完美数。完美数程序经常在 Java 编码面试和学术界被问到。

完美数

如果两个素数（例如 p 和 q）的乘积，并且素数 p 中的数字总数等于素数 q 中的数字总数，则该数字称为完美数。

由于完美数是两个素数的乘积，因此每个完美数也是一个半素数。但是，反之则不成立。数学上，如果 N 满足以下条件，则称 N 为完美数：

N = p * q 且 p 中的数字数量 = q 中的数字数量。

让我们通过示例来理解。

示例 1

输入 15

输出：15 是一个完美数。

解释：15 是两个素数 3 和 5 的乘积。此外，数字 3 的位数（1 位）等于数字 5 的位数。因此，15 是一个完美数。

示例 2

输入 50

输出：50 不是完美数。

解释：50 是数字 5 和 10 的乘积。但是，10 不是素数。因此，50 不是完美数。

示例 3

输入 22

输出：22 不是完美数。

解释：22 是两个素数 2 和 11 的乘积。此外，数字 2 的位数（1 位）不等于数字 11 的位数（2 位）。因此，22 不是完美数。

完美数验证

要检查 n 是否为完美数，我们需要检查该数字是否为半素数。

如果数字不是半素数，则它永远不会是完美数。
如果是半素数，则检查素数的总位数是否相等。

观察以下算法。

步骤 1：取数字 n。

步骤 2：计算数字 n 的总因子数。

步骤 3：检查步骤 2 中计算的总因子数是否等于 3 或 4（检查数字是否为半素数的条件）。

如果总因子数等于 3，则检查数字 n 是否为完全平方数。如果是，则该数字是完美数；否则不是。
如果总因子数等于 4，则检查真因子的总位数。如果真因子具有相同的数字计数，则该数字是完美数；否则不是。
如果总计数既不等于 3 也不等于 4，则该数字不是完美数。

让我们在 Java 程序中实现上述算法。

完美数 Java 程序

观察上述算法的实现。

文件名：BrilliantNum.java

// important import statement
import java.util.*;

public class BrilliantNum 
{

// a method that computes the digits of the number
// num
public int countDigits(int num)
{
    int count = 0;
    
    while(num != 0)
    {
        num = num / 10;
        
        count = count + 1;
    }
    
    return count;
}

// a method that returns true if the number 
// n is a brilliant number
public boolean isBrilliant(int n) 
{
    // numbers 0, 1, 2, and 3 are not
    // the brilliant numbers
    if(n <= 3)
    {
        return false;
    }
    
    // already include 1 and the number itself 
    // as the factors
    int count = 2;
    
    // loop for computing the proper factors
    for(int i = 2; i * i <= n; i++)
    {
        if(n % i == 0)
        {
            // for the perfect square 
            // the count of factors will be 3 for semi prime numbers
            if(n / i == i)
            {
                count = count + 1;
            }
            else
            {
            
            // semi prime numbers that are not perfect square
            // should have the count of factors as 4.
            count = count + 2;
            }
        }
    }
    
    if(count == 4)
    {
    for(int i = 2; i * i <= n; i++)
    {
        if(n % i == 0)
        {
            int p = i;
            int q = n / i;
            
            int digCountOfP = countDigits(p);
            int digCountOfQ = countDigits(q);
            
            if(digCountOfP == digCountOfQ)
            {
                return true;
            }
            return false;
        }
    }
    
    
    }
    
    else if(count == 3)
    {
        // count = 3 means the number is prefect square
        // as well as the number, is a semiprime number
        // For any perfect square semiprime numbers, the proper factors
        // will as be the same. Hence, there is no need to compute the number of 
        // digits and we can directly return true.
        return true;
    }
    
    // if the control reaches here, then it means
    // the count of factors is neither 4 nor 3
    // hence the number can never be a brilliant number
    return false;
}
    
// main method
public static void main(String[] argvs)
{
// creating an object of the class BrilliantNum
BrilliantNum obj = new BrilliantNum();

// input 1
int num = 15;

boolean ans = obj.isBrilliant(num);

if(ans)
{
    System.out.println("The number " + num + " is a brilliant number.");
}
else
{
    System.out.println("The number " + num + " is not a brilliant number.");    
}

System.out.println();

// input 2
num = 50;

ans = obj.isBrilliant(num);

if(ans)
{
    System.out.println("The number " + num + " is a brilliant number.");
}
else
{
    System.out.println("The number " + num + " is not a brilliant number.");    
}

System.out.println();

// input 3
num = 22;

ans = obj.isBrilliant(num);

if(ans)
{
    System.out.println("The number " + num + " is a brilliant number.");
}
else
{
    System.out.println("The number " + num + " is not a brilliant number.");    
}

}
}

输出

The number 15 is a brilliant number.
The number 50 is not a brilliant number.
The number 22 is not a brilliant number.

查找范围内的完美数

在此方法中，我们将使用筛法来查找给定范围内的完美数。取两个具有相同位数的素数，然后计算它们的乘积。乘积将是一个完美数。

假设我们要查找范围 1 到 200 内的完美数。请观察以下算法。

步骤 1：计算筛法，找出 1 到 20 之间的素数。

步骤 2：过滤出素数并将它们存储在一个数组或 ArrayList 中，在本例中是 al。

步骤 3：启动一个循环 i = 0 到 s - 1，其中 s 是数组的总大小

步骤 4：在步骤 3 开始的循环内，启动另一个循环 j = I + 1 到 size。

步骤 5：确保由 i 指向的数字的位数等于由 j 指向的数字的位数。

步骤 6：找到由循环变量 I 和 j 指向的数字的乘积。如果乘积大于 200，则丢弃它；否则，保留它。

让我们在 Java 程序中实现上述算法。

文件名：BrilliantNum1.java

// important import statement
import java.util.*;

public class BrilliantNum1
{
// a method that computes the digits of the number
// num
public int countDigits(int num)
{
    int count = 0;
    
    while(num != 0)
    {
        num = num / 10;
        
        count = count + 1;
    }
    
    return count;
}


    // a method that returns the list of primes that are 
    // present between 1 to num
    public ArrayList<Integer> findPrimes(int num) 
    {
        boolean primeArr[] = new boolean[num + 1]; 
        
        ArrayList<Integer> al = new ArrayList<Integer>();
        
        int size = primeArr.length;
        
        // filtering out prime numbers using the 
        // Sieve of Eratosthenes technique
        for(int i = 2 ; i < size; i++)
        {
            primeArr[i] = true;
        }
        
        for(int i = 2; (i * i) <= num; i++)
        {
            if(primeArr[i])
            {
                for(int j = i * i; j <= num; j = j + i)
                {
                    primeArr[j] = false;
                }
            }
        }
        
        
        // loop for storing the prime into an array list
        for(int i = 0; i < size; i++)
        {
            if(primeArr[i])
            {
                al.add(i);
            }
        }

        
        return al;
    }
    
    
    // a method that computes the brilliant numbers within the 
    // range l & r
    public ArrayList<Integer> findBrilliantNum(int l, int r) 
    {
        // al contains all the prime numbers
        ArrayList<Integer> al = findPrimes(r);
        
        // list for storing the brilliant numbers
        ArrayList<Integer> ans = new ArrayList<Integer>();
        
        int size = al.size();
        
        for(int i = 0; i < size - 1; i++)
        {
            for(int j = i; j < size; j++)
            {
                int p = al.get(i);
                int q = al.get(j);
                
                // computing the digits count of the number p & q
                int countDigOfP = countDigits(p);
                int countDigOfQ = countDigits(q);
                
                if(countDigOfP == countDigOfQ)
                {
                    // finding the product of prime numbers p and q
                    int prod = p * q;
                    
                    // the product has to lie in the range
                    if(prod >= l && prod <= r)
                    {
                       
                        ans.add(prod);
                    }
                }
                    
            }
        }
        
        
        // arranging the brilliant numbers in the ascending order
        Collections.sort(ans);
        
        
        return ans;
    }
       

// main method
public static void main(String[] argvs)
{
// creating an object of the class BrilliantNum1
BrilliantNum1 obj = new BrilliantNum1();

ArrayList<Integer> al = obj.findBrilliantNum(1, 200);

int size = al.size();
System.out.println("The brilliant numbers that lie within the range 1 to 200 are: ");
for(int i = 0; i < size; i++)
{
    System.out.print(al.get(i) + " ");
}


}
}

输出

The brilliant numbers that lie within the range 1 to 200 are: 
4 6 9 10 14 15 21 25 35 49 121 143 169 187

下一主题Java 中按频率排序元素

Java 中的 Brilliant 数

完美数

完美数验证

完美数 Java 程序

查找范围内的完美数

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中的 Brilliant 数

完美数

完美数验证

完美数 Java 程序

查找范围内的完美数

相关帖子

Java 中的布尔值求值

Java 中的构造函数可以静态吗

DecimalFormat getMultiplier() method in Java

Facing The Sun Problem in Java

Java 中的菜单驱动程序

MinguoDate equals() method in Java with Examples

How to take Character Input in Java using BufferedReader Class

如何在 Java 中向日期添加 4 年

Why String is Immutable or Final in Java

Java 中的图像处理 - 对比度增强

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器