我不知道Scala风格在过去的9年里发生了多大的变化，但我发现一个有趣的现象:大多数现有的答案都使用了var，或者是难以阅读的递归。尽早退出的关键是使用惰性集合生成可能的候选对象，然后分别检查条件。生成产物:

val products = for {
  i <- (999 to 1 by -1).view
  j <- (i to 1 by -1).view
} yield (i*j)

然后在不生成所有组合的情况下从视图中找到第一个回文:

val palindromes = products filter {p => p.toString == p.toString.reverse}
palindromes.head

要找到最大的回文(尽管懒惰不会给你带来什么好处，因为你必须检查整个列表):

palindromes.max

您的原始代码实际上是在检查第一个大于后续产品的回文，这与检查第一个回文是一样的，只是在一个奇怪的边界条件下，我认为这不是您想要的。乘积不是严格单调递减的。例如，998*998大于999*997，但在循环中出现得更晚。

不管怎样，分离的惰性生成和条件检查的优点是，你写它的时候就像使用整个列表一样，但它只生成你需要的东西。你可以说是两全其美了。

接近你的解决方案是这样的:

var largest = 0
for (i <- 999 to 1 by -1;
  j <- i to 1 by -1;
  product = i * j;
  if (largest <= product && product.toString.reverse.equals (product.toString.reverse.reverse)))
    largest = product

println (largest)

j迭代是在没有新的作用域的情况下进行的，产品生成和条件都是在for语句中完成的(这不是一个好的表达式-我没有找到更好的表达式)。对于这个问题大小来说，条件是反向的，这是相当快的——也许对于更大的循环，您可以通过中断获得一些东西。

字符串。reverse隐式转换为RichString，这就是为什么我做了2个额外的反转。:)一个更数学的方法可能会更优雅。

只需使用while循环:

var (i, sum) = (0, 0)
while (sum < 1000) {
  sum += i
  i += 1
}

巧妙地使用find方法进行收集将为您提供帮助。

var largest = 0
lazy val ij =
  for (i <- 999 to 1 by -1; j <- i to 1 by -1) yield (i, j)

val largest_ij = ij.find { case(i,j) =>
  val product = i * j
  if (product.toString == product.toString.reverse)
    largest = largest max product
  largest > product
}

println(largest_ij.get)
println(largest)

// import following package
import scala.util.control._

// create a Breaks object as follows
val loop = new Breaks;

// Keep the loop inside breakable as follows
loop.breakable{
// Loop will go here
for(...){
   ....
   // Break will go here
   loop.break;
   }
}

使用Break模块 http://www.tutorialspoint.com/scala/scala_break_statement.htm

跳出for循环从来都不是一个好主意。如果你正在使用for循环，这意味着你知道你想要迭代多少次。使用带有两个条件的while循环。

例如

var done = false
while (i <= length && !done) {
  if (sum > 1000) {
     done = true
  }
}