Economical Number in Java

In Java, number programs such as Armstrong number, Prime number, and Palindrome number are frequently asked by the interviewer. Unlike other number programs, the Economical number is not frequently asked by the interviewers.

An economical number is a number whose number of digits in the prime factorization with their powers is less than the number of digits of the original number. Let's take some examples of economical numbers:

The number 125 is an economical number because its prime factorization is 5^3, and the total number of digits is 2, including power which is less than the number of digits of the original number.
The number 128 is not an economical number because its prime factorization is (2^2 * 3^3). Here, the total number of digits with the power is 4, which is greater than the number of digits of the original number.
The number 625 is an economical number because its prime factorization is 5^5. Here, the total number of digits with the power is 2, which is less than the number of digits of the original number.

Steps to check Economical number

These are the following steps to check whether the number is Economical or not:

In the first step, we will find the primes upto 10^6.
Find the total number of digits in the original number.
Find all prime factors of the original number, and for each prime factor, we find the number of digits and count the highest power of it that divides the original number and calculate the sum of both of them.
If the number of digits in the prime factors is less than the total number of digits in the original number, return true.

Let's implement the code to get all the Economical numbers in a certain range.

EconomicalNumber.java

// import required classes and packages
import java.util.*;

// create class EconomicalNumber to get all the economical numbers in a given range
public class EconomicalNumber {
	
	// define max value
	static int maxVal = 10000;

	// create vector of Integer for storing primes <= to maxVal
	static Vector<Integer> primeValues = new Vector<Integer>();

	// create calculatePrimeValues() method to find primes
	static void calculatePrimeValues()
	{
		// reduce max to half
		boolean []mark = new boolean[maxVal / 2 + 1];
		
		//logic for marking all the numbers that cannot generate prime number by performing 2*i+1
		for (int i = 1; i <= (Math.sqrt(maxVal) - 1) / 2; i++){
			for (int j = (i * (i + 1)) << 1; j <= maxVal / 2; j = j + 2 * i + 1) {
				mark[j] = true;
			}
		}
			
		// add 2 in the primeValues as it is a prime number
		primeValues.add(2);

		// add all other primes which are in the form 2*i + 1 such that mark[i] is false.
		for (int i = 1; i <= maxVal / 2; i++) {
			if (mark[i] == false) {
				primeValues.add(2 * i + 1);
			}
		}
			
				
	}

	// create checkEconomical() method to check whether the number is economical or not
	static boolean checkEconomical(int number)
	{
		// if the number equals to 1, return false.
		if (number == 1)
			return false;

		// find the total number of digits in the original number.
		int realNumber = number;
		int count = 0;
		while (realNumber > 0) {
			// increment the value of count
			count++;
			
			// remove last digit from the number
			realNumber = realNumber / 10;
		}

		// find the total number of digits in the prime factors of the number.
		int primeFactDigits = 0, countNew = 0, prime = 0;
		for (int i = 0; primeValues.get(i) <= number / 2; i++) {
			
			// find the count of powers of prime in number
			while (number % primeValues.get(i) == 0)
			{
				// If primeValues[i] is a prime factor,
				prime = primeValues.get(i);
				number = number / prime;

				// increment value of countNew that indicates power of prime factors
				countNew++;
			}
			
			while (prime > 0)
			{
				primeFactDigits++;
				prime = prime / 10;
			}

			// Add digits of power of prime factors to primeFactDigits.
			while (countNew > 1)
			{
				primeFactDigits++;
				countNew = countNew / 10;
			}
		}

		// If number is not equals to 1, one prime factor is still remaining to be summed up;
		if (number != 1)
		{
			while (number > 0)
			{
				primeFactDigits++;
				number = number / 10;
			}
		}

		// returns true when the total number of digits in prime factors is less than the total number of digits in the original number.
		return (primeFactDigits < count);
	}

	// main method starts
	public static void main(String[] args)
	{
		int start, end;
		// find all the prime numbers 
		calculatePrimeValues();
		
		//create a scanner class object.
		Scanner sc= new Scanner(System.in);
		
		System.out.print("Enter start range: ");
		start = sc.nextInt();
		
		System.out.print("Enter last range: ");
		end = sc.nextInt();
		
		for (int i = start; i < end; i++) {
			if (checkEconomical(i)) {
				System.out.print(i + " is an economical number.\n");
			}
		}		
	}
}

Output: