Элегантный способ инвертировать карту в Scala


97

Изучая Scala в настоящее время, необходимо инвертировать карту, чтобы выполнить поиск по инвертированному значению-> ключу. Я искал простой способ сделать это, но нашел только:

(Map() ++ origMap.map(kvp=>(kvp._2->kvp._1)))

У кого-нибудь есть более элегантный подход?

Ответы:


174

Предполагая, что значения уникальны, это работает:

(Map() ++ origMap.map(_.swap))

Однако в Scala 2.8 это проще:

origMap.map(_.swap)

Возможность сделать это - одна из причин, по которой в Scala 2.8 появилась новая библиотека коллекций.


1
Осторожный! Вы можете потерять ценность с этим решением. Например, Map(1 -> "A", 2 -> "B", 3 -> "B").map(_.swap)результатMap(A -> 1, B -> 3)
dev-null

1
@ dev-null Мне очень жаль, но ваш пример не подпадает под требуемое предположение.
Дэниел С. Собрал

Я согласен. Извините, я упустил это из виду.
dev-null

45

Математически сопоставление может быть необратимым (инъективным), например, от Map[A,B], вы не можете получить Map[B,A], а скорее получите Map[B,Set[A]], потому что могут быть разные ключи, связанные с одними и теми же значениями. Итак, если вам интересно узнать все ключи, вот код:

scala> val m = Map(1 -> "a", 2 -> "b", 4 -> "b")
scala> m.groupBy(_._2).mapValues(_.keys)
res0: Map[String,Iterable[Int]] = Map(b -> Set(2, 4), a -> Set(1))

2
.map(_._1)было бы более разборчиво, как просто.keys
Cheezsteak

Теперь благодаря тебе даже на несколько символов короче. Теперь разница в том, что вы получаете Sets вместо Lists, как раньше.
Rok Kralj

1
Будьте осторожны при использовании, .mapValuesпотому что он возвращает представление. Иногда это именно то, что вам нужно, но если вы не будете осторожны, это может потреблять много памяти и процессора. Для того, чтобы заставить его в карту, вы можете сделать m.groupBy(_._2).mapVaues(_.keys).map(identity), или вы могли бы заменить вызов .mapValues(_.keys)с .map { case (k, v) => k -> v.keys }.
Марк Т.

10

Вы можете избежать файлов ._1 при повторении несколькими способами.

Вот один способ. Здесь используется частичная функция, охватывающая единственный случай, имеющий значение для карты:

Map() ++ (origMap map {case (k,v) => (v,k)})

Вот еще один способ:

import Function.tupled        
Map() ++ (origMap map tupled {(k,v) => (v,k)})

Итерация карты вызывает функцию с двухэлементным кортежем, а анонимной функции нужны два параметра. Function.tupled выполняет перевод.


6

Я пришел сюда в поисках способа инвертировать карту типа Map [A, Seq [B]] в Map [B, Seq [A]], где каждый B в новой карте связан с каждым A в старой карте для который B содержался в связанной последовательности.

Например,
Map(1 -> Seq("a", "b"), 2-> Seq("b", "c"))
преобразовал бы в
Map("a" -> Seq(1), "b" -> Seq(1, 2), "c" -> Seq(2))

Вот мое решение:

val newMap = oldMap.foldLeft(Map[B, Seq[A]]().withDefaultValue(Seq())) {
  case (m, (a, bs)) => bs.foldLeft(m)((map, b) => map.updated(b, m(b) :+ a))
}

где oldMap имеет тип, Map[A, Seq[B]]а newMap имеет типMap[B, Seq[A]]

Вложенные foldLefts заставляют меня немного съеживаться, но это самый простой способ, который я мог найти для выполнения такого типа инверсии. У кого-нибудь есть более чистое решение?


очень красивое решение! @Rok, его решение как - то иначе , чем ваш немного , я думаю , потому что он трансформирует: Map[A, Seq[B]]к Map[B, Seq[A]]где ваши trasnforms решения Map[A, Seq[B]]для Map[Seq[B], Seq[A]].
YH

1
В этом случае без двух вложенных складок и, возможно, более производительного:a.toSeq.flatMap { case (a, b) => b.map(_ -> a) }.groupBy(_._2).mapValues(_.map(_._1))
Рок Краль

6

Хорошо, это очень старый вопрос, на который есть много хороших ответов, но я создал идеальный, универсальный швейцарский армейский нож, Mapинвертор, и это место, чтобы его опубликовать.

Фактически это два инвертора. Один для отдельных элементов значения ...

//from Map[K,V] to Map[V,Set[K]], traverse the input only once
implicit class MapInverterA[K,V](m :Map[K,V]) {
  def invert :Map[V,Set[K]] =
    m.foldLeft(Map.empty[V, Set[K]]) {
      case (acc,(k, v)) => acc + (v -> (acc.getOrElse(v,Set()) + k))
    }
}

... и еще один, очень похожий, для коллекций значений.

import scala.collection.generic.CanBuildFrom
import scala.collection.mutable.Builder
import scala.language.higherKinds

//from Map[K,C[V]] to Map[V,C[K]], traverse the input only once
implicit class MapInverterB[K,V,C[_]](m :Map[K,C[V]]
                                     )(implicit ev :C[V] => TraversableOnce[V]) {
  def invert(implicit bf :CanBuildFrom[Nothing,K,C[K]]) :Map[V,C[K]] =
    m.foldLeft(Map.empty[V, Builder[K,C[K]]]) {
      case (acc, (k, vs)) =>
        vs.foldLeft(acc) {
          case (a, v) => a + (v -> (a.getOrElse(v,bf()) += k))
        }
    }.mapValues(_.result())
}

использование:

Map(2 -> Array('g','h'), 5 -> Array('g','y')).invert
//res0: Map(g -> Array(2, 5), h -> Array(2), y -> Array(5))

Map('q' -> 1.1F, 'b' -> 2.1F, 'c' -> 1.1F, 'g' -> 3F).invert
//res1: Map(1.1 -> Set(q, c), 2.1 -> Set(b), 3.0 -> Set(g))

Map(9 -> "this", 8 -> "that", 3 -> "thus", 2 -> "thus").invert
//res2: Map(this -> Set(9), that -> Set(8), thus -> Set(3, 2))

Map(1L -> Iterator(3,2), 5L -> Iterator(7,8,3)).invert
//res3: Map(3 -> Iterator(1, 5), 2 -> Iterator(1), 7 -> Iterator(5), 8 -> Iterator(5))

Map.empty[Unit,Boolean].invert
//res4: Map[Boolean,Set[Unit]] = Map()

Я бы предпочел, чтобы оба метода были в одном неявном классе, но чем больше времени я тратил на его изучение, тем более проблематичным это казалось.


3

Вы можете инвертировать карту, используя:

val i = origMap.map({case(k, v) => v -> k})

Проблема с этим подходом заключается в том, что если ваши значения, которые теперь стали хэш-ключами на вашей карте, не уникальны, вы удалите повторяющиеся значения. Проиллюстрировать:

scala> val m = Map("a" -> 1, "b" -> 2, "c" -> 3, "d" -> 1)
m: scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 2, c -> 3, d -> 1)

// Notice that 1 -> a is not in our inverted map
scala> val i = m.map({ case(k , v) => v -> k})
i: scala.collection.immutable.Map[Int,String] = Map(1 -> d, 2 -> b, 3 -> c)

Чтобы избежать этого, вы можете сначала преобразовать свою карту в список кортежей, а затем инвертировать, чтобы не отбрасывать повторяющиеся значения:

scala> val i = m.toList.map({ case(k , v) => v -> k})
i: List[(Int, String)] = List((1,a), (2,b), (3,c), (1,d))

1

В scala REPL:

scala> val m = Map(1 -> "one", 2 -> "two")
m: scala.collection.immutable.Map[Int,java.lang.String] = Map(1 -> one, 2 -> two)

scala> val reversedM = m map { case (k, v) => (v, k) }
reversedM: scala.collection.immutable.Map[java.lang.String,Int] = Map(one -> 1, two -> 2)

Обратите внимание, что повторяющиеся значения будут перезаписаны последним добавлением к карте:

scala> val m = Map(1 -> "one", 2 -> "two", 3 -> "one")
m: scala.collection.immutable.Map[Int,java.lang.String] = Map(1 -> one, 2 -> two, 3 -> one)

scala> val reversedM = m map { case (k, v) => (v, k) }
reversedM: scala.collection.immutable.Map[java.lang.String,Int] = Map(one -> 3, two -> 2)

1

Для начала Scala 2.13, чтобы поменять местами ключи / значения без потери ключей, связанных с одними и теми же значениями, мы можем использовать Mapновый метод groupMap , который (как следует из названия) является эквивалентом a groupByи mapping для сгруппированных элементов.

Map(1 -> "a", 2 -> "b", 4 -> "b").groupMap(_._2)(_._1)
// Map("b" -> List(2, 4), "a" -> List(1))

Это:

  • groups элементов на основе их второй части кортежа ( _._2) (групповая часть групповой карты)

  • maps сгруппированные элементы, взяв их первую часть кортежа ( _._1) (часть карты группы Map )

Это можно рассматривать как вариант однопроходной из map.groupBy(_._2).mapValues(_.map(_._1)).


Жаль , что это не превратится Map[K, C[V]]в Map[V, C[K]].
jwvh

0
  1. Инверсия - лучшее название для этой операции, чем обратная (как в «инверсии математической функции»).

  2. Я часто делаю это обратное преобразование не только на картах, но и на других коллекциях (включая Seq). Я считаю, что лучше не ограничивать определение моей обратной операции однозначными картами. Вот определение, с которым я работаю для карт (пожалуйста, предложите улучшения в моей реализации).

    def invertMap[A,B]( m: Map[A,B] ) : Map[B,List[A]] = {
      val k = ( ( m values ) toList ) distinct
      val v = k map { e => ( ( m keys ) toList ) filter { x => m(x) == e } }
      ( k zip v ) toMap
    }

Если это взаимно однозначная карта, вы получите одноэлементные списки, которые можно тривиально протестировать и преобразовать в карту [B, A], а не в карту [B, List [A]].


0

Мы можем попробовать использовать эту foldLeftфункцию, которая позаботится о столкновениях и инвертирует карту за один проход.

scala> def invertMap[A, B](inputMap: Map[A, B]): Map[B, List[A]] = {
     |     inputMap.foldLeft(Map[B, List[A]]()) {
     |       case (mapAccumulator, (value, key)) =>
     |         if (mapAccumulator.contains(key)) {
     |           mapAccumulator.updated(key, mapAccumulator(key) :+ value)
     |         } else {
     |           mapAccumulator.updated(key, List(value))
     |         }
     |     }
     |   }
invertMap: [A, B](inputMap: Map[A,B])Map[B,List[A]]

scala> val map = Map(1 -> 2, 2 -> 2, 3 -> 3, 4 -> 3, 5 -> 5)
map: scala.collection.immutable.Map[Int,Int] = Map(5 -> 5, 1 -> 2, 2 -> 2, 3 -> 3, 4 -> 3)

scala> invertMap(map)
res0: Map[Int,List[Int]] = Map(5 -> List(5), 2 -> List(1, 2), 3 -> List(3, 4))

scala> val map = Map("A" -> "A", "B" -> "A", "C" -> "C", "D" -> "C", "E" -> "E")
map: scala.collection.immutable.Map[String,String] = Map(E -> E, A -> A, B -> A, C -> C, D -> C)

scala> invertMap(map)
res1: Map[String,List[String]] = Map(E -> List(E), A -> List(A, B), C -> List(C, D))
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.