Question

以下是获取三位数Armstrong number的代码：

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);
            }
        }
    }
}

我正在尝试根据用户输入获得任何数字的Armstrong，但我最终写了太多的循环和多余的代码。

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;   
   }
}

Source here

有功能

如果您需要将其用作功能，请尝试此操作。 n参数是您要检查的数字。如果是阿姆斯特朗号，我的函数返回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之间的阿姆斯壮数字

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之间的所有阿姆斯壮数字，我已在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);

<强>输出：

与评论问题的链接：

这是不快速解决问题的方法。您可以使用parallel来缩短执行时间。唯一的缺点是最终输出不符合规定。

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);

<强>输出：

以下是给定范围1至10_000的Caliper测试报告：

 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

试试这段代码，你甚至可以要求用户输入数字来测试阿姆斯特朗。

package my.package;
import java.util.logging.Filter;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

public class OWBDelegateHanderLogDiscarder {

/*
 * See org.apache.webbeans.config.OWBLogConst.ERROR_0012
 */
private static final String OWB_LOG_CONST_ERROR_0012 = "ERROR_0012";

private static final String LOGGER_NAME = "org.apache.webbeans.decorator.DelegateHandler";

public OWBDelegateHanderLogDiscarder() {
    Logger delegateHandlerLogger = Logger.getLogger(DelegateHandler.class.getName());
    if (delegateHandlerLogger != null) {
        delegateHandlerLogger.setFilter(new Filter() {
            @Override
            public boolean isLoggable(LogRecord record) {
                if (!LOGGER_NAME.equals(record.getLoggerName())) {
                    return true;
                }
                String message = record.getMessage();
                return !(message != null && message.startsWith(OWB_LOG_CONST_ERROR_0012));
            }
        });
    }
}

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

You just need to provide a limit value, so the following program will search all the Armstrong Numbers from 1 to Limit

    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");

        }

    }

}

Java任何数字阿姆斯特朗数

9 个答案: