从项的迭代器创建子序列的迭代器

Question

如果我有一个Seq，那么很容易生成到给定长度限制的所有子序列，如下所示：

def subseqs[A](n: Int)(s: Seq[A]) = {
  (1 to n).flatMap(s.sliding)
}                                            

subseqs(3)(List(1, 2, 3, 4)) foreach println    //> List(1)
                                                //| List(2)
                                                //| List(3)
                                                //| List(4)
                                                //| List(1, 2)
                                                //| List(2, 3)
                                                //| List(3, 4)
                                                //| List(1, 2, 3)
                                                //| List(2, 3, 4)

但是，是否有一种惯用的（并且相当有效）方法可以将迭代器作为输入，产生一个迭代器（或者可能是一个流）作为输出？

更新：我有一个实现迭代器的working implementation，它在一次传递中完成，因此需要很少的内存，但相对较长并且使用可变变量（var 和 @ 987654325@) - 如果有帮助，可以发布。我希望有一种更优雅的方式使用高阶函数...

上面的方法（使用sliding()）不起作用，因为迭代器在第一遍就用完了，不能再使用了。

使用sliding() 和inits() 的组合更好，但会错过预期子序列的尾部：

def subseqsi[A](n: Int)(i: Iterator[A]) = {
  //(1 to n).flatMap(i.sliding) 
  // no - this exhausts the iterator

  i.sliding(n).flatMap { _.inits.filterNot(_.isEmpty) } 
  //nearly, this misses off subsequences towards the end
} 
                                              //> List(1, 2, 3)
                                              //| List(1, 2)
                                              //| List(1)
                                              //| List(2, 3, 4)
                                              //| List(2, 3)
                                              //| List(2)

我的输入数据是一个未知（可能非常大）大小的迭代器。输出子序列的顺序无关紧要。

Answer 1

只需使用Stream：

def subseqs[A](n: Int)(iter: Iterator[A]) = {
  val i = iter.toStream
  1 to n flatMap i.sliding
}

Stream 和 Iterator 一样是惰性的，但它存储所有已计算的值。

Answer 2

这是另一种使用 Streams 的方法 - 远不如 flatMap/sliding 方法（它用于最后几个元素）优雅，但速度更快，内存消耗更少。

def subseqs[A](n: Int)(s: Iterator[A]) = {
  def loop(s: Stream[A], history: Vector[A]): Stream[Seq[A]] = {
    if (s.isEmpty) (1 to n).flatMap(history.sliding).toStream
    else if (history.length == n) 
      history.inits.filterNot(_.isEmpty).toStream #::: loop(s.tail, history.tail :+ s.head)
    else loop(s.tail, history :+ s.head)
  }
  loop(s.toStream, Vector())
}

这会建立一个历史记录，直到有 n 个元素，输出 inits，然后移动历史记录。然而，不仅代码更丑，它还以丑陋的顺序返回结果，因为需要将流的结尾作为一种特殊情况来处理：

subseqs(3)(List(1, 2, 3, 4)) foreach println  > Vector(1, 2, 3)
                                              | Vector(1, 2)
                                              | Vector(1)
                                              | Vector(2)
                                              | Vector(3)
                                              | Vector(4)
                                              | Vector(2, 3)
                                              | Vector(3, 4)
                                              | Vector(2, 3, 4)

我仍然希望优雅的和快速解决方案是可能的......