Extravagant Number in Java

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

Extravagant Number

A natural number that has fewer digits than the number of digits present in its prime factorization (including exponents) is known as the extravagant number. It is also known as the wasteful numbers because of this property.

Extravagant numbers are the subset of composite numbers because one can factorize the extravagant numbers. But vice-versa is not true.

Steps to Find Extravagant Numbers

Step 1: Pick a natural number. Let's say the number is n.

Step 2: Compute the prime factorization of the number n. Store the digits involved in the prime factors of the prime factorization and its exponents in an array.

Step 3: Find the size of the array.

Step 4: Calculate the number of digits present in the number n.

Step 5: If the total number of digits present in the number n is less than the size of the array found in step 3, then the number n is an extravagant number; otherwise, not.

Examples of Extravagant Numbers

Extravagant Number	Prime Factorization	Number of digits in the number	Number of digits in the prime factorization (including exponents)
4	2 * 2	1	2
6	2 * 3	1	2
8	2 * 2 * 2	1	3
9	3 * 3	1	2
12	2 * 2 * 3	2	3
18	2 * 3 * 3	2	3
20	2 * 2 * 5	2	3
22	2 * 11	2	3 (two digits of 11)

We see that for every number mentioned, the number of digits is less than the number of digits present in the prime factorization (including exponents). Hence, the numbers mentioned in the above table are extravagant numbers.

Extravagant Numbers Java Program

The following program checks for extravagant numbers using the steps defined above.

FileName: ExtravagantNumber.java

// A program that checks for the extravagant number from 1 to 30
import java.util.*;

public class ExtravagantNumber 
{
// the method finds the digits of the factors and their exponents found in the prime factorization
public static void addDig(ArrayList<Integer> al, int no)
{
while(no != 0)
{
no = no / 10;
al.add(1);
}

}

// A method to find all of the prime factors
// of the given number no, and stores those factors in the list al
public static void findPrimeFactors (int no, ArrayList<Integer> al)
{
// Extract all the 2s present in the number and store in the list al
Boolean flag = false;
int count = 0;
while (no % 2 == 0) 
{
flag = true;
no = no / 2;
count = count + 1;
}

if(flag)
{
al.add(2);
if(count > 1)
{
// handling digits of exponents
if(count > 9)
{
addDig(al, count);    
}
else
{
al.add(count);
}
}
}
// after all the 2s are removed from the number no, the number no 
// must be odd. So, we can take a jump of 2
// Notice the statement j = j + 2
// It is because 3 is odd and 3 + 2 = 5 which is also odd.
// 5 + 2 = 7, which is also odd. Thus, we see that when we 
// add 2 to an odd number we always get an odd number.
for (int j = 3; j <= Math.sqrt(no); j = j + 2) 
{
count = 0;
flag = false;
// While j divides the number no, store j and continue dividing the number no
while (no % j == 0) 
{
flag = true;
no = no / j;
count = count + 1;
}
if(flag)
{
// we have to ensure that 
// we are not considering the prime factors. We have to 
// ensure that total number of digits present 
// in the factors are considered.
if(j > 10)
{
addDig(al, j);
}
else
{
al.add(j);
}
if(count > 1)
{
// handling digits of exponents
if(count > 9)
{
addDig(al, count);    
}
else
{
al.add(count);
}
}
}
}
// if no is a prime number whose value is 
// greater than 2 then no should be included in the list.
if(no > 2)
{
if(no > 10)
{
addDig(al, no);
}
else
{
al.add(no);
}
}
}
// a method to find the total number digits 
// present in the number no.
public static int findDigits(int no)
{
int dig = 0;
while(no != 0)
{
no = no / 10;
dig = dig + 1;
}

return dig;
}
// main method
public static void main(String argvs[])
{
// List for storing all the prime factors of a number
ArrayList<Integer> al = new ArrayList<Integer>();
for(int i = 1; i <= 30; i++)
{
findPrimeFactors(i, al);
int size = al.size();
int totalNoOfDig = findDigits(i);
if(size > totalNoOfDig)
{
System.out.println(i + " is an extravagant number.");    
}
else
{
System.out.println(i + " is not an extravagant number.");   
}
al.clear();
}
}
}

Output:

1 is not an extravagant number.
2 is not an extravagant number.
3 is not an extravagant number.
4 is an extravagant number.
5 is not an extravagant number.
6 is an extravagant number.
7 is not an extravagant number.
8 is an extravagant number.
9 is an extravagant number.
10 is not an extravagant number.
11 is not an extravagant number.
12 is an extravagant number.
13 is not an extravagant number.
14 is not an extravagant number.
15 is not an extravagant number.
16 is not an extravagant number.
17 is not an extravagant number.
18 is an extravagant number.
19 is not an extravagant number.
20 is an extravagant number.
21 is not an extravagant number.
22 is an extravagant number.
23 is not an extravagant number.
24 is an extravagant number.
25 is not an extravagant number.
26 is an extravagant number.
27 is not an extravagant number.
28 is an extravagant number.
29 is not an extravagant number.
30 is an extravagant number.

Next TopicJava Unicode

← prev next →