编写 Scala 程序，计算 100～999 的所有的水仙花数

水仙花数是指一个三位数，其各位数字立方和等于该数本身。例如，153就是一个水仙花数，因为 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153。在Scala中，我们可以编写一个函数来找出给定范围内的所有水仙花数。以下是简单的实现：

object NarcissisticNumbers {
  def main(args: Array[String]): Unit = {
    val start = 100
    val end = 999

    for (number <- start to end) {
      if (isNarcissistic(number)) {
        println(s"$number is a narcissistic number.")
      }
    }
  }

  // 检查是否为水仙花数
  def isNarcissistic(n: Int): Boolean = {
    val digits = n.toString.map(_.asDigit).toList
    val sumOfCubes = digits.map(_ * _ * _).sum
    sumOfCubes == n
  }
}

这个程序首先定义了一个`main`函数，遍历从100到999的所有整数。对于每个数字，它调用`isNarcissistic`函数检查是否满足水仙花数条件。如果满足，就打印出该数。

相关问题

编写scala程序，计算100~999的所有水仙花数

### 回答1：

我们可以使用scala编写以下程序来计算100~999之间的所有水仙花数：object Demo {
def main(args: Array[String]) {
for (i <- 100 to 999) {
val s = i.toString
val a = s.charAt(0).asDigit
val b = s.charAt(1).asDigit
val c = s.charAt(2).asDigit
if (i == a * a * a + b * b * b + c * c * c) {
println("水仙花数：" + i)
}
}
}
}

### 回答2：
水仙花数指的是一个数的每个位上的数字的立方和等于该数本身的整数。比如，153是一个水仙花数，因为 1^3 + 5^3 + 3^3 = 153。

以下是用Scala编写的程序，用于计算100到999之间的所有水仙花数：

object NarcissisticNumbers {
  def main(args: Array[String]): Unit = {
    println("100到999之间的水仙花数有：")
    for (num <- 100 to 999) {
      if (isNarcissistic(num)) {
        println(num)
      }
    }
  }

  def isNarcissistic(num: Int): Boolean = {
    val digit1 = num / 100
    val digit2 = (num / 10) % 10
    val digit3 = num % 10
    val sum = math.pow(digit1, 3) + math.pow(digit2, 3) + math.pow(digit3, 3)
    num == sum.toInt
  }
}

这个程序首先定义了一个`isNarcissistic`方法，用于判断一个数是否是水仙花数。该方法首先将给定的数分解为三个位上的数字，然后计算每个位上数字的立方和，并将其与原始数进行比较。如果它们相等，则数是水仙花数。

在`main`方法中，程序使用`for`循环遍历100到999之间的所有数，并调用`isNarcissistic`方法来判断每个数是否是水仙花数。如果是，就打印该数。

运行此程序，将输出100到999之间的所有水仙花数。

注意：此程序仅计算了整数形式的水仙花数，即三位数。如果想要计算更高位数的水仙花数，需要相应地修改代码。

### 回答3：
水仙花数是指一个三位数，其各位数字的立方和等于该数本身。下面是用 Scala 编写的程序，可以计算出 100~999 的所有水仙花数。

object NarcissisticNumber {
  def main(args: Array[String]): Unit = {
    for (num <- 100 to 999) {
      val digit1 = num / 100
      val digit2 = (num % 100) / 10
      val digit3 = num % 10

      if (digit1 * digit1 * digit1 + digit2 * digit2 * digit2 + digit3 * digit3 * digit3 == num) {
        println(num)
      }
    }
  }
}

程序中使用了一个 for 循环，遍历所有的三位数。然后，我们取出每个数字的个位、十位和百位，分别存储在 digit1、digit2 和 digit3 变量中。接下来，通过计算每个数字的立方和，判断是否等于原始的数字。如果等于，那么就打印出该数字，即为水仙花数。

运行程序，会输出结果：

153
370
371
407

这些数就是 100~999 之间的所有水仙花数。

编写scala程序 计算100-999的所有的水仙花数

以下是Scala程序代码：

object NarcissisticNumbers {
  def main(args: Array[String]): Unit = {
    val narcissisticNumbers = for {
      i <- 100 to 999
      val (a, b, c) = (i / 100, (i / 10) % 10, i % 10)
      if (a * a * a + b * b * b + c * c * c == i)
    } yield i

    println(narcissisticNumbers.mkString(", "))
  }
}

程序中定义了一个 `NarcissisticNumbers` 对象，其中包含一个 `main` 方法。在 `main` 方法中，使用 `for` 循环遍历了 100 到 999 之间的所有数字，并对每个数字进行水仙花数的计算。对于每个数字，通过模运算和整除运算，计算出该数字的百、十、个位上的数字，然后根据水仙花数的定义，判断是否满足条件，如果满足条件，则将该数字加入到结果列表中。最后，将结果列表打印输出即可。