1

我必须处理订单序列（这里Int为简化起见）：

// the handleOrder methods are in fact much more complicated:
def handleOrders(prev: Double, orders: Seq[Int]): Double = prev + orders.sum
def handleOrder(prev: Double, order: Int): Double = prev / order

由于一个所谓的

def nextGroup(prev: Double, orders: Seq[Int]): Seq[Double]

函数我得到另一个类的序列（这里Double是为了简化）。

从这里我实现了两个版本。

版本 1（foldLeft 和显式构建器）：

def nextGroup1(prev: Double, orders: Seq[Int]): Seq[Double] = {
  import collection.mutable.Builder
  import collection.immutable.VectorBuilder
  val bld: Builder[Double, Seq[Double]] = new VectorBuilder[Double]
  var first = true
  orders.foldLeft(prev) { (prev, order) =>
    val step = if (first) handleOrders(prev, orders) else prev
    val next = handleOrder(step, order)
    first = false
    bld += next
    next
  }
  bld.result
}

版本 2（var 和用于 yield builder）：

def nextGroup2(prev: Double, orders: Seq[Int]): Seq[Double] = {
  var first = true
  var präv = prev
  for (order <- orders) yield {
    if (first) präv = handleOrders(präv, orders)
    präv = handleOrder(präv, order)
    first = false
    präv
  }
}

我想在版本 1 中保存显式构建器或var在版本 2 中保存可变构建器。

这可能吗？也许结合foldLeft和for- yield？

还有一些示例数据：

val orders = Seq(1, 2, 3)
nextGroup1(1d, orders) // => Vector(7.0, 3.5, 1.1666666666666667)
nextGroup2(1d, orders) // => List(7.0, 3.5, 1.1666666666666667)
nextGroup1(2d, orders) // => Vector(8.0, 4.0, 1.3333333333333333)
nextGroup2(2d, orders) // => List(8.0, 4.0, 1.3333333333333333)

结果nextGroup处理为Seq[Double]，所以Vector或List没有区别。

4

1 回答 1

6 
orders.tail.scanLeft(handleOrders(prev, orders)) { (p, o) => handleOrder(p, o) }

scanLeft与 dos 相同，foldLeft但保留所有中间结果。head您可以通过排除可以使用的集合来摆脱特殊情况orders.tail。

于 2011-11-22T18:43:49.133 回答