Scala, wiederhole eine endliche Liste unendlich

Will ich mit Stream-Klasse in scala zum wiederholen einer vorgegebenen Liste unendlich.

Zum Beispiel die Liste (1,2,3,4,5) ich will einen stream erstellen, der gibt mir (1,2,3,4,5,1,2,3,4,5,1,2,3....)

So, ich kann wickeln Sie den Betrieb nehmen. Ich weiß, das kann auf andere Weise realisiert werden, aber ich will es auf diese Weise für einige Grund, nur humor mich 🙂

Also die Idee ist, dass mit dieser unendlichen Zyklus erstellt aus einer Liste, die ich verwenden kann, nehmen Sie den Betrieb, und wenn er erreicht das Ende der Liste it-Zyklen.

Wie kann ich einen stream, die einfach wiederholt, zu einer gegebenen Liste?

InformationsquelleAutor der Frage Felix | 2010-01-19

  1. 33

    Sehr ähnlich zu @Eastsun ist, aber ein bisschen mehr Absicht enthüllt. Getestet in Scala 2.8.

    scala> val l  = List(1, 2, 3)
l: List[Int] = List(1, 2, 3)

scala> Stream.continually(l.toStream).flatten.take(10).toList
res3: List[Int] = List(1, 2, 3, 1, 2, 3, 1, 2, 3, 1)

    Alternativ mit Scalaz:

    scala> import scalaz._
import scalaz._

scala> import Scalaz._
import Scalaz._

scala> val l = List(1, 2, 3)
l: List[Int] = List(1, 2, 3)

scala> l.toStream.repeat[Stream].join.take(10).toList
res7: List[Int] = List(1, 2, 3, 1, 2, 3, 1, 2, 3, 1)

    InformationsquelleAutor der Antwort retronym

  2. 22

    Eine alternative Methode ist die Verkettung der .toStream der Eingabe mit sich selbst rekursiv. Das ist,

    scala> val xs: Stream[Int] = List(1, 2, 3).toStream #::: xs
xs: Stream[Int] = Stream(1, ?)

scala> xs.take(10).toList
res1: List[Int] = List(1, 2, 3, 1, 2, 3, 1, 2, 3, 1)

    InformationsquelleAutor der Antwort Volkan Yazıcı

  3. 7

    Gibt es eine einfache Möglichkeit, mit Stream#flatten in scala 2.8

    Welcome to Scala version 2.8.0.r20542-b20100116020126 (Java HotSpot(TM) Client VM, Java 1.6.0_18).
Type in expressions to have them evaluated.
Type :help for more information.

scala> def cycle[T](seq: Seq[T]) = Stream.from(0).flatten(_ => seq)
cycle: [T](seq: Seq[T])scala.collection.immutable.Stream[T]

scala> cycle(1::2::3::Nil)
res0: scala.collection.immutable.Stream[Int] = Stream(1, ?)

scala> res0.take(10)
res1: scala.collection.immutable.Stream[Int] = Stream(1, ?)

scala> res0.take(10).toList
res2: List[Int] = List(1, 2, 3, 1, 2, 3, 1, 2, 3, 1)

    InformationsquelleAutor der Antwort Eastsun

  4. 5

    Hier ist eine Implementierung, die nicht davon ausgehen, dass length effizient:

    def rep[A](seq: Seq[A]) = {
  def inner(proj: Seq[A]): Stream[A] = {
    if (proj.isEmpty)
      inner(seq)
    else
      Stream.cons(proj.first, inner(proj drop 1))
  }

  if (seq.isEmpty)
    Stream.empty
  else
    inner(seq)
}

    Sollte dies laufen in konstanter Zeit für alle Seq (einschließlich List oder sogar Stream) und nur auferlegt, eine Konstante Zeit-overhead, füllen Sie jedes element. Auch, es funktioniert sogar für unendliche Sequenzen. So können Sie rufen Sie rep auf eine unendliche Stream und die daraus resultierenden Stream entspricht den input.

    InformationsquelleAutor der Antwort Daniel Spiewak

  5. 1

    Gestohlen blatently von der hervorragenden Scala by Example Buch, Kapitel 12, und mit ein paar Modifikationen:

    def repeatedSeq(idx: Int, lst:Seq[Int]): Stream[Int] = Stream.cons(lst(idx), repeatedSeq((idx + 1)%lst.length, lst))

for(i <- repeatedSeq(1,List(1,1,2,3,5))) println(i)

    Dies funktioniert für alle Seq-Typen (es sei denn, Sie kann nicht gelesen werden aus mehreren Zeiten, natürlich). Vielleicht nicht effizient, wenn die .Länge Aufruf langsam ist. Getestet in Scala 2.7.7.

    InformationsquelleAutor der Antwort Justin W

Schreibe einen Kommentar