How to merge two lists of tuples?

Question

I have two lists in Scala, how to merge them such that the tuples are grouped together?

Is there an existing Scala list API which can do this or need I do it by myse

Answer 1

You can try the following one-line:

scala> ( l1 ++ l2 ).groupBy( _._1 ).map( kv => (kv._1, kv._2.map( _._2).sum ) ).toList
res6: List[(Symbol, Int)] = List(('a,5), ('c,2), ('b,2), ('d,1))

Where l1 and l2 are the lists of tuples you want merge.

Now, the breakdown:

• (l1 ++ l2) you just concatenate both lists
• .groupBy( _._1) you group all tuples by their first element. You will receive a Map with the first element as key and lists of tuples starting with this element as values.
• .map( kv => (kv._1, kv._2.map( _._2).sum ) ) you make a new map, with similar keys, but the values are the sum of all second elements.
• .toList you convert the result back to a list.

Alternatively, you can use pattern matching to access the tuple elements.

( l1 ++ l2 ).groupBy( _._1 ).map{
  case (key,tuples) => (key, tuples.map( _._2).sum ) 
}.toList

Answer 2

Alternatively you can also use mapValues to shorten the code.

mapValues, as you can probably guess, allows you to re-map just the value for each (key, value) pair in the Map created by groupBy.

In this case the function passed to mapValues reduces each (Char, Int) tuple to just the Int then sums the resulting List of Ints.

(l1 ::: l2).groupBy(_._1).mapValues(_.map(_._2).sum).toList

If the order of the output list needs to follow your example, just add sorted which relies on an Ordering[(Char, Int)] implicit instance.

(l1 ::: l2).groupBy(_._1).mapValues(_.map(_._2).sum).toList.sorted

Answer 3

If you can assume that both List[(A,B)] are ordered according to Ordering[A], you could write something like:

def mergeLists[A,B](one:List[(A,B)], two:List[(A,B)])(op:(B,B)=>B)(implicit ord:Ordering[A]): List[(A,B)] = (one,two) match {
    case (xs, Nil) => xs
    case (Nil, ys) => ys
    case((a,b)::xs,(aa,bb)::ys) =>
      if (a == aa) (a, op(b,bb)) :: mergeLists(xs,ys)(op)(ord)
      else if (ord.lt(a,aa)) (a, b) :: mergeLists(xs, (aa,bb)::ys)(op)(ord)
      else (aa, bb) :: mergeLists((a,b) :: xs, ys)(op)(ord)
}

Unfortunately this isn't tail recursive.