Wie erstelle ich n-mal eine Liste mit demselben Element?

90

Manuelle Implementierung:

scala> def times(n: Int, s: String) =
 | (for(i <- 1 to n) yield s).toList
times: (n: Int, s: String)List[String]

scala> times(3, "foo")
res4: List[String] = List(foo, foo, foo)

Gibt es auch eine eingebaute Möglichkeit, dasselbe zu tun?

scala

— John Threepwood
quelle

163

Siehe scala.collection.generic.SeqFactory.fill (n: Int) (Elem: => A) , dass Sammeldatenstrukturen, wie Seq, Stream, Iteratorund so weiter, erweitern:

scala> List.fill(3)("foo")
res1: List[String] = List(foo, foo, foo)

WARNUNG Es ist in Scala 2.7 nicht verfügbar.

— kiritsuku
quelle

Siehe GenTraversableFactory für weitere Informationen und # 14 auf dieser Seite: nicholassterling.wordpress.com/2012/01/28/scala-snippets

— AmigoNico

11

Verwenden Sie tabulateso,

List.tabulate(3)(_ => "foo")

— Ulme
quelle

9

(1 to n).map( _ => "foo" )

Klappt wunderbar.

— Danilo M. Oliveira
quelle

@AlonsodelArte Warum ist es verschwenderisch?

— k0pernikus

@ k0pernikus Weil der Wert von _eigentlich keine Rolle spielt. Sie könnten tun n to 1 by -1, -1 to -n by -1etc.

— Alonso del Arte

@AlonsodelArte Am Ende benötigt man eine temporäre Schleifenvariable. Selbst die fillImplementierung der Methode erstellt intern eine temporäre Variable, deren Wert keine Rolle spielt, solange die richtige Menge in der Liste erzeugt wird. Das Unbenutzte macht mir also nichts aus _.

— k0pernikus

1

@ k0pernikus Ich hätte nichts dagegen, weder auf der lokalen Scala REPL noch in einem Scastie-Snippet. Aber bei einem professionellen Projekt würde ich es als Grund genug für ein Refactoring betrachten.

— Alonso del Arte

1

Ich habe eine andere Antwort, die meiner Meinung nach flatMap emuliert (ich habe herausgefunden, dass diese Lösung Unit zurückgibt, wenn duplicateN angewendet wird).

 implicit class ListGeneric[A](l: List[A]) {
  def nDuplicate(x: Int): List[A] = {
    def duplicateN(x: Int, tail: List[A]): List[A] = {
      l match {
       case Nil => Nil
       case n :: xs => concatN(x, n) ::: duplicateN(x, xs)
    }
    def concatN(times: Int, elem: A): List[A] = List.fill(times)(elem)
  }
  duplicateN(x, l)
}

}}

def times(n: Int, ls: List[String]) = ls.flatMap{ List.fill(n)(_) }

Dies ist jedoch eher für eine vorgegebene Liste und Sie möchten jedes Element n-mal duplizieren

— Tomás Duhourq
quelle