एक ही तत्व n-time के साथ एक सूची कैसे बनाएं?

Question

एक ही तत्व n-time के साथ एक सूची कैसे बनाएं?

मैन्युअल रूप से कार्यान्वयन:

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)

क्या ऐसा करने का एक अंतर्निहित तरीका भी है?

Answer 1

देखें scala.collection.generic.SeqFactory.fill (एन: इंट) (ELEM: => ए) कि संग्रह डेटा संरचनाओं, जैसे Seq, Stream, Iteratorऔर इतने पर, विस्तार:

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

चेतावनी यह स्केल 2.7 में उपलब्ध नहीं है।

Comments

अधिक जानकारी के लिए GenTraversableFactory देखें, और इस पृष्ठ पर # 14: nicholassterling.wordpress.com/2012/01/28/scala-snippets

— AmigoNico

Answer 2

tabulateइस तरह का उपयोग करते हुए ,

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

Answer 3

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

एक जादू की तरह काम करता है।

Comments

@AlonsodelArte यह बेकार क्यों है?

— k0pernikus

@ k0pernikus क्योंकि मूल्य _वास्तव में मायने नहीं रखता है। आप कर सकते हैं n to 1 by -1, -1 to -n by -1आदि

— अलोंसो डेल आरटे

@AlonsodelArte अंत में, एक अस्थायी लूप चर की जरूरत है। यहां तक ​​कि fillविधि का कार्यान्वयन आंतरिक रूप से एक अस्थायी चर का निर्माण करता है जिसका मूल्य तब तक कोई फर्क नहीं पड़ता जब तक कि यह सूची में सही मात्रा का उत्पादन नहीं करता। इसलिए मैं अप्रयुक्त मन नहीं है _।

— k0pernikus

@ k0pernikus मैं इसे स्थानीय स्काला REPL या स्कैस्टी स्निपेट पर बुरा नहीं मानूंगा। लेकिन एक पेशेवर परियोजना पर, मैं इसे रीफैक्टरिंग के लिए पर्याप्त कारण मानूंगा।

— अलोंसो डेल आरटे

Answer 4

मेरे पास एक और उत्तर है जो मुझे लगता है कि सपाट नक्शा का अनुकरण करता है (पता चला कि यह समाधान डुप्लिकेट लागू करते समय इकाई देता है)

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

लेकिन यह एक पूर्व निर्धारित सूची के लिए है और आप प्रत्येक तत्व के लिए n बार डुप्लिकेट करना चाहते हैं