我想使用 for comprehension 来查找数组的最小和最大元素。是否可以通过一次迭代数组来找到最小元素和最大元素？
我正在寻找不使用 scala 提供的 array.min 或 max 的解决方案。
【问题讨论】：
标签： scala
您可以使用reduceLeft 函数获取 Array[Int] 的最小值和最大值。
scala> val a = Array(20, 12, 6, 15, 2, 9)
a: Array[Int] = Array(20, 12, 6, 15, 2, 9)
scala> a.reduceLeft(_ min _)
res: Int = 2
scala> a.reduceLeft(_ max _)
分辨率：Int = 20
有关reduceLeft方法的更多信息和示例，请参阅此链接：http://alvinalexander.com/scala/scala-reduceleft-examples
【讨论】：
这是一个简洁易读的解决方案，可以避免丑陋的if 语句：
def minMax(a: Array[Int]) : (Int, Int) = {
if (a.isEmpty) throw new java.lang.UnsupportedOperationException("array is empty")
a.foldLeft((a(0), a(0)))
{ case ((min, max), e) => (math.min(min, e), math.max(max, e))}
}
解释：foldLeft 是 Scala 中许多集合的标准方法。它允许将一个累加器传递给一个回调函数，该函数将为数组的每个元素调用。
查看scaladoc了解更多详情
【讨论】：
require(a.nonEmpty, "array is empty") 而不是 if。
min 在数组为空时抛出 UOE）。
if，一个非常清晰的词，你不需要任何其他东西就可以理解英文字典是“丑陋的”，但是 foldLeft 带有闭包、模式匹配和函数调用数学库更好？我喜欢函数式范式，但我愿意喝这么多的冷却剂；-)
def findMinAndMax(array: Array[Int]) = { // a non-empty array
val initial = (array.head, array.head) // a tuple representing min-max
// foldLeft takes an initial value of type of result, in this case a tuple
// foldLeft also takes a function of 2 parameters.
// the 'left' parameter is an accumulator (foldLeft -> accum is left)
// the other parameter is a value from the collection.
// the function2 should return a value which replaces accumulator (in next iteration)
// when the next value from collection will be picked.
// so on till all values are iterated, in the end accum is returned.
array.foldLeft(initial) { ((min, max), x) =>
if (x < min) (x, max)
else if (x > max) (min, x)
else acc
}
}
【讨论】：
从其他答案开始 - 一个更通用的解决方案是可能的，它适用于其他集合以及Array，以及其他内容以及Int：
def minmax[B >: A, A](xs: Iterable[A])(implicit cmp: Ordering[B]): (A, A) = {
if (xs.isEmpty) throw new UnsupportedOperationException("empty.minmax")
val initial = (xs.head, xs.head)
xs.foldLeft(initial) { case ((min, max), x) =>
(if (cmp.lt(x, min)) x else min, if (cmp.gt(x, max)) x else max) }
}
例如：
minmax(List(4, 3, 1, 2, 5)) //> res0: (Int, Int) = (1,5)
minmax(Vector('Z', 'K', 'B', 'A')) //> res1: (Char, Char) = (A,Z)
minmax(Array(3.0, 2.0, 1.0)) //> res2: (Double, Double) = (1.0,3.0)
（也可以使用cmp.min() 和cmp.max() 更简洁地编写此代码，但前提是您删除了B >: A 类型绑定，这会降低函数的通用性）。
【讨论】：
考虑一下（对于非空可排序数组），
val ys = xs.sorted
val (min,max) = (ys.head, ys.last)
【讨论】：
val xs: Array[Int] = ???
var min: Int = Int.MaxValue
var max: Int = Int.MinValue
for (x <- xs) {
if (x < min) min = x
if (x > max) max = x
}
【讨论】：
var的？
我在这个聚会上迟到了，但我是 Scala 的新手，我想无论如何我都会做出贡献。这是使用尾递归的解决方案：
@tailrec
def max(list: List[Int], currentMax: Int = Int.MinValue): Int = {
if(list.isEmpty) currentMax
else if ( list.head > currentMax) max(list.tail, list.head)
else max(list.tail,currentMax)
}
【讨论】：
在我对这个问题的所有回答中，DNA 的解决方案是我能找到的最接近“Scala 惯用语”的解决方案。但是，它可以通过...稍微改进：
cmets 应有助于澄清更改。
def minAndMax[B>: A, A](iterable: Iterable[A])(implicit ordering: Ordering[B]): Option[(A, A)] =
if (iterable.nonEmpty)
Some(
iterable.foldLeft((iterable.head, iterable.head)) {
case (minAndMaxTuple, element) =>
val (min, max) =
minAndMaxTuple //decode reference to tuple
if (ordering.lt(element, min))
(element, max) //if replacing min, it isn't possible max will change so no need for the max comparison
else
if (ordering.lt(max, element))
(min, element)
else
minAndMaxTuple //use original reference to avoid instantiating a new tuple
}
)
else
None
这里的解决方案扩展为在单次通过中返回二维空间的下限和上限，再次使用上述优化：
def minAndMax2d[B >: A, A](iterable: Iterable[(A, A)])(implicit ordering: Ordering[B]): Option[((A, A), (A, A))] =
if (iterable.nonEmpty)
Some(
iterable.foldLeft(((iterable.head._1, iterable.head._1), (iterable.head._2, iterable.head._2))) {
case ((minAndMaxTupleX, minAndMaxTupleY), (elementX, elementY)) =>
val ((minX, maxX), (minY, maxY)) =
(minAndMaxTupleX, minAndMaxTupleY) //decode reference to tuple
(
if (ordering.lt(elementX, minX))
(elementX, maxX) //if replacing minX, it isn't possible maxX will change so no need for the maxX comparison
else
if (ordering.lt(maxX, elementX))
(minX, elementX)
else
minAndMaxTupleX //use original reference to avoid instantiating a new tuple
, if (ordering.lt(elementY, minY))
(elementY, maxY) //if replacing minY, it isn't possible maxY will change so no need for the maxY comparison
else
if (ordering.lt(maxY, elementY))
(minY, elementY)
else
minAndMaxTupleY //use original reference to avoid instantiating a new tuple
)
}
)
else
None
【讨论】：
您始终可以编写自己的 foldLeft 函数 - 这将保证一次迭代和已知性能。
val array = Array(3,4,62,8,9,2,1)
if(array.isEmpty) throw new IllegalArgumentException // Just so we can safely call array.head
val (minimum, maximum) = array.foldLeft((array.head, array.head)) { // We start of with the first element as min and max
case ((min, max), next) =>
if(next > max) (min, next)
else if(next < min) (next, max)
else (min, max)
}
println(minimum, maximum) //1, 62
【讨论】：
(min, max) 元组。如果处理一个巨大的列表，这很重要。此外，此解决方案不是通用的。请参阅下面的“Scala 惯用”解决方案我的答案：stackoverflow.com/a/55959734/501113
scala> val v = Vector(1,2)
scala> v.max
res0: Int = 2
scala> v.min
res1: Int = 2
您可以使用Vector 的min 和max 方法
【讨论】：
.min 和.max。