Magnanimous Number in Java

In this tutorial, we are going to learn about the Magnanimous number in Java.

Magnanimous Number

The magnanimous number are those numbers that contain at least 2 digits and always generates a prime number when the left part of the number is added with the right part of the number. The left and the right part of the number can be of any size but not zero.

Magnanimous Number Example

Let's take the number 359794. Its left and the right part are mentioned in the following table.

Left Part	Right Part
3	59794
35	9794
359	794
3597	94
35979	4

Now, we check the addition of the left part and the right part.

3 + 59794 = 59797

35 + 9794 = 9829

359 + 794 = 1153

3597 + 94 = 3691

35979 + 4 = 35983

The numbers 59797, 9829, 1153, 3691, and 35983 are prime numbers. Therefore, 359794 is a Magnanimous number.

Let's take another number 200. The left and the right parts of the number 100 are:

Left Part	Right Part
2	00
20	0

Now the sum of the left and right parts are:

2 + 00 = 2 and 20 + 0 = 20.

Thus, we got two numbers one is 2, and another is 20, in which 2 is a prime number, and 20 is not a prime number. Thus, we got at least one number, which is not a prime number. Hence, 200 is not a Magnanimous number.

Steps for Finding a Magnanimous Number

Following are the steps involved in finding the magnanimous number.

Step 1: Take a number (let's say the number is num) and convert it into a string.

Step 2: Do the traversal of the string to get all of the left part and the right part of the string.

Step 3: Convert each and every left and the right part of the string into an integer.

Step 4: Generate the sum of the left and the right part.

Step 5: Check each of the generated sums (found in step 4) for the prime numbers.

Step 6: If each and every generated sum is a prime number, then the number num is the magnanimous number; otherwise, not.

Magnanimous Number Java Program

Iterative Approach

The following program uses the iterative approach to check for the Magnanimous number using the steps defined above.

FileName: MagnanimousNumberExamples.java

// A Java program that checks for 
// Magnanimous numbers from 10 to 20 (10 and 20 inclusive) 
public class MagnanimousNumberExample
{

// method to check whether no is prime or not
public boolean isPrime(int no)
{

// handling base case
// negative numbers as well as 1 and 0 are not prime
if (no <= 1)
{
return false;
}
// 2 and 3 are prime numbers
if (no <= 3)
{
return true;
}

// any number that is divisible by 2 and 3 are not prime numbers
if (no % 3 == 0 || no % 2 == 0)
{
return false;
}

// we have covered till the number 4
// so we can start directly from the number 5
// any number that is divisible 2 and 3 are handle above
// therefore, we can take a jump of 6
for(int j = 5; j * j <= no; j = j + 6)
{
if (no % j == 0 || no % (j + 2) == 0)
{
return false;
}
}

return true;
}

// Method to check whether the number is Magnanimous or not
public boolean isMagnanimous(int num)
{

// the number is converted to string
String str = Integer.toString(num);

// computing the length of the string
int len = str.length();

// A single-digit number can never be a Magnanimous number
if (len < 2)
{
return false;
}

// Loop for finding all the left and the right part of the string str
for(int j = 0; j < len - 1; j++)
{
// left part
String l = str.substring(0, j + 1);

// right part
String r = str.substring(j + 1);

// converting the left part into string
int intLeft = Integer.valueOf(l);

// converting the right part into string
int intRight = Integer.valueOf(r);

// the summation of left and right part must be a prime number
if (!isPrime(intLeft + intRight))
{
return false;
}
}
return true;
}

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

for(int i = 10; i <= 20; i++)
{
Boolean flag = obj.isMagnanimous(i);
if(flag)
{
System.out.println(i + " is the magnanimous number.");   
}
else
{
System.out.println(i + " is not the magnanimous number.");
}
}

}
}

Output:

10 is not the magnanimous number.
11 is the magnanimous number.
12 is the magnanimous number.
13 is not the magnanimous number.
14 is the magnanimous number.
15 is not the magnanimous number.
16 is the magnanimous number.
17 is not the magnanimous number.
18 is not the magnanimous number.
19 is not the magnanimous number.
20 is the magnanimous number.

Recursive Approach

The following program uses the recursive approach to check for the Magnanimous number.

FileName: MagnanimousNumberExample1.java

// A Java program that checks for 
// Magnanimous numbers from 10 to 20 (10 and 20 inclusive) 
public class MagnanimousNumberExample1
{

// method to check whether no is prime or not
public boolean isPrime(int no)
{

// handling base case
// negative numbers as well as 1 and 0 are not prime
if (no <= 1)
{
return false;
}
// 2 and 3 are prime numbers
if (no <= 3)
{
return true;
}

// any number that is divisible by 2 and 3 are not prime numbers
if (no % 3 == 0 || no % 2 == 0)
{
return false;
}

// we have covered till the number 4
// so we can start directly from the number 5
// any number that is divisible 2 and 3 are handle above
// therefore, we can take a jump of 6
for(int j = 5; j * j <= no; j = j + 6)
{
if (no % j == 0 || no % (j + 2) == 0)
{
return false;
}
}

return true;
}

// Method to check whether the number is Magnanimous or not
public boolean isMagnanimous(String str, int len, int pos)
{

// A single-digit number can never be a Magnanimous number
if (len < 2)
{
return false;
}

// when the pos reaches the len, then it means further division
// into left and right part is not possible
// and hence the number is a Magnanimous number
if(pos == len)
{
return true;
}


// left part
String l = str.substring(0, pos);

// right part
String r = str.substring(pos);

// converting the left part into string
int intLeft = Integer.valueOf(l);

// converting the right part into string
int intRight = Integer.valueOf(r);

// the summation of left and right part must be a prime number
if (!isPrime(intLeft + intRight))
{
return false;
}

// recursively finding the left and right part 
// the value of pos determines the position of the addition sign (+)

Boolean flag = isMagnanimous(str, len, pos + 1);

return true;
}

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

for(int i = 10; i <= 20; i++)
{
// the number is converted to string
String str = Integer.toString(i);
int len = str.length();

Boolean flag = obj.isMagnanimous(str, len, 1);
if(flag)
{
System.out.println(i + " is the magnanimous number.");   
}
else
{
System.out.println(i + " is not the magnanimous number.");
}
}

}
}

Output:

10 is not the magnanimous number.
11 is the magnanimous number.
12 is the magnanimous number.
13 is not the magnanimous number.
14 is the magnanimous number.
15 is not the magnanimous number.
16 is the magnanimous number.
17 is not the magnanimous number.
18 is not the magnanimous number.
19 is not the magnanimous number.
20 is the magnanimous number.

Next TopicBinary Tree Java

← prev next →