Scala 如何在以下列表中与 Map[String, Double] 类型的地图相交：List[Map[String, Double]]

Question

So I have a list of maps: List[Map[String, Double]]. An example of it would be:

List(Map("A" -> 1.1, "B" -> 2.5, "E" -> 3.5, "C" -> 1.6, "D" -> 0.9), 
        Map("A" -> 0.8, "C" -> 2.1, "D" -> 2.8), 
        Map("C" -> 2.2, "D" -> 2.9, "A" -> 3.4), 
        Map("B" -> 0.4, "D" -> 1.8, "E" -> 0.234, "A" -> 3.7))

What I want to do is to get the intersect of all of the maps together so then it looks like:

   For example, for A: (1.1 + 0.8 + 3.4 + 3.7)/4 = 2.25
                for D: (0.9 + 2.8 + 2.9 + 1.8)/4 = 2.1

   List(Map("A" -> 2.25,"D" -> 2.1))

Is there a way to get the intersected list of map above using built in functions only? The values are the average of all of the keys in the four maps combined.

Answer 1

Try first using reduce to keep only duplicate keys and add up all the values, and then use mapValues to get the mean:

val maps = List(...)

val intersected = maps
  .reduce { (m1, m2) =>
    m1.keySet.intersect(m2.keySet).map(key => (key, m1(key) + m2(key))).toMap
  }
  .view
  .mapValues(_ / maps.size)
  .toMap

Scastie

This question is similar.

Answer 2

Have to be careful that the input isn't empty.

val lm : List[Map[String,Double]] =
  List(Map("A" -> 1.1, "B" -> 2.5, "E" -> 3.5, "C" -> 1.6, "D" -> 0.9)
      ,Map("A" -> 0.8, "C" -> 2.1, "D" -> 2.8)
      ,Map("C" -> 2.2, "D" -> 2.9, "A" -> 3.4)
      ,Map("B" -> 0.4, "D" -> 1.8, "E" -> 0.234, "A" -> 3.7))

val len = lm.length
val res = if (len > 0)
            lm.map(_.keySet)
              .reduce(_ intersect _)
              .map(k => (k, lm.map(_(k)).sum/len))
              .toMap
          else Map.empty[String,Double]
//res: Map[String,Double] = Map(A -> 2.25, D -> 2.1)

Answer 3

Assuming we have:

val list = List(Map("A" -> 1.1, "B" -> 2.5, "E" -> 3.5, "C" -> 1.6, "D" -> 0.9),
  Map("A" -> 0.8, "C" -> 2.1, "D" -> 2.8),
  Map("C" -> 2.2, "D" -> 2.9, "A" -> 3.4),
  Map("B" -> 0.4, "D" -> 1.8, "E" -> 0.234, "A" -> 3.7))

Another option you have is (only Scala 2.13):

val stringToDoubles =
  list.flatten
    .groupMap(_._1)(_._2)
    .filter(_._2.size == list.size)
    .map(keyAndValues => (keyAndValues._1, keyAndValues._2.sum / list.size))

Code run can be found at scastie .

In Scala 2.12 and below it will be:

val stringToDoubles =
  list.flatten
    .groupBy(_._1)
    .filter(_._2.size == list.size)
    .map(keyAndValues => (keyAndValues._1, keyAndValues._2.map(_._2).sum / list.size))

Code run can be found at scastie .

Answer 4

If you are open to using external libraries, this becomes very simple with cats :

import cats.data.NonEmptyList
import cats.syntax.all._

val data = NonEmptyList.of(
  Map("A" -> 1.1, "B" -> 2.5, "E" -> 3.5, "C" -> 1.6, "D" -> 0.9),
  Map("A" -> 0.8, "C" -> 2.1, "D" -> 2.8),
  Map("C" -> 2.2, "D" -> 2.9, "A" -> 3.4),
  Map("B" -> 0.4, "D" -> 1.8, "E" -> 0.234, "A" -> 3.7)
)

val result =
  data
    .nonEmptySequence
    .fmap { group =>
      val (sum, count) = group.foldMap(_ -> 1)
      sum / count
    }
// result: Map[String, Double] = HashMap(A -> 2.25, D -> 2.1)

---

You can see the code running here .