4

我有一些代表选择的函数，每个选择都有不同的可取性。考虑

f1 : Seq[A] => Seq[A]
f2 : Seq[A] => Seq[A]
f3 : Seq[A] => Seq[A]

其中f1比 更可取f2，并且f3是最不可取的。我编写了这个 scala 代码来生成做出 2 个连续选择的结果，按从最理想到最不理想的顺序排列

def applyTwice[A](initial: Seq[A],
  f1: Seq[A] => Seq[A],
  f2: Seq[A] => Seq[A],
  f3: Seq[A] => Seq[A]): Seq[A] = {

  lazy val f1s = f1(initial).toStream
  lazy val f2s = f2(initial).toStream
  lazy val f3s = f3(initial).toStream

  f1(f1s) ++
    f2(f1s) ++ f1(f2s) ++
    f2(f2s) ++
    f1(f3s) ++ f3(f1s) ++
    f2(f3s) ++ f3(f2s) ++
    f3(f3s)
}

一般来说，一系列功能应用是按照系列中最差的功能排名的。如果最差是平局，则比较第二个最差的，依此类推。例如，f4(f1(a))会比f3(f3(a))因为f4比 更差f3。请注意，它是 和 之间的f3(f2(a))关系f2(f3(a))。

我可能可以将其推广到可变数量的函数和（更困难的）可变数量的应用程序，但这似乎是一个我还不知道名称的经典问题。这是否已经内置到某些语言/库中？有没有更好的办法？

4

1 回答 1

3

我不认为这是众所周知的事情，但很容易概括：

import scala.math.max
case class Fun[A](cost : Int, fun : Seq[A] => Seq[A])

def applyN[A](funs : Seq[Fun[A]], n : Int, initial : Seq[A]) = 
  (Seq((0, initial)) /: (1 to n)) { 
    case (acc, _) => for {
      f <- funs
      (cost, old) <- acc
    } yield (max(cost, f.cost), f.fun(old))
}

scala> val funs = Seq(Fun[Int](2, _.map(_*2)), Fun[Int](3, _.map(_*3)))

funs: Seq[Fun[Int]] = List(Fun(2,), Fun(3,))

scala> applyN(funs, 2, Seq(1,2,3,4))

res0: Seq[(Int, Seq[Int])] = List((2,List(4, 8, 12, 16)), (3,List(6, 12, 18, 24)), (3,List (6, 12, 18, 24)), (3,列表(9, 18, 27, 36)))

编辑：我注意到我在这里使用了一个简化的成本函数，它只查看最大值，但您可以轻松收集成本列表并将您想要的任何决定应用于它们。

于 2013-10-08T16:06:54.277 回答