Scala - Combine two lists in an alternating fashion

Question

How do I merge 2 lists in such a way that the resulting list contains the elements of 2 lists in alternating fashion in Scala.

Input:

val list1 = List("Mary", "a", "lamb")

val list2 = List("had", "little")

Output:

List("Mary", "had", "a", "little", "lamb")

Similar question for arbitrary number of lists: http://stackoverflow.com/q/19097078/770361 — Luigi Plinge, Nov 06 '13 at 13:25

yan · Accepted Answer · 2013-11-06T12:03:49.550

21

What you're looking for is usually called "intersperse" or "intercalate" and there are a few ways to do it:

def intersperse[A](a : List[A], b : List[A]): List[A] = a match {
  case first :: rest => first :: intersperse(b, rest)
  case _             => b
}

You can also use scalaz

import scalaz._
import Scalaz._

val lst1 = ...
val lst2 = ...

lst1 intercalate lst2

Edit: You can also do the following:

lst1.zipAll(lst2,"","") flatMap { case (a, b) => Seq(a, b) }

Come to think of it, I believe the last solution is my favorite since it's most concise while still being clear. If you're already using Scalaz, I'd use the second solution. The first is also very readable however.

And just to make this answer more complete, adding @Travis Brown's solution that is generic:

list1.map(List(_)).zipAll(list2.map(List(_)), Nil, Nil).flatMap(Function.tupled(_ ::: _))

edited Nov 06 '13 at 12:03

answered Nov 06 '13 at 11:46

yan

20,644
3
38
48

2

Your last solution won't work if the lists aren't the same length—you'd need the much less elegant `list1.map(List(_)).zipAll(list2.map(List(_)), Nil, Nil).flatMap(Function.tupled(_ ::: _))`. – Travis Brown Nov 06 '13 at 11:55
@yan: 1st solution fails when the first list is empty. – yAsH Nov 06 '13 at 11:56
@TravisBrown fixed the last solution while still being somewhat elegant (although not generic) – yan Nov 06 '13 at 11:57
@raHul how? `intersperse(Nil, List(1,2,3))` => `List(1, 2, 3)` – yan Nov 06 '13 at 11:58
@yan: Exception in thread "main" java.lang.UnsupportedOperationException: tail of empty list. This is the exception that I got – yAsH Nov 06 '13 at 12:01
What version of Scala? That really shouldn't happen since the first case should not match if the list is empty. – yan Nov 06 '13 at 12:02
@raHul I guess you were using my version with empty list check placed as second to get that exception – arkonautom Nov 06 '13 at 12:02
I am using Scala 2.9.2 – yAsH Nov 06 '13 at 12:03
As @arkonautom said, are you sure you're using the solution I provided? – yan Nov 06 '13 at 12:04
it would be interesting to have a solution to interscalate multiple lists – Sebastien Lorber Apr 27 '17 at 13:44

arkonautom · Answer 2 · 2013-11-06T12:09:43.710

5

val list1 = List("Mary", "a", "lamb")
val list2 = List("had", "little")

def merge1(list1: List[String], list2: List[String]): List[String] = {
    if (list1.isEmpty) list2
    else list1.head :: merge(list2, list1.tail)
}

def merge2(list1: List[String], list2: List[String]): List[String] = list1 match {
    case List() => list2
    case head :: tail => head :: merge(list2, tail)
} 

merge1(list1, list2)
merge2(list1, list2)
//> List[String] = List(Mary, had, a, little, lamb)

edited Nov 06 '13 at 12:09

answered Nov 06 '13 at 11:39

arkonautom

958
18
29

1

This would be much nicer if you matched on the structure of the list rather than using `head` and `tail`. – Travis Brown Nov 06 '13 at 11:43
ty, added version with matching – arkonautom Nov 06 '13 at 11:47
1

@arkonautom, I don't think that's what Travis Brown had in mind. Check my answer for a match on structure – yan Nov 06 '13 at 11:49
@yan yours is better indeed ... almost did it, have a +1 ;) – arkonautom Nov 06 '13 at 11:50

score 1 · Answer 3 · answered Nov 06 '13 at 11:45

1

list1.zipAll(list2,"","").flatMap(_.productIterator.toList).filter(_ != "")

answered Nov 06 '13 at 11:45

Ankur

33,367
2
46
72

score 1 · Answer 4 · answered Nov 06 '13 at 11:46

You could do something like this:

def alternate[A]( a: List[A], b: List[A] ): List[A] = {
    def first( a: List[A], b: List[A] ): List[A] = a match {
        case Nil => Nil
        case x :: xs => x :: second( xs, b )
    }

    def second( a: List[A], b: List[A] ): List[A] = b match {
        case Nil => Nil
        case y :: ys => y :: first( a, ys )
    }

    first( a, b )
}

Scala - Combine two lists in an alternating fashion

4 Answers4

Linked

Related