Brilliant Numbers in Java

In this section, we will learn what is brilliant number and also create Java programs to check if the given number is a brilliant number or not. The brilliant number program is frequently asked in Java coding interviews and academics.

Brilliant Number

A number is called a brilliant number if the product of two prime numbers (say p and q) such that a total number of digits present in the prime number p must be equal to the total number of digits present in the prime number q.

Since a brilliant number is a product of two prime numbers, therefore, each brilliant number is also a semi-prime number. However, vice-versa is not true. Mathematically, N is said to be a brilliant number iff

N = p * q and Number of digits in p = Number of digits in q.

Let's understand it through examples.

Example 1:

Input: 15

Output: 15 is a brilliant number.

Explanation: 15 is the product of two prime numbers 3 and 5. Also, the number of digits in the number 3, which is 1, is equal to the number of digits in the number 5. Hence, 15 is a brilliant number.

Example 2:

Input: 50

Output: 50 is a not brilliant number.

Explanation: 50 is the product of two numbers 5 and 10. However, 10 is not a prime number. Hence, 50 is not a brilliant number.

Example 3:

Input: 22

Output: 2 is a not brilliant number.

Explanation: 22 is the product of two prime numbers 2 and 11. Also, the number of digits in the number 2, which is 1, is not equal to the number of digits in the number 11, which is 2. Hence, 2 is not a brilliant number.

Validation For the Brilliant Number

To check whether n is a brilliant number or not, we need to check whether the number is semi-prime or not.

If the number is not a semi-prime number, then it can never be a brilliant number.
If it is a semi-prime number, then check whether the total count of digits of the prime numbers is equal or not.

Observe the following algorithm.

Step 1: Take the number n.

Step 2: Compute the total number of factors for the number n.

Step 3: Check whether the total count of factors computed in step 2 is equal to 3 or 4 or not (condition for checking whether the number is semi-prime or not).

If the total count of factors is equal to 3, then check whether the number n is a perfect square or not. If yes, then the number is a brilliant number; otherwise, not.
If the total count of factors is equal to 4, then check the total number of digits of the proper factors. If the proper factors have the same digit count, then the number is a brilliant number; otherwise, not.
If the total count is neither equal to 3 nor equal to 4, then the number is not a brilliant number.

Let's implement the above algorithm in a Java program.

Brilliant Number Java Program

Observe the implementation of the above algorithm.

FileName: 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.");    
}

}
}

Output:

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

Find Brilliant Numbers Within a Range

In this approach, we will be using a sieve to find the brilliant numbers within the given range. Take two prime numbers of the same digits and find their product. The product is going to be a brilliant number.

Suppose, we want to find the brilliant numbers that are present within the range 1 to 200. Observe the following algorithm.

Step 1: Compute the sieve to find the prime numbers between 1 to 20.

Step 2: Filter out the prime numbers and store them in an array or an ArrayList, which is al in our case.

Step 3: Start a loop i = 0 to s - 1, where s is the total size of the array

Step 4: Within the loop started in step 3, start another loop j = I + 1 to size.

Step 5: Ensure that the digit count of the number pointed by i is equal to the digit count of number pointed by j.

Step 6: Find the product of the numbers pointed by the loop variables I and j. If the product is greater than the number 200, discard it; otherwise, keep it.

Let's implement the above algorithm in a Java Program.

FileName: 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) + " ");
}


}
}

Output:

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

Next TopicSort Elements by Frequency in Java

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

^{Like/Subscribe us for latest updates or newsletter}

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

Brilliant Numbers in Java