How to group a variable-length, repeating sequence in Scala

Question

I have a collection of ints that repeat themselves in a pattern:

val repeatingSequence = List(1,2,3,1,2,3,4,1,2,1,2,3,4,5)

I'd like to section that List up when the pattern repeats itself; in this case, when the sequence goes back to 1:

val groupedBySequence = List(List(1,2,3), List(1,2,3,4), List(1,2), List(1,2,3,4,5))

Notice that I'm grouping when the sequence jumps back to 1, but that the sequence can be of arbitrary length. My colleague and I have solved it by adding an additional method called 'groupWhen'

class IteratorW[A](itr: Iterator[A]) {
  def groupWhen(fn: A => Boolean): Iterator[Seq[A]] = {
    val bitr = itr.buffered
    new Iterator[Seq[A]] {
      override def hasNext = bitr.hasNext
      override def next = {
        val xs = collection.mutable.ListBuffer(bitr.next)
        while (bitr.hasNext && !fn(bitr.head)) xs += bitr.next
        xs.toSeq
      }
    }
  }
}
implicit def ToIteratorW[A](itr: Iterator[A]): IteratorW[A] = new IteratorW(itr)

> repeatingSequence.iterator.groupWhen(_ == 1).toSeq
List(List(1,2,3), List(1,2,3,4), List(1,2), List(1,2,3,4,5))

However, we both feel like there's a more elegant solution lurking in the collection library.

What should be the result of List(2).iterator.groupWhen(_ == 1)? — Thomas Jung, Jul 23 '11 at 14:15
Thomas Jung - I would think that should return an empty List. There is no group starting with 1 in that example so it should throw that away. — Matt Hughes, Jul 24 '11 at 02:05

score 9 · Accepted Answer · answered Jul 23 '11 at 14:46

9

Given an iterator itr, this will do the trick:

val head = iter.next()
val out = (
  Iterator continually {iter takeWhile (_ != head)}
  takeWhile {!_.isEmpty}
  map {head :: _.toList}
).toList

answered Jul 23 '11 at 14:46

Kevin Wright

49,540
9
105
155

Nice way to deal with takeWhile losing the head value (https://issues.scala-lang.org/browse/SI-3581). And if you drop the final toList, it works on an infinite iterator. – mpilquist Jul 23 '11 at 15:10
What if `iter.hasNext == false`? – huynhjl Jul 23 '11 at 16:09
huynhjl - indeed, you'd need an explicit check for that, I didn't want to distract from the core logic though :) – Kevin Wright Jul 23 '11 at 22:04

Kim Stebel · Answer 2 · 2011-07-23T14:34:28.997

2

As well all know, fold can do everything... ;)

  val rs = List(1,2,3,1,2,3,4,1,2,1,2,3,4,5)
  val res = (rs++List(1)).foldLeft((List[List[Int]](),List[Int]()))((acc,e) => acc match {
    case (res,subl) => {
      if (e == 1) ((subl.reverse)::res,1::Nil) else (res, e::subl)
    }
  })
  println(res._1.reverse.tail)

Please regard this as an entry for the obfuscated Scala contest rather than as a real answer.

edited Jul 23 '11 at 14:34

answered Jul 23 '11 at 14:28

Kim Stebel

41,826
12
125
142

score 2 · Answer 3 · answered Jul 23 '11 at 14:48

Here's a not-exactly-elegant solution I bashed out using span:

def groupWhen[A](fn: A => Boolean)(xs: List[A]): List[List[A]] = {
  xs.span(!fn(_)) match {
    case (Nil, Nil) => Nil
    case (Nil, z::zs) => groupWhen(fn)(zs) match {
      case ys::yss => (z::ys) :: yss
      case Nil => List(List(z))
    }
    case (ys, zs) => ys :: groupWhen(fn)(zs)
  }
}

scala> groupWhen[Int](_==1)(List(1,2,3,1,2,3,4,1,2,3,4,5))
res39: List[List[Int]] = List(List(1, 2, 3), List(1, 2, 3, 4), List(1, 2, 3, 4, 5))

scala> groupWhen[Int](_==1)(List(5,4,3,2,1,2,3,1,2,3,4,1,2,3,4,5))
res40: List[List[Int]] = List(List(5, 4, 3, 2), List(1, 2, 3), List(1, 2, 3, 4), List(1, 2, 3, 4, 5))

score 1 · Answer 4 · answered Jul 23 '11 at 15:39

import scala.collection.mutable.ListBuffer
import scala.collection.breakOut

val repeatingSequence = List(1,2,3,1,2,3,4,1,2,1,2,3,4,5)
val groupedBySequence: List[List[Int]] = repeatingSequence.foldLeft(ListBuffer[ListBuffer[Int]]()) {
  case (acc, 1) => acc += ListBuffer(1)
  case (acc, n) => acc.last += n; acc
}.map(_.toList)(breakOut)

How to group a variable-length, repeating sequence in Scala

4 Answers4

Linked