Come creare una lista con lo stesso elemento n volte?

90

Implementazione manuale:

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)

C'è anche un modo integrato per fare lo stesso?

scala

— John Threepwood
fonte

164

See scala.collection.generic.SeqFactory.fill (n: Int) (elem: => A) che le strutture di dati raccolta, come Seq, Stream, Iteratore così via, si estendono:

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

ATTENZIONE Non è disponibile in Scala 2.7.

— kiritsuku
fonte

Vedi GenTraversableFactory per maggiori informazioni e # 14 su questa pagina: nicholassterling.wordpress.com/2012/01/28/scala-snippets

— AmigoNico

11

Usando in tabulatequesto modo,

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

— olmo
fonte

9

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

Funziona come un fascino.

— Danilo M. Oliveira
fonte

@AlonsodelArte Perché è uno spreco?

— k0pernikus

@ k0pernikus Perché il valore di _non ha importanza. Potresti fare n to 1 by -1, -1 to -n by -1ecc.

— Alonso del Arte

1

@AlonsodelArte Alla fine, è necessaria una variabile di ciclo temporanea. Anche l' fillimplementazione del metodo costruisce internamente una variabile temporanea il cui valore non sarebbe importante fintanto che produce la giusta quantità nell'elenco. Quindi non mi dispiace ciò che non viene utilizzato _.

— k0pernikus

1

@ k0pernikus Non mi dispiacerebbe né sul REPL Scala locale né in uno snippet di Scastie. Ma su un progetto professionale, lo considererei un motivo sufficiente per il refactoring.

— Alonso del Arte

1

Ho un'altra risposta che emula flatMap penso (ho scoperto che questa soluzione restituisce Unit quando si applica 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)(_) }

ma questo è piuttosto per un elenco predeterminato e vuoi duplicare n volte ogni elemento

— Tomás Duhourq
fonte