计算所有值或停止并仅返回最佳值（如果找到）

Question

我有一个项目列表，我为每个项目计算一个值。计算这个值有点计算密集，所以我想尽可能地减少它。

我需要实现的算法是这样的：

1. 我有一个值 X

2. 每个项目

   一个。计算它的值，如果它是

   b. if (值 > 0) && (值

3. 返回 List 中的所有 (item, value) 对（值 > 0），理想情况下按值排序

为了更清楚一点，第 3 步仅在没有任何项的值小于 X 的情况下发生。在第 2 步中，当我们遇到第一个小于 X 的项时，我们不应该计算其余项并返回该项目（我们显然可以在 Set() 中单独返回它以匹配返回类型）。

我目前的代码如下：

  val itemValMap = items.foldLeft(Map[Item, Int)]()) {
  (map : Map[Item, Int], key : Item) =>
    val value = computeValue(item)
    if ( value >= 0 )        //we filter out negative ones
      map + (key -> value)
    else
      map
  }

 val bestItem = itemValMap.minBy(_._2)
 if (bestItem._2 < bestX)
 {
      List(bestItem)
 }
 else
 {
    itemValMap.toList.sortBy(_._2)
 }

但是，此代码所做的是计算列表中的所有值并选择最佳值，而不是在找到“更好”的值时停止。我怀疑我必须以某种方式使用 Streams 来实现这一点？

Answer 1

好的，我不确定您的整个设置如何，但我尝试准备一个最小的示例来反映您的情况。

那就是：

object StreamTest {
  case class Item(value : Int)
  def createItems() = List(Item(0),Item(3),Item(30),Item(8),Item(8),Item(4),Item(54),Item(-1),Item(23),Item(131))
  def computeValue(i : Item) = { Thread.sleep(3000); i.value * 2 - 2 }

  def process(minValue : Int)(items : Seq[Item]) = {
    val stream = Stream(items: _*).map(item => item -> computeValue(item)).filter(tuple => tuple._2 >= 0)
    stream.find(tuple => tuple._2 < minValue).map(List(_)).getOrElse(stream.sortBy(_._2).toList)
  }
}

每次计算需要 3 秒。现在让我们看看它是如何工作的：

val items = StreamTest.createItems()
val result = StreamTest.process(2)(items)
result.foreach(r => println("Original: " + r._1 + " , calculated: " + r._2))

给予：

[info] Running Main 
Original: Item(3) , calculated: 4
Original: Item(4) , calculated: 6
Original: Item(8) , calculated: 14
Original: Item(8) , calculated: 14
Original: Item(23) , calculated: 44
Original: Item(30) , calculated: 58
Original: Item(54) , calculated: 106
Original: Item(131) , calculated: 260
[success] Total time: 31 s, completed 2013-11-21 15:57:54

由于没有小于 2 的值，我们得到了一个按计算值排序的列表。请注意，缺少两对，因为计算的值小于 0 并被过滤掉了。

好的，现在让我们尝试使用不同的最小截止点：

val result = StreamTest.process(5)(items)

这给出了：

[info] Running Main 
Original: Item(3) , calculated: 4
[success] Total time: 7 s, completed 2013-11-21 15:55:20

很好，它返回了一个只有一个项目的列表，第一个值（原始列表中的第二个项目）小于“最小”值并且不小于 0。

我希望上面的例子很容易适应你的需要......

Answer 2

避免计算不需要的值的一种简单方法是使用view 方法使您的集合变得惰性：

val weigthedItems = items.view.map{ i => i -> computeValue(i) }.filter(_._2 >= 0 )
weigthedItems.find(_._2 < X).map(List(_)).getOrElse(weigthedItems.sortBy(_._2))

例如，这里是 REPL 中的一个测试：

scala> :paste
// Entering paste mode (ctrl-D to finish)

type Item = String
def computeValue( item: Item ): Int = {
  println("Computing " + item)
  item.toInt
}
val items = List[Item]("13", "1", "5", "-7", "12", "3", "-1", "15")
val X = 10
val weigthedItems = items.view.map{ i => i -> computeValue(i) }.filter(_._2 >= 0 )
weigthedItems.find(_._2 < X).map(List(_)).getOrElse(weigthedItems.sortBy(_._2))

// Exiting paste mode, now interpreting.

Computing 13
Computing 1
defined type alias Item
computeValue: (item: Item)Int
items: List[String] = List(13, 1, 5, -7, 12, 3, -1, 15)
X: Int = 10
weigthedItems: scala.collection.SeqView[(String, Int),Seq[_]] = SeqViewM(...)
res27: Seq[(String, Int)] = List((1,1))

如您所见，computeValue 仅被调用到第一个值 1）