Magic Number Program in Java

In Java programming, numbers play a vital role in solving logical and mathematical problems. One such interesting concept is the Magic Number. A magic number is not just a random term—it’s a number that gives the same result when you repeatedly add the sum of its digits until you reach a single digit, and that single digit is 1.

This concept is often asked in Java interviews, especially for beginners and those preparing for coding rounds. It helps test how well you understand loops, conditionals, and number manipulation in Java.

In this post, we’ll explore what a magic number is, how it works, its algorithm, and different ways to implement it in Java.

What is a Magic Number?

A Magic Number is a number that, after repeatedly adding its digits until a single digit remains, becomes 1.

Let’s understand this with an example.

Example

Consider the number 19.

Sum of digits = 1 + 9 = 10
Now sum digits of 10 = 1 + 0 = 1

Since the final result is 1, the number 19 is a Magic Number.

If the result was anything other than 1, it wouldn’t be considered a magic number.

Algorithm to Check a Magic Number

To check if a number is a Magic Number:

Take the number.
Calculate the sum of its digits.
If the sum is a single digit, check if it’s 1.
If it’s not a single digit, repeat the process.
If at any step the result equals 1, the number is a magic number.

Here’s the Java code to check if a number is a Magic Number:


import java.util.Scanner;

public class MagicNumber {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int num = sc.nextInt();

        int result = num;
        while (result > 9) {
            result = sumOfDigits(result);
        }

        if (result == 1) {
            System.out.println(num + " is a Magic Number.");
        } else {
            System.out.println(num + " is not a Magic Number.");
        }
    }

    static int sumOfDigits(int n) {
        int sum = 0;
        while (n > 0) {
            sum += n % 10;
            n /= 10;
        }
        return sum;
    }
}

Output Example

How the Code Works

The user enters a number.
The program calls the sumOfDigits() function to calculate the sum of all digits.
It continues summing digits until the result becomes a single digit.
If the final result is 1, the program prints that it’s a magic number.

Using Mathematical Logic

You can also use a shortcut method involving modulo operation (similar to digital root calculation).

If the number’s digital root equals 1, it’s a magic number.

Formula-Based Java Program


import java.util.Scanner;

public class MagicNumberFormula {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int num = sc.nextInt();

        int remainder = num % 9;

        if (remainder == 1) {
            System.out.println(num + " is a Magic Number.");
        } else {
            System.out.println(num + " is not a Magic Number.");
        }
    }
}

This formula uses the digital root concept—if (num % 9 == 1), the number is magic.

Example Calculations

Number	Step-by-step Sum	Final Result	Magic Number
19	1+9 → 10 → 1+0=1	1	✅ Yes
28	2+8 → 10 → 1+0=1	1	✅ Yes
12	1+2 → 3	3	❌ No
55	5+5 → 10 → 1+0=1	1	✅ Yes

Why Learn This Program?

The magic number program is commonly asked in technical interviews because it tests:

Understanding of loops
Use of functions
Handling of conditions and recursion
Mathematical logic skills

It’s simple but demonstrates strong problem-solving skills.

Common Interview Questions Related to Magic Number

What is a magic number in Java?
How can you check a magic number using recursion?
Can a negative number be a magic number?
What is the time complexity of your program?
Can you write a one-line formula for checking magic numbers?

Recursion-Based Solution

Here’s how to solve it recursively:


import java.util.Scanner;

public class MagicNumberRecursion {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int num = sc.nextInt();

        if (isMagic(num))
            System.out.println(num + " is a Magic Number.");
        else
            System.out.println(num + " is not a Magic Number.");
    }

    static boolean isMagic(int n) {
        if (n < 10) return n == 1; int sum = 0; while (n > 0) {
            sum += n % 10;
            n /= 10;
        }

        return isMagic(sum);
    }
}

This approach keeps calling the same function until the sum reduces to a single digit.

Applications of the Magic Number Concept

While the magic number itself is a fun logic puzzle, it’s also useful for:

Developing algorithmic thinking
Learning digit manipulation in loops
Enhancing coding interview skills
Understanding recursion and modular arithmetic

Key Takeaways

A Magic Number reduces to 1 after repeated sum of digits.
Formula: num % 9 == 1 (shortcut method).
Commonly asked in Java interview programs.
Helps in understanding loops, recursion, and conditions.

Conclusion

The Magic Number Program in Java may seem like a small exercise, but it’s a great way to strengthen your logic-building foundation. Such programs are essential in Java interviews and coding challenges.

Whether you’re a beginner learning Java or preparing for your first technical interview, understanding the logic behind programs like this will help you code with more confidence and precision.

If you want to download a PDF version of this Java program with examples, logic explanation, and exercises — stay tuned on thewebdox.com

Magic Number Program in Java – Explanation with Example

What is a Magic Number?

Example

Algorithm to Check a Magic Number