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

Question 1

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

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

Question 2

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

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")

Question 3

স্কেল সংগ্রহগুলি আছে count:list.count(_ == 2)

Question 4

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

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)

Question 5

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)

Question 6

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))

Question 7

শুরু করা হচ্ছে 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(_ + _))

Question 8

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

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

Question 9

আপনি যদি এটি ব্যবহার করতে চান তবে আপনাকে 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

Question 10

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

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)

Question 11

এটি লক্ষণীয় আকর্ষণীয় যে মানচিত্রটি ডিফল্ট 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এমনকি পরিবর্তনীয় মানচিত্রের চেয়েও দ্রুত!

Question 12

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

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

Question 13

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

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)

Question 14

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

Question 15

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

import cats.implicits._

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

Question 16

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

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

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

Question 17

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

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)