Java任意數字的阿姆斯特朗號

Question

以下是我獲得三位數阿姆斯特朗編號的代碼：

public class test {

    public static void main(String args[]) {

        for (int i = 100; i <= 999; i++) {
            int firstDigit = (i / 100);
            int secondDigit = (i % 100) / 10;
            int thirdDigit = (i % 10);
            if ((firstDigit * firstDigit * firstDigit)
                    + (secondDigit * secondDigit * secondDigit)
                    + (thirdDigit * thirdDigit * thirdDigit) == i) {

                System.out.println("this is a armstriong number - " + i);
            }
        }
    }
}

我試圖根據用戶輸入獲得任何數字的阿姆斯特朗，但最終卻寫了太多的循環和多余的代碼。

Answer 1

以下代碼檢查（在控制台上）掃描的號碼是否是阿姆斯特朗號碼。 我已經測試過了，它工作正常。

控制台測試

import java.util.Scanner;

class ArmstrongNumber
{
   public static void main(String args[])
   {
      int n, sum = 0, temp, remainder, digits = 0;

      Scanner in = new Scanner(System.in);
      System.out.println("Input a number to check if it is an Armstrong number");      
      n = in.nextInt();

      temp = n;

      // Count number of digits

      while (temp != 0) {
         digits++;
         temp = temp/10;
      }

      temp = n;

      while (temp != 0) {
         remainder = temp%10;
         sum = sum + power(remainder, digits);
         temp = temp/10;
      }

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

   static int power(int n, int r) {
      int c, p = 1;

      for (c = 1; c <= r; c++) 
         p = p*n;

      return p;   
   }
}

來源在這里 。

---

有功能

如果需要將其用作功能，請嘗試此操作。 n參數是您要檢查的數字。 如果我的函數是Armstrong數，則返回true，否則返回false。

public boolean isArmstrongNumber(int n) {
    int sum = 0, temp = n, remainder, digits = 0;
    while (temp != 0) {
         digits++;
         temp = temp/10;
      }

      temp = n;

      while (temp != 0) {
         remainder = temp%10;
         sum = sum + power(remainder, digits);
         temp = temp/10;
      }
      if (n == sum) //Armstrong number
          return true;
       else //Not Armstrong number
          return false;
}

Answer 2

只需更改arm_num最大值，您將獲得介於0到arm_num之間的Armstrong數

for(int arm_num = 0 ; arm_num < 100000 ; arm_num++)
        {
            String[] data = String.valueOf(arm_num).split("(?<=.)");
            int lngth = String.valueOf(arm_num).length();

            int arm_t_num = 0;

            int ary[] = new int[lngth];

            for(int i = 0 ; i < lngth ; i++)
            {
                ary[i] = Integer.parseInt(data[i]);

                for(int x = 0 ; x < lngth-1 ; x++)
                {
                    ary[i] = ary[i] * Integer.parseInt(data[i]);
                }

                arm_t_num+=ary[i];
            }

            if(arm_num == arm_t_num)
            {
                System.out.println("Number is ArmStrong : "+arm_num);
            }
        }

Answer 3

請嘗試使用以下方法

public static Boolean isArmstrongNumber(int number) {
    int n = number;
    List<Integer> lst = new ArrayList<Integer>();

    // to find digit and putting in list
    while (number > 0) {
        lst.add(number % 10);
        number = number / 10;
    }

    Long sum = 0L;
    for (Integer integer : lst)
        sum += (Long) Math.round(Math.pow(integer, lst.size()));
    return sum.intValue() == n ? true : false;
}

Answer 4

使用Java8，您可以創建一個IntStream來生成Armstrong編號。

第一步可能是創建一個函數來驗證數字是否為阿姆斯特朗數字：

public class ArmstrongNumbersGenerator {    

    // Get the next n armstrong numbers starting at a given number         
    public static int[] get(int start, int count) {         
        return IntStream.iterate(start, i -> i + 1)
            .filter(ArmstrongNumbersGenerator::isArmstrongNumber)
            .limit(count)
            .toArray();
    }

    // Get all the armstrong numbers in a given range
    public static int[] inRange(int start, int end) {
        return IntStream.range(start, end)
                .filter(ArmstrongNumbersGenerator::isArmstrongNumber)
                .toArray();
    }

    // Validate if a number is a armstrong number
    public static boolean isArmstrongNumber(int number) {
        int remainingDigits = number;
        int cubesTotal = 0;
        while(remainingDigits > 0) {
            int currentDigit = remainingDigits % 10;
            remainingDigits = remainingDigits / 10;
            cubesTotal += currentDigit * currentDigit * currentDigit;
        }
        return cubesTotal == number;
    }
}

---

用法示例：

System.out.println(Arrays.toString(ArmstrongNumbersGenerator.inRange(0, 10_000)));
Output: [0, 1, 153, 370, 371, 407]

System.out.println(Arrays.toString(ArmstrongNumbersGenerator.get(200, 2)));
Output: [370, 371] 

Answer 5

我編寫了一個程序來獲取1到10_000_000之間的所有Armstrong編號，這些代碼已經在Code Review上進行了審查。 以下是根據我在那里收到的建議使用Java-8查找阿姆斯壯編號的極簡實現：

IntStream.range(1, 10_000_000)
            .filter((n) -> {
                final String number = Integer.toString(n);
                return number.chars()
                    .mapToDouble(v -> Math.pow(v - '0', number.length()))
                    .sum() == n;
            }).forEach(System.out::println);

輸出：

1
2
3
4
5
6
7
8
9
153
370
371
407
1634
8208
9474
54748
92727
93084
548834
1741725
4210818
9800817
9926315

鏈接到評論問題：

• 使用Java 8在給定范圍內的阿姆斯壯數字
• （后續）使用Java 8在給定范圍內的阿姆斯壯數字

---

這不是解決問題的快速方法。 您可以使用並行來減少執行時間。 唯一的缺點是最終輸出將不按順序排列。

IntStream.range(1, 10_000_000)
            .parallel()    // For reducing execution time.
            .filter((n) -> {
                final String number = Integer.toString(n);
                return number.chars()
                        .mapToDouble(v -> Math.pow(v - '0', number.length()))
                        .sum() == n;
            }).forEach(System.out::println);

輸出：

1741725
9800817
9926315
1
2
3
4
5
6
7
8
9
153
370
371
407
1634
8208
9474
54748
92727
93084
4210818
548834

以下是針對1到10_000的給定范圍的卡尺測試報告：

 0% Scenario{vm=java, trial=0, benchmark=Parallel} 1933923.45 ns; ?=119465.91 ns @ 10 trials
50% Scenario{vm=java, trial=0, benchmark=Normal} 6161598.59 ns; ?=29084.33 ns @ 3 trials

benchmark   ms linear runtime
 Parallel 1.93 =========
   Normal 6.16 ==============================

Answer 6

嘗試使用此代碼，U甚至可以要求用戶輸入數字以測試Armstrong。

class Test{  
  public static void main(String[] args)  {  
    int c=0,a,temp;  
    Scanner scn = new Scanner(System.in);
  //It is the number to check armstrong
    System.out.println("Enter the number to check");
    int n=scn.nextInt();  

    temp=n;  
    while(n>0)  
    {  
    a=n%10;  
    n=n/10;  
    c=c+(a*a*a);  
    }  
    if(temp==c)  
    System.out.println("armstrong number");   
    else  
        System.out.println("Not armstrong number");   
   }  
}  

Answer 7

我認為我的解決方案更容易...

int n = in.nextInt();
for(int i = 10; i<=n; i++){
    int x=i; sum = 0;
    while(x>0){
      sum+ = (x%10)(x%10)(x%10);
      x/=10;
}
if(sum==i)
System.out.println(i+" ");
}

Answer 8

您只需要提供一個極限值，下面的程序將搜索從1到Limit的所有Armstrong數。

    int sum =0, tenspower =1;
    Int limit =1000000001;

    int arr[] = new int[10];


    for (int i=1;i<limit;i++){
        String[] str = String.valueOf(i).split("");


        for(int k=0; k< str.length; k++ ){

            sum = (int) (sum + Math.pow(Integer.parseInt(str[k]), str.length))   ;

                }


        if(sum==i){
            System.out.println(sum);

        }

        sum =0 ;
        str =null;

    }

Answer 9

/* 
 * To Find The Given Number is Armstrong Or Not.
 */
package Test_2_Feb;

import java.util.Scanner;
public class ArmStrongNo {


    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int count =0,rem,Sum =0,pow;
        System.out.println("\t\tWelcome To the Program To Find Armstrong Number");
        System.out.println("\t\t------- -- --- ------- -- ---- --------- ------");
        System.out.println("Enter The Number ");
        int no = sc.nextInt();
        int temp = no;
        pow = no;
        while(no>0)
        {
            rem = no%10;

            while(pow>0)
            {
                pow = pow/10;
                count++;
                }

            no = no/10;

            if(count!=0)
            {
                Sum = (int) (Sum+Math.pow(rem, count));
            }

        }
        if(temp==Sum)
        {
            System.out.println("\tGiven Number : " +temp + "\n\tSum Of Number : " + Sum + "\n\tSo, The Given Number (" + temp + ") is An armstrong Number");
        }
        else
        {
            System.out.println("\tGiven Number : " +temp + "\n\tSum Of Number : " + Sum + "\n\tSo, The Given Number (" + temp + ") is Not an armstrong Number");

        }

    }

}