Create function to group sequence at breakpoints - scala

Question

I'm trying to create a function that takes two sequences and groups the elements first based on the "breakpoints" included in the second. An example:
val ls = ('a' to 'z').map(_.toString)
// IndexedSeq[String] = Vector(a, b, c, d, e, f, g, h, i, j, k, l, m, ...)
val breakpoints = Seq("c", "f", "j")
grouper(ls, breakpoints)
// Seq(Seq("a", "b"), Seq("c", "d", "e"), Seq("f", "g", "h", "i"), Seq("j", ...))
I've tried to do this with recursive calls to takeWhile and dropWhile (as I might in a language like Haskell), but as my current function doesn't use tail recursion, I receive a java.lang.StackOverflowError. Here's the function:
def grouper(strings: Seq[String], breaks: Seq[String]): Seq[Seq[String]] = strings match {
case Nil => Seq()
case s => s.takeWhile(breaks.contains(_)) +: grouper(s.dropWhile(breaks.contains(_)), breaks)
}
Is there a better way to approach this?

Answer 1

You're on the right track. takeWhile and dropWhile can be replaced by span.
def grouper(xs: Seq[String], breaks: Seq[String]): Seq[Seq[String]] = breaks match{
case Nil => Seq(xs)
case h::t => {
val split = xs.span(x => x != h);
split._1 +: grouper(split._2, t);
}
}
scala> grouper(ls, breakpoints)
res5: Seq[Seq[String]] = List(Vector(a, b), Vector(c, d, e), Vector(f, g, h, i),
Vector(j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z))
From the API on span: Note: c span p is equivalent to (but possibly more efficient than) (c takeWhile p, c dropWhile p), provided the evaluation of the predicate p does not cause any side-effects.

Answer 2

For this kind of problems, I always prefer to write my own tail-recursive function, operating o Lists.
import Ordering.Implicits._
def group[A : Ordering](data: List[A], breakPoints: List[A]): List[List[A]] = {
def takeUntil(list: List[A], breakPoint: A): (List[A], List[A]) = {
#annotation.tailrec
def loop(remaining: List[A], acc: List[A]): (List[A], List[A]) =
remaining match {
case x :: xs if (x < breakPoint) =>
loop(remaining = xs, x :: acc)
case _ =>
(acc.reverse, remaining)
}
loop(remaining = list, acc = List.empty)
}
#annotation.tailrec
def loop(remainingElements: List[A], remainingBreakPoints: List[A], acc: List[List[A]]): List[List[A]] =
remainingBreakPoints match {
case breakPoint :: remainingBreakPoints =>
val (group, remaining) = takeUntil(remainingElements, breakPoint)
loop(
remainingElements = remaining,
remainingBreakPoints,
group :: acc
)
case Nil =>
(remainingElements :: acc).reverse
}
loop(
remainingElements = data.sorted,
remainingBreakPoints = breakPoints.sorted,
acc = List.empty
)
}
You can use it like this:
group(data = ('a' to 'z').toList, breakPoints = List('c', 'f', 'j'))
//res: List[List[Char]] = List(
// List('a', 'b'),
// List('c', 'd', 'e'),
// List('f', 'g', 'h', 'i'),
// List('j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z')
// )
This function will generate always a list of length = length(breakPoints) + 1.
If there are no more elements, it will generate empty lists.
(you can edit the code for your concrete requirements)

Answer 3

You can try a bit different approach:
def grouper(strings: Seq[String], breaks: Seq[String]): Seq[Seq[String]] = {
var i = 0
(for(x <- strings) yield {if (breaks.contains(x)) {i=i+1}; (x,i)})
.groupBy(_._2).map(_._2.map(_._1)).toList
}
grouper(ls,breakpoints).foreach(println(_))
Vector(f, g, h, i)
Vector(c, d, e)
Vector(j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)
Vector(a, b)