Comment créer une liste avec le même élément n fois?

90

Mise en œuvre manuelle:

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)

Existe-t-il également un moyen intégré de faire de même?

scala

— John Threepwood
source

164

Voir scala.collection.generic.SeqFactory.fill (n: Int) (elem: => A) que les structures de données de collecte, comme Seq, Stream, Iteratoret ainsi de suite, étendent:

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

AVERTISSEMENT Il n'est pas disponible dans Scala 2.7.

— Kiritsuku
source

Voir GenTraversableFactory pour plus d'informations, et n ° 14 sur cette page: nicholassterling.wordpress.com/2012/01/28/scala-snippets

— AmigoNico

11

En utilisant tabulatecomme ça,

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

— orme
source

9

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

Fonctionne comme un charme.

— Danilo M. Oliveira
source

@AlonsodelArte Pourquoi est-ce du gaspillage?

— k0pernikus

@ k0pernikus Parce que la valeur de _n'a pas vraiment d'importance. Vous pourriez faire n to 1 by -1, -1 to -n by -1etc.

— Alonso del Arte

1

@AlonsodelArte Au final, il faut une variable de boucle temporaire. Même l' fillimplémentation de la méthode construit une variable temporaire en interne dont la valeur n'aurait pas d'importance tant qu'elle produit le bon montant dans la liste. Donc ça ne me dérange pas les inutilisés _.

— k0pernikus

1

@ k0pernikus Cela ne me dérangerait pas que ce soit sur le REPL Scala local ou dans un extrait de Scastie. Mais sur un projet professionnel, je considérerais que c'est une raison suffisante pour refactoriser.

— Alonso del Arte

1

J'ai une autre réponse qui émule flatMap je pense (j'ai découvert que cette solution renvoie Unit lors de l'application de duplicateN)

 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)(_) }

mais c'est plutôt pour une liste prédéterminée et vous voulez dupliquer n fois chaque élément

— Tomás Duhourq
source