Armstrong number checking in Java

Question

I'm trying to write a class which checks if a number is an Armstrong number or not. I'm having trouble with the following block of code.

public boolean checkNum(long num) {
    digits = (int) (Math.log10(num) + 1);
    String number = String.valueOf(num);
    numDigits = number.toCharArray();
    for (int i = 0; i < numDigits.length; i++) {
        digit = numDigits[i] * 1.0;
        power = digits * 1.0;
        sum = sum + (long) (Math.pow(digit, power));
    }
    if (sum == num) {
        return true;
    } else {
        return false;
    }
}            

The casting doesn't seem to work, and checkNum returns false every time. Is this a correct method, and are there any better ways of doing this?

Answer 1

Try this, using only arithmetic operations and it works for non-negative integers with an arbitrary number of digits (as long as they fit into a long ).

public boolean checkNum(long num) {

    long n = num;
    long sum = 0;

    // find the number of digits
    int power = (int) Math.floor(Math.log10(n == 0 ? 1 : n)) + 1;

    while (n != 0) {
        int digit = (int) n % 10;
        sum += Math.pow(digit, power);
        n /= 10;
    }

    return sum == num;

}

Alternatively (albeit less efficiently) you could transform the number into a string and iterate over each of the characters converting them into digits. Here's a fixed version of your intended solution, with comments on the key points:

public boolean checkNum(long num) {

    String number = String.valueOf(num);
    char[] numDigits = number.toCharArray();

    long sum = 0;
    // a simple way to obtain the number of digits
    int power = numDigits.length;

    for (int i = 0; i < numDigits.length; i++) {
        // this is how we transform a character into a digit
        int digit = Character.digit(numDigits[i], 10);
        // we need to rise digit to the value of power
        sum = sum + (long) Math.pow(digit, power);
    }

    if (sum == num) {
        return true;
    } else {
        return false;
    }

}

For example, use either implementation to verify that the following are Armstrong numbers:

checkNum(6)
=> true
checkNum(371)
=> true
checkNum(1634)
=> true

Answer 2

You can also use this simple logic

public class Armstrong {

    public static void main(String[] args) {

        int number = 371, originalNumber, remainder, result = 0;

        originalNumber = number;

        while (originalNumber != 0)
        {
            remainder = originalNumber % 10;
            result += Math.pow(remainder, 3);
            originalNumber /= 10;
        }

        if(result == number)
            System.out.println(number + " is an Armstrong number.");
        else
            System.out.println(number + " is not an Armstrong number.");
    }
}

Answer 3

Guess This will work:

boolean isArmstrong(int x){
int s=0;
int u=x;
while(x!=0)
   {
       int y=x%10;
       s=s+(y*y*y);
       x=x/10;
    }
    if(u==s)
    return true;
    else 
    return false;
}

Answer 4

How to Check Number is Armstrong or Not

public boolean isArmstrongNum(int input)
{
    int sum=0,rem,temp;  
    temp=input;  
    while(input>0)  
    {  
       rem=input%10;  
       input=input/10;  
       sum=sum+(rem*rem*rem);  
    }
   return sum==temp;  
}

Answer 5

In Kotlin, you can use:

fun main() {

println("---------------------------------------")

val userInputValues = Scanner(System.`in`)

//* Kotlin Program to Display Armstrong Numbers Between Intervals Using Function
println("* Kotlin Program to Display Armstrong Numbers Between Intervals Using Function\n")

println("Enter your number range")
println("Enter start number of your range \t ")
val startRange = userInputValues.nextInt()

println("Enter end number of your range \t ")
val endRange = userInputValues.nextInt()


println("\n\n------ Armstrong number between $startRange and $endRange ------  ")
for (number in startRange..endRange) {

    var stringNumber : String = number.toString()
    var numberArray = stringNumber.toCharArray()
    var powerOfNumber:Int = numberArray.size;

    var result = 0
    for (digit in numberArray){
        var intDigit:Int = digit.toString().toInt()
        result += intDigit.toDouble().pow(powerOfNumber.toDouble()).toInt()
    }

    if(result == number){
        println( "$number is Armstrong number")
    }

}


println("---------------------------------------")
}

Answer 6

    public static void main(String[] args) {
    Scanner scanner=new Scanner(System.in);
    System.out.print("Enter the number: ");
    int number=scanner.nextInt();
    scanner.close();
    
    int lastDigit=0;
    int reverseNum=0;
    int originalNumber=number;
    while(originalNumber!=0) {
        lastDigit=originalNumber%10;
        reverseNum +=(lastDigit*lastDigit*lastDigit);
        originalNumber /=10;
    }
    if(reverseNum==number) {
        System.out.println("Number is Armstrong");
    }
    else {
        System.out.println("Number is not Armstrong");
    }

}

Answer 7

This image is testing image of this code in terminal.

The best way is using while loop. Here is your Answer for finding 3 digits Armstrong numbers.

import java.util.Scanner;
class Main {
 ////////////////////////////////////////////

 ////////////////////////////////////////////
 public static void main(String args[])
{
 System.out.println("Hello world!");
 Scanner sc = new Scanner(System.in);
 int num = sc.nextInt();
 int numc = num; 
 int rem = 0;
 int cu = 0;
 int val = 0;
 while(num != 0){
  rem = num%10;
  cu = rem*rem*rem;
  val += cu; 
  num /= 10;
 }
           if(val == numc){
            System.out.println("Yes its a Armstrong number ");
           }else{
            System.out.println("No its not a Armstrong number ");
            
           }
 
}
}
///////////////////////////////////////////

Answer 8

Here I have done a code to find armstrong number dynamically:

import java.util.Scanner;

public class Armstrong {
    public static void main(String[] args) {
        if(isArmstrongNumber(input())) {
            System.out.println("armstrong number");
        } else {
            System.out.println("Not armstrong number");
        }
    }

    private static int input() {
        try(Scanner reader = new Scanner(System.in)) {
            return reader.nextInt();
        }
    }

    private static int digitCount(int num) {
        int count = 0;
        while(num > 0) {
            num = num / 10;
            count++;
        }
        System.out.println("No of digit : " + count);
        return count;
    }

    private static int power(int num, int count) {
        int sum = 0;
        while(num > 0) {
            int result = 1;
            int r2 = num % 10;
            num /= 10;
            for(int digit = count; digit > 0; digit--) {
                result *= r2;
            }
            sum += result;
        }
        System.out.println("Sum : " + sum);
        return sum;
    }

    public static boolean isArmstrongNumber(int num) {
        int count = digitCount(num);
        int sum = power(num, count);
        return sum == num;
    }
}

Here is the result:

371
No of digit : 3
Sum : 371
armstrong number

Hope this code helps you better.