Balanced Prime Number in Java

In this section, we will discuss what is balance prime number and how to find balanced prime number through a Java program.

Balance Prime Number

A balanced prime number is a prime number that is equal to the average of the immediate next and immediate previous prime numbers.

Let's understand it through examples.

Example 1:

Input: 13

Output: 13 is not a balanced prime number.

Explanation: Prime number that is immediately next to the number 13 is 17, and the prime number that is immediately previous to the number 13 is 11, and its average is (11 + 17) / 2 = 28 / 2 = 14, which is not equal to 13. Hence, 13 is not a balanced prime number.

Example 2:

Input: 53.

Output: 53 is a balanced prime number.

Explanation: Prime number that is immediately next to the number 53 is 59, and the prime number that is immediately previous to the number 53 is 47, and its average is (47 + 59) / 2 = 106 / 2 = 53, which is equal to the input number. Hence, 53 is a balanced prime number.

Naive Approach

In this approach, we will use two separate loops. One for computing the immediately previous prime number and the other for computing the immediately next prime number by taking the input prime number as a reference. Then, we find the average of the immediate previous and the immediate next prime numbers and compare it with the input number to check whether the average is equal to the input prime number or not. Observe the following program.

FileName: BalancedPrime.java

public class BalancedPrime 
{
// a method that checks whether the number num 
// is a prime number or not
public boolean isPrime(int num)
{
if(num == 0 || num == 1)
{
return false;
}
// Math.sqrt method returns double
// therefore, we have to change it to int
int n = (int)Math.sqrt(num);
for(int i = 2; i <= n; i++)
{
if(num % i == 0)
{
// reaching here means we have got 
// a factor that is not 1 and the number num
// hence the number num is not prime, and we 
// return false
return false;
}
}
return true;
}
public boolean isBalancedPrime(int num)
{
float f = num;
// for storing the previous prime by
// keeping the current num as the reference
float prvNum = -1f;
// for storing the next prime by
// keeping the current num as the reference
float nextNum = -1f;
// computing the immediate previous prime
for(float i = num - 1f; i >= 2f; i--)
{
if(isPrime((int)i))
{
// immediate previous prime is found
// we can terminate the loop
prvNum = i;
break;
}
}
// computing the immediate next prime
for(float j = num + 1f; true; j++)
{
if(isPrime((int)j))
{
// immediate next prime is found
// we can terminate the loop
nextNum = j;
break;
}
}
if(prvNum == -1f)
{   
// reaching here means
// the previous prime number 
// is not found
return false;
}
// computing the average of the prvNum and the nextNum
float avg = (prvNum + nextNum) / 2f;
if(f == avg)
{
return true;
}
return false;
}
public static void main(String argvs[])
{
// creating an object of the class BalancedPrime
BalancedPrime obj = new BalancedPrime();

System.out.println("Total number of balanced primes from 1 to 200 is: ");

for(int i = 1; i <= 200; i++)
{
// balance prime is also a prime number
if(obj.isPrime(i) && obj.isBalancedPrime(i))
{
System.out.print(i + " ");
}
}
}
}

Output:

Total number of balanced primes from 1 to 200 is: 
5 53 157 173

Time Complexity: If we consider a prime number num, we also assume that the immediate previous prime number is m distance away from num, and the immediate next prime number is n distance away from num. Also, assume that the largest number encountered in search of the immediate previous prime number is k, and the largest number encountered in search of the immediate next prime number is l. Therefore, the time complexity of the program is O(m + n ) for each num.

It is irritating that for each number, we have to check each previous number and the next numbers for computing the immediate next and immediate previous prime numbers. To avoid that, we can use the sieve of Eratosthenes. Observe the following.

Using Sieve of Eratosthenes Algorithm

FileName: BalancedPrime1.java

public class BalancedPrime1
{
public boolean primeArr[];
// a method that uses the sieve of Eratosthenes
// to filter out the prime numbers
public void sieveofNumbers(int n)
{
// Creating an array of type boolean primeArr[0 ... n]" and initializing
// all the entries with the true value. The value of primeArr[j] will be
// finally the false value if j is not the prime, otherwise true.
primeArr = new boolean[n + 1];
for(int i = 0; i <= n; i++)
{
primeArr[i] = true;
}
for(int j = 2; j * j <= n; j++)
{
// If primeArr[j] is not getting changed, then it is a prime
if(primeArr[j] == true)
{
// Updating all of the multiples of j
for(int i = j * j; i <= n; i += j)
{
primeArr[i] = false;
}
}
}
}
public boolean isBalancedPrime(int num)
{
float f = num;
// for storing the previous prime by
// keeping the current num as the reference
float prvNum = -1f;
// for storing the next prime by
// keeping the current num as the reference
float nextNum = -1f;
// computing the immediate previous prime
for(float i = num - 1f; i >= 2f; i--)
{
if(primeArr[(int)i])
{
// immediate previous prime is found
// we can terminate the loop
prvNum = i;
break;
}
}
// computing the immediate next prime
for(float j = num + 1f; true; j++)
{
if(primeArr[(int)j])
{
// immediate next prime is found
// we can terminate the loop
nextNum = j;
break;
}
}
if(prvNum == -1f)
{   
// reaching here means
// the previous prime number 
// is not found
return false;
}
// computing the average of the prvNum and the nextNum
float avg = (prvNum + nextNum) / 2f;
if(f == avg)
{
return true;
}
return false;
}
public static void main(String argvs[])
{
// creating an object of the class BalancedPrime1
BalancedPrime1 obj = new BalancedPrime1();
obj.sieveofNumbers(300);
System.out.println("Total number of balanced primes from 1 to 200 is: ");
for(int i = 1; i <= 200; i++)
{
// balance prime is also a prime number
if(obj.primeArr[i] && obj.isBalancedPrime(i))
{
System.out.print(i + " ");
}
}
}
}

Output:

Total number of balanced primes from 1 to 200 is: 
5 53 157 173

Time Complexity: For any prime number num, the time complexity of the above program is O(m + n + k.log(k)), where m is the gap between the immediate previous prime number and num and n is the gap between num and the immediate next prime number. k is the range for which the sieve is computed.

Points to Remember

For a prime number num, if the average of the immediate next prime number and the immediate smaller prime number is smaller than the number num, then num is called a weak prime number.
For a prime number num, if the average of the immediate next prime number and the immediate smaller prime number is greater than the number num, then num is called a strong prime number.