java这个程序如何一步一步地计算两个区间之间的阿姆斯特朗数？

Question

class Armstrong {
  public static void main(String[] args) {

    int low = 999, high = 99999;

    for(int number = low + 1; number < high; ++number) {
      int digits = 0;
      int result = 0;
      int originalNumber = number;

      // number of digits calculation
      while (originalNumber != 0) {
        originalNumber /= 10;
        ++digits;
      }

      originalNumber = number;

      // result contains sum of nth power of its digits
      while (originalNumber != 0) {
        int remainder = originalNumber % 10;
        result += Math.pow(remainder, digits);
        originalNumber /= 10;
      }

      if (result == number)
        System.out.print(number + " ");
      }
  } 

这个项目是如何运作的？这将非常有帮助。在两次间隔之间查找阿姆斯特朗的程序？有人能一步一步地解释吗？帮帮我

Answer 1

Steb逐步解释

用999和9999初始化间隔的开始和结束 您可以更改这些数字，但要确保low始终小于high：

int low = 999;
int high = 99999;

for (int number = low + 1; // Create a variable number and assign it one number greater than low
    number < high;         // This loop should keep repeating until number is less than high(end of the interval)
    ++number               // After each repetition, increment the value of number by 1
    ) {

创建一个变量digits来存储number中的位数。 例如，如果数字为100，则随着算法的进行，这将被设置为3：

  int digits = 0;

创建一个变量result，用于存储数字的幂和：

  int result = 0;

将number的值复制到局部变量originalNumber，因为它必须被修改：

  int originalNumber = number;

计算一个数字的位数的逻辑是将其除以10，直到数字为0。 每次你把任何数字除以10，最后一个数字就会被去掉。因此，每次去掉最后一个数字时，将数字增加1（digit++）

  // number of digits calculation
  while (originalNumber != 0) // Continue this while loop till originalNumber is not 0
  {
    originalNumber /= 10;     // Divide the number by 10. Dividing a number by 10 removes its last digit.
    ++digits;                // One digit was removed in the above step, which means it has to be counted, so increment digit by 1
  }
  // For example, for originalNumber = 423,
  // 423 / 10 = 42 : digits = 1 (first loop)
  // 42 / 10 = 4 : digits = 2   (second loop)
  // 4 / 10 = 0 : digits = 3    (third loop)
  // Now originalNumber has become 0, so the while loop condition originalNumber != 0 will be false and the loop will stop.
  // Now we have digits = 3, which is the number of digits in 423

  // When program reaches here, digits will have the number of digits in the
  // number "originalNumber"

再次将number复制到originalNumber，因为我们想修改数字 由于上面的数字计数循环，originalNumber再次变为0：

  originalNumber = number;

阿姆斯特朗数是一个数字，等于其位数的幂和

例如：在153，(1^3) + (5^3) + (3^3) = 153。我们得到每个数字（1，5，3）的立方体，因为153有3个数字1，5，3。 如果是50，我们会检查( 5^2 + 0^2)，因为50有两个数字（50不是阿姆斯特朗，因为25 + 0 = 25不等于50）

我们在上面看到，将一个数字除以10将删除最后一个数字（423/10=42） 类似地，如果我们只需要最后一个数字，我们可以通过模10（% 10）：（423 % 10 = 3）（42 % 10 = 2）（4 % 10 = 4）得到它

  // Let's assume originalNumber is 153
  while (originalNumber != 0) // Same as above, keep looping till the originalNumber is not 0(i.e. all digits have been removed)
  {

将最后一位数字提取到remainder（对于153:153 % 10 = 3）（对于15:15 % 10 = 5）

    int remainder = originalNumber % 10;

现在我们有了最后一个数字，我们需要把这个数字提高到 数字，即3（代表153）：(3^3) = 27。我们使用Math.pow(3, 3)来实现这一点。把这个数字加到result。最后，在每个循环数的幂相加后，在loop的末尾，result将包含它们的和：

    result += Math.pow(remainder, digits);
    originalNumber /= 10; // Remove the last digit (same as above, for 153: 153 / 10 = 15)
    // After this line finishes, one rightmost digit will be removed, this will keep
    // happening till originalNumber = 153 becomes 15, then 1, then 0.
    // When originalNumber is 0, loop stops and we will have the total sum in result
  }

对于像153这样的阿姆斯特朗数，result也将包含153。对于非阿姆斯特朗数，它将包含其他内容

  if (result == number) // For 153, both will be equal.
    System.out.print(number + " "); // This will only execute if result is equal to number, or in other words, only if the number is Armstrong
}

改进

根据单一责任原则，每个函数或类必须完全做一件事。你有一个单一的main()方法：

• 定义时间间隔
• 计算间隔中每个数字的位数
• 计算数字的幂和
• 检查号码是否为阿姆斯特朗并打印出来

我更愿意将每个操作分解为一个单独的方法，以便在遵守单一责任原则的同时提高可读性和可维护性：

class Armstrong {

   public static int countDigits(int number) {
      int digits = 0;
      while (number != 0) {
        number /= 10;
        ++digits;
      }
      return digits;
   }

  public static int digitPowerSum(int number, int power) {
    int result = 0;
    while (number != 0) {
      int remainder = number % 10;
      result += Math.pow(remainder, power);
      number /= 10;
    }
    return result;
  }

  public static boolean isArmstrong(int number) {
    int digits = countDigits(number);
    int sum = digitPowerSum(number, digits);
    return sum == number ; // will return true if both numbers are equal else false
  }

  public static ArrayList<Integer> armstrongNumbersBetween(int low, int high) {
      ArrayList<Integer> numbers = new ArrayList<>();
      for(int number = low + 1; number < high; number++) {
        if (isArmstrong(number)) {
          numbers.add(number);
        }
      }
      return numbers;
  }

  public static void main(String[] args) {
    int low = 999, high = 99999;

    ArrayList<Integer> numbers = armstrongNumbersBetween(low, high);

    for(int number : numbers) {
      System.out.print(number + " ");
    }

  }
}

在这里，每个方法只做一件事，这有助于更好地重用。只需调用所需的方法即可执行特定操作。 如果有不清楚的地方，请告诉我