স্ক্যালায় আমি কীভাবে একটি তালিকার সংখ্যার সংখ্যা গণনা করতে পারি


104
val list = List(1,2,4,2,4,7,3,2,4)

আমি এটি এর মতো বাস্তবায়ন করতে চাই: list.count(2)(রিটার্ন 3)


আমি জানি না স্কালায় একটি তালিকার আকার পেতে সঠিক উপায় আছে কিনা, তবে আপনার অবস্থার জন্য আপনি একটি সিকোয়েন্স ব্যবহার করতে পারেন।
— কুশে ফান্তাজিয়া

এই প্রশ্নটি কি এখনও উত্তরহীন? জিজ্ঞাসা করছেন কারণ আপনি হয়ত কোনওটিকেই ভুলে গিয়েছেন।
— টোবিয়াস কলব

উত্তর:


152

অন্য উত্তরের একটির কিছুটা ক্লিনার সংস্করণ হ'ল:

val s = Seq("apple", "oranges", "apple", "banana", "apple", "oranges", "oranges")

s.groupBy(identity).mapValues(_.size)

Mapমূল অনুক্রমের প্রতিটি আইটেমের জন্য একটি গণনা দিয়ে দেওয়া :

Map(banana -> 1, oranges -> 3, apple -> 3)

প্রশ্নটি জিজ্ঞাসা করে যে কোনও নির্দিষ্ট আইটেমের গণনা কীভাবে খুঁজে পাওয়া যায়। এই পদ্ধতির সাথে, সমাধানটির জন্য পছন্দসই উপাদানটিকে তার গণনা মানের সাথে ম্যাপিংয়ের প্রয়োজন হবে:

s.groupBy(identity).mapValues(_.size)("apple")

4
"পরিচয়" কি?
— ইগরোক

4
এটি পরিচয় ফাংশন, এখানে আলোচনা হিসাবে । ফাংশনটির groupByএকটি ফাংশন প্রয়োজন যা এটি উপাদানগুলির জন্য প্রযোজ্য যাতে এটি কীভাবে তাদের গ্রুপ করতে হয় তা জানে। তাদের পরিচয় অনুসারে উত্তরে স্ট্রিংগুলিকে গোষ্ঠীকরণের বিকল্প হতে পারে, বলুন, তাদের দৈর্ঘ্য ( groupBy(_.size)) বা তাদের প্রথম অক্ষর ( groupBy(_.head)) দ্বারা গ্রুপিং করা যেতে পারে ।
— ohruunuruus

4
অপূর্ণতাটি হ'ল প্রচুর অকেজো সংগ্রহ (কারণ কেবল আকারের প্রয়োজন হয়) তৈরি করা হয়।
— ইয়ান মোইসান

আমি যদি নতুন মানচিত্র তৈরির পরিবর্তে সেই অভিব্যক্তিতে কোনও সংযোজক মানচিত্রটি সংজ্ঞায়িত করতে চাই?
— টোবিয়াস কলব


48

শরৎ প্রভালের মতো আমারও একই সমস্যা ছিল এবং আমি আরও একটি সমাধান পেয়েছি:

val s = Seq("apple", "oranges", "apple", "banana", "apple", "oranges", "oranges")
s.groupBy(l => l).map(t => (t._1, t._2.length))

ফলাফল হিসাবে:

Map(banana -> 1, oranges -> 3, apple -> 3)

45
কিছুটা ক্লিনার সংস্করণটি হ'লs.groupBy(identity).mapValues(_.size)
— ohruunuruus

4
@ ওহরুনুরুস এর উত্তর হওয়া উচিত (বনাম মন্তব্য); আমি উত্সাহের সাথে উত্সাহ দিতে পছন্দ করব, যদি তা হয় (এবং আমি যদি ওপি ছিলাম তবে এটি সেরা উত্তর হিসাবে নির্বাচন করুন);
— ডগ

4
@ ডগ এসও-তে কিছুটা নতুন এবং নিশ্চিত ছিল না, তবে বাধ্য হয়ে খুশি
— ohruunuruus

27
list.groupBy(i=>i).mapValues(_.size)

দেয়

Map[Int, Int] = Map(1 -> 1, 2 -> 3, 7 -> 1, 3 -> 1, 4 -> 3)

মনে রাখবেন যে আপনি (i=>i)বিল্ট ইন identityফাংশন দিয়ে প্রতিস্থাপন করতে পারেন :

list.groupBy(identity).mapValues(_.size)

অন্তর্নির্মিত গ্রন্থাগারগুলি ব্যবহার করে সংক্ষিপ্ত সমাধানগুলি ভালোবাসি
— রুস্তম আলিয়েভ

14
val list = List(1, 2, 4, 2, 4, 7, 3, 2, 4)
// Using the provided count method this would yield the occurrences of each value in the list:
l map(x => l.count(_ == x))

List[Int] = List(1, 3, 3, 3, 3, 1, 1, 3, 3)
// This will yield a list of pairs where the first number is the number from the original list and the second number represents how often the first number occurs in the list:
l map(x => (x, l.count(_ == x)))
// outputs => List[(Int, Int)] = List((1,1), (2,3), (4,3), (2,3), (4,3), (7,1), (3,1), (2,3), (4,3))

4
কিন্তু এটি সংখ্যা দেয়। প্রতিটি মানের জন্য যতবার মান আসে তার সংঘটনগুলি
— nces

14

শুরু করা হচ্ছে Scala 2.13, গ্রুপম্যাপ্রেডস পদ্ধতিটি তালিকার এক পাসে এটি করে:

// val seq = Seq("apple", "oranges", "apple", "banana", "apple", "oranges", "oranges")
seq.groupMapReduce(identity)(_ => 1)(_ + _)
// immutable.Map[String,Int] = Map(banana -> 1, oranges -> 3, apple -> 3)
seq.groupMapReduce(identity)(_ => 1)(_ + _)("apple")
// Int = 3

এই:

  • groupগুলি তালিকাভুক্ত উপাদানসমূহ ( গ্রুপ ম্যাপ্রেডিউসের গ্রুপ অংশ )

  • mapপ্রতিটি গ্রুপযুক্ত মান সংঘটন 1 (গ্রুপ মানচিত্র হ্রাস এর মানচিত্র অংশ )

  • reduceমানগুলির একটি গোষ্ঠীর মধ্যে মানগুলি ( _ + _) এর সংক্ষিপ্ত করে (গ্রুপম্যাপ হ্রাসের অংশ হ্রাস করুন )।

এটি যা অনুবাদ করতে পারে তার এক-পাস সংস্করণ :

seq.groupBy(identity).mapValues(_.map(_ => 1).reduce(_ + _))

ভাল লাগল, আমি এটিই সন্ধান করছিলাম, আমি এটি দু: খজনক দেখতে পেলাম যে জাভা প্রবাহগুলিও (যা কিছু দিক দিয়ে ভাল নয়) একক পাসে এটিকে অনুমতি দেয় যখন স্কেলা পারেনি।
— Dici

9

আমি একই সমস্যায় পড়েছি কিন্তু একসাথে একাধিক আইটেম গণনা করতে চেয়েছিলাম ..

val s = Seq("apple", "oranges", "apple", "banana", "apple", "oranges", "oranges")
s.foldLeft(Map.empty[String, Int]) { (m, x) => m + ((x, m.getOrElse(x, 0) + 1)) }
res1: scala.collection.immutable.Map[String,Int] = Map(apple -> 3, oranges -> 3, banana -> 1)

https://gist.github.com/sharathprabhal/6890475


সম্ভবত ব্যবহার করে Streamএবং গৃহীত উত্তরটি আপনার "ওয়ান গো" প্লাস ক্লিয়ার কোডের লক্ষ্য অর্জন করবে।
— জুলাইচিত

এই দ্রষ্টব্যটি গ্রুপবাই ব্যবহার করে তালিকার কেবল একবারে পুনরাবৃত্তি করে এবং তারপরে মানচিত্রটি এটি দু'বার করবে।
— ruloweb

7

আপনি যদি এটি ব্যবহার করতে চান তবে আপনাকে list.count(2)একটি অন্তর্ভুক্ত ক্লাস ব্যবহার করে এটি প্রয়োগ করতে হবে ।

implicit class Count[T](list: List[T]) {
  def count(n: T): Int = list.count(_ == n)
}

List(1,2,4,2,4,7,3,2,4).count(2)  // returns 3
List(1,2,4,2,4,7,3,2,4).count(5)  // returns 0

7

সংক্ষিপ্ত উত্তর:

import scalaz._, Scalaz._
xs.foldMap(x => Map(x -> 1))

দীর্ঘ উত্তর:

স্ক্যালাজ ব্যবহার করে , দেওয়া হচ্ছে।

import scalaz._, Scalaz._

val xs = List('a, 'b, 'c, 'c, 'a, 'a, 'b, 'd)

তারপরে এই সমস্তগুলি (আরও সরলীকরণের চেয়ে কম সরীকরণের ক্রমে)

xs.map(x => Map(x -> 1)).foldMap(identity)
xs.map(x => Map(x -> 1)).foldMap()
xs.map(x => Map(x -> 1)).suml
xs.map(_ -> 1).foldMap(Map(_))
xs.foldMap(x => Map(x -> 1))

ফলন

Map('b -> 2, 'a -> 3, 'c -> 2, 'd -> 1)

6

এটি লক্ষণীয় আকর্ষণীয় যে মানচিত্রটি ডিফল্ট 0 মান সহ, ইচ্ছাকৃতভাবে এই মামলার জন্য ডিজাইন করা সবচেয়ে খারাপ কার্য সম্পাদন করে (এবং হিসাবে সংক্ষিপ্ত নয় groupBy)

    type Word = String
    type Sentence = Seq[Word]
    type Occurrences = scala.collection.Map[Char, Int]

  def woGrouped(w: Word): Occurrences = {
        w.groupBy(c => c).map({case (c, list) => (c -> list.length)})
  }                                               //> woGrouped: (w: forcomp.threadBug.Word)forcomp.threadBug.Occurrences

  def woGetElse0Map(w: Word): Occurrences = {
        val map = Map[Char, Int]()
        w.foldLeft(map)((m, c) => m + (c -> (m.getOrElse(c, 0) + 1)) )
  }                                               //> woGetElse0Map: (w: forcomp.threadBug.Word)forcomp.threadBug.Occurrences

  def woDeflt0Map(w: Word): Occurrences = {
        val map = Map[Char, Int]().withDefaultValue(0)
        w.foldLeft(map)((m, c) => m + (c -> (m(c) + 1)) )
  }                                               //> woDeflt0Map: (w: forcomp.threadBug.Word)forcomp.threadBug.Occurrences

  def dfltHashMap(w: Word): Occurrences = {
        val map = scala.collection.immutable.HashMap[Char, Int]().withDefaultValue(0)
        w.foldLeft(map)((m, c) => m + (c -> (m(c) + 1)) )
    }                                             //> dfltHashMap: (w: forcomp.threadBug.Word)forcomp.threadBug.Occurrences

    def mmDef(w: Word): Occurrences = {
        val map = scala.collection.mutable.Map[Char, Int]().withDefaultValue(0)
        w.foldLeft(map)((m, c) => m += (c -> (m(c) + 1)) )
  }                                               //> mmDef: (w: forcomp.threadBug.Word)forcomp.threadBug.Occurrences

    val functions = List("grp" -> woGrouped _, "mtbl" -> mmDef _, "else" -> woGetElse0Map _
    , "dfl0" -> woDeflt0Map _, "hash" -> dfltHashMap _
    )                                  //> functions  : List[(String, String => scala.collection.Map[Char,Int])] = Lis
                                                  //| t((grp,<function1>), (mtbl,<function1>), (else,<function1>), (dfl0,<functio
                                                  //| n1>), (hash,<function1>))


    val len = 100 * 1000                      //> len  : Int = 100000
    def test(len: Int) {
        val data: String = scala.util.Random.alphanumeric.take(len).toList.mkString
        val firstResult = functions.head._2(data)

        def run(f: Word => Occurrences): Int = {
            val time1 = System.currentTimeMillis()
            val result= f(data)
            val time2 = (System.currentTimeMillis() - time1)
            assert(result.toSet == firstResult.toSet)
            time2.toInt
        }

        def log(results: Seq[Int]) = {
                 ((functions zip results) map {case ((title, _), r) => title + " " + r} mkString " , ")
        }

        var groupResults = List.fill(functions.length)(1)

        val integrals = for (i <- (1 to 10)) yield {
            val results = functions map (f => (1 to 33).foldLeft(0) ((acc,_) => run(f._2)))
            println (log (results))
                groupResults = (results zip groupResults) map {case (r, gr) => r + gr}
                log(groupResults).toUpperCase
        }

        integrals foreach println

    }                                         //> test: (len: Int)Unit


    test(len)
    test(len * 2)
// GRP 14 , mtbl 11 , else 31 , dfl0 36 , hash 34
// GRP 91 , MTBL 111

    println("Done")
    def main(args: Array[String]) {
    }

উত্পাদন

grp 5 , mtbl 5 , else 13 , dfl0 17 , hash 17
grp 3 , mtbl 6 , else 14 , dfl0 16 , hash 16
grp 3 , mtbl 6 , else 13 , dfl0 17 , hash 15
grp 4 , mtbl 5 , else 13 , dfl0 15 , hash 16
grp 23 , mtbl 6 , else 14 , dfl0 15 , hash 16
grp 5 , mtbl 5 , else 13 , dfl0 16 , hash 17
grp 4 , mtbl 6 , else 13 , dfl0 16 , hash 16
grp 4 , mtbl 6 , else 13 , dfl0 17 , hash 15
grp 3 , mtbl 5 , else 14 , dfl0 16 , hash 16
grp 3 , mtbl 6 , else 14 , dfl0 16 , hash 16
GRP 5 , MTBL 5 , ELSE 13 , DFL0 17 , HASH 17
GRP 8 , MTBL 11 , ELSE 27 , DFL0 33 , HASH 33
GRP 11 , MTBL 17 , ELSE 40 , DFL0 50 , HASH 48
GRP 15 , MTBL 22 , ELSE 53 , DFL0 65 , HASH 64
GRP 38 , MTBL 28 , ELSE 67 , DFL0 80 , HASH 80
GRP 43 , MTBL 33 , ELSE 80 , DFL0 96 , HASH 97
GRP 47 , MTBL 39 , ELSE 93 , DFL0 112 , HASH 113
GRP 51 , MTBL 45 , ELSE 106 , DFL0 129 , HASH 128
GRP 54 , MTBL 50 , ELSE 120 , DFL0 145 , HASH 144
GRP 57 , MTBL 56 , ELSE 134 , DFL0 161 , HASH 160
grp 7 , mtbl 11 , else 28 , dfl0 31 , hash 31
grp 7 , mtbl 10 , else 28 , dfl0 32 , hash 31
grp 7 , mtbl 11 , else 28 , dfl0 31 , hash 32
grp 7 , mtbl 11 , else 28 , dfl0 31 , hash 33
grp 7 , mtbl 11 , else 28 , dfl0 32 , hash 31
grp 8 , mtbl 11 , else 28 , dfl0 31 , hash 33
grp 8 , mtbl 11 , else 29 , dfl0 38 , hash 35
grp 7 , mtbl 11 , else 28 , dfl0 32 , hash 33
grp 8 , mtbl 11 , else 32 , dfl0 35 , hash 41
grp 7 , mtbl 13 , else 28 , dfl0 33 , hash 35
GRP 7 , MTBL 11 , ELSE 28 , DFL0 31 , HASH 31
GRP 14 , MTBL 21 , ELSE 56 , DFL0 63 , HASH 62
GRP 21 , MTBL 32 , ELSE 84 , DFL0 94 , HASH 94
GRP 28 , MTBL 43 , ELSE 112 , DFL0 125 , HASH 127
GRP 35 , MTBL 54 , ELSE 140 , DFL0 157 , HASH 158
GRP 43 , MTBL 65 , ELSE 168 , DFL0 188 , HASH 191
GRP 51 , MTBL 76 , ELSE 197 , DFL0 226 , HASH 226
GRP 58 , MTBL 87 , ELSE 225 , DFL0 258 , HASH 259
GRP 66 , MTBL 98 , ELSE 257 , DFL0 293 , HASH 300
GRP 73 , MTBL 111 , ELSE 285 , DFL0 326 , HASH 335
Done

এটি কৌতূহল যে সবচেয়ে সংক্ষিপ্ততর groupByএমনকি পরিবর্তনীয় মানচিত্রের চেয়েও দ্রুত!


4
আমি এই বেঞ্চমার্কটি সম্পর্কে একটু সন্দেহজনক কারণ এটি ডেটার আকার কী তা পরিষ্কার নয়। groupByসমাধান সঞ্চালিত toLowerকিন্তু অন্যরা না। এছাড়াও মানচিত্রে কেন কোনও প্যাটার্ন ম্যাচ ব্যবহার করবেন - কেবল ব্যবহার করুন mapValues। সুতরাং এটি একসাথে রোল করুন এবং আপনি পান def woGrouped(w: Word): Map[Char, Int] = w.groupBy(identity).mapValues(_.size)- এটি চেষ্টা করে দেখুন এবং বিভিন্ন আকারের তালিকার জন্য কর্মক্ষমতা পরীক্ষা করুন check অবশেষে অন্যান্য সমাধানগুলিতে, mapক) কেন ঘোষণা করুন এবং খ) এটিকে একটি ভার বানিয়েছেন ?? শুধু করুনw.foldLeft(Map.empty[Char, Int])...
— সামিটবেস্ট

4
আরও ডেটা সরবরাহ করার জন্য ধন্যবাদ (আমার ভোট পরিবর্তন হয়েছে :)। আমি মনে করি যে গ্রুপবাইয়ের বাস্তবায়নের কারণটি পুনরুক্তিযুক্ত Builderবৃদ্ধির জন্য অনুকূলিত হওয়া একটি পরিবর্তিত মানচিত্র ব্যবহার করে । এরপরে এটি ব্যবহার করে পরিবর্তনীয় মানচিত্রকে পরিবর্তনযোগ্য হিসাবে রূপান্তরিত করে MapBuilder। জিনিসগুলি আরও দ্রুত করার জন্য হুডের নীচে সম্ভবত কিছু অলস মূল্যায়ন চলছে।
— সামতিবেস্ট

@ সাম্তেবেস্ট আপনি কেবল কাউন্টারটি সন্ধান করছেন এবং এটি বাড়িয়ে তোলেন। সেখানে কী ক্যাশে করা যায় তা আমি দেখছি না। ক্যাশে যেভাবেই হোক একই ধরণের মানচিত্র হওয়া দরকার।
— Val,

আমি বলছি না এটি কিছু ক্যাশে করে। আমি কল্পনা করেছি পারফরম্যান্স বৃদ্ধি Builderএস এর ব্যবহার এবং সম্ভবত কিছু অলস মূল্যায়ন থেকে আসে ।
— সামথবেস্ট

@ সাম্তিবেস্ট অলস মূল্যায়ন = বিলম্বিত মূল্যায়ন (নাম ধরে ডাক) + ক্যাচিং। আপনি অলস মূল্যায়ন সম্পর্কে কথা বলতে পারবেন না তবে ক্যাশে করছেন না।
— Val,

4

আমি ব্যবহার করে তালিকার আকারটি পাইনি lengthবরং এখানেsize উল্লিখিত সমস্যার কারণে উপরের উত্তর হিসাবে এটির প্রস্তাব দেওয়া হয়েছে ।

val list = List("apple", "oranges", "apple", "banana", "apple", "oranges", "oranges")
list.groupBy(x=>x).map(t => (t._1, t._2.size))

3

এখানে আরও একটি বিকল্প রয়েছে:

scala> val list = List(1,2,4,2,4,7,3,2,4)
list: List[Int] = List(1, 2, 4, 2, 4, 7, 3, 2, 4)

scala> list.groupBy(x => x) map { case (k,v) => k-> v.length }
res74: scala.collection.immutable.Map[Int,Int] = Map(1 -> 1, 2 -> 3, 7 -> 1, 3 -> 1, 4 -> 3)

3
scala> val list = List(1,2,4,2,4,7,3,2,4)
list: List[Int] = List(1, 2, 4, 2, 4, 7, 3, 2, 4)

scala> println(list.filter(_ == 2).size)
3

3

বিড়াল ব্যবহার

import cats.implicits._

"Alphabet".toLowerCase().map(c => Map(c -> 1)).toList.combineAll
"Alphabet".toLowerCase().map(c => Map(c -> 1)).toList.foldMap(identity)

4
বাহ, মূল ক্রম দিয়ে 4 পুনরাবৃত্তি! এমনকি seq.groupBy(identity).mapValues(_.size)শুধুমাত্র দু'বারের মধ্যে দিয়ে যায়।
— অস্ত্র গ্রেড

পুনরাবৃত্তিও সংখ্যা না ব্যাপার "বর্ণমালা" মত একটি ছোট স্ট্রিং এর জন্য, কিন্তু একটি সংগ্রহ আইটেম লক্ষ লক্ষ সঙ্গে যখন কারবারী, পুনরাবৃত্তিও অবশ্যই may না ব্যাপার!
— অস্ত্র গ্রেড

2

এটি চেষ্টা করুন, কাজ করা উচিত।


val list = List(1,2,4,2,4,7,3,2,4)
list.count(_==2) 

এটি ফিরে আসবে 3


4
সাত বছর আগে দেওয়া জেফিয়ের উত্তর থেকে এটি কীভাবে আলাদা?
— jwvh

0

এটি করার জন্য এখানে একটি সহজ উপায়।

val data = List("it", "was", "the", "best", "of", "times", "it", "was", 
                 "the", "worst", "of", "times")
data.foldLeft(Map[String,Int]().withDefaultValue(0)){
  case (acc, letter) =>
    acc + (letter -> (1 + acc(letter)))
}
// => Map(worst -> 1, best -> 1, it -> 2, was -> 2, times -> 2, of -> 2, the -> 2)
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.