结合Scala流

Question

我需要组合来自几个（可能是无限的）流的值，流的数量可能会有所不同;有时会从每个＆＃34;中抽出一个＆＃34;并将它们作为元组处理，有时会交换值。

示例输入可以是这样的：

val as= Stream.from(0)
val bs= Stream.from(10)
val cs= Stream.from(100)
val ds= Stream.from(1000)
val list= List(as, bs, cs, ds)

对于第一个用例，我想最终得到类似

的内容

Seq(0, 10, 100, 1000), Seq(1, 11, 101, 1001), ...

和第二次

Seq(0, 10, 100, 1000, 1, 11, 101, 1001, ...

是否有一个标准的，甚至是内置的组合Stream s？

的解决方案

Answer 1

我的解决方案与Eastsun的解决方案相同，但更容易理解：

def combine[A](s:Seq[Stream[A]]):Stream[Seq[A]]=s.map(_.head) #:: combine(s.map(_.tail))

Answer 2

这是：

scala> val coms = Stream.iterate(list)(_ map (_.tail)) map (_ map (_.head))
coms: scala.collection.immutable.Stream[List[Int]] = Stream(List(0, 10, 100, 1000), ?)

scala> coms take 5 foreach println
List(0, 10, 100, 1000)
List(1, 11, 101, 1001)
List(2, 12, 102, 1002)
List(3, 13, 103, 1003)
List(4, 14, 104, 1004)

scala> val flat = coms.flatten
flat: scala.collection.immutable.Stream[Int] = Stream(0, ?)

scala> flat take 12 toList
res1: List[Int] = List(0, 10, 100, 1000, 1, 11, 101, 1001, 2, 12, 102, 1002)

Answer 3

我提出的最好的东西看起来有点“拥挤”＃34;好像我正在尝试编写流操作的教科书示例......

def combine[A](list: List[Stream[A]]): Stream[Seq[A]] = {
  val listOfSeqs= list.map(_.map(Seq(_))) // easier to reduce when everything are Seqs...
  listOfSeqs.reduceLeft((stream1, stream2)=> stream1 zip stream2 map {
      case (seq1, seq2) => seq1 ++ seq2
    })
}

def interleave[A](list: List[Stream[A]]): Stream[A] = combine(list).flatten