Count consecutive characters in a list? - scala

Question

I want to create a scala method that counts the number of consecutive characters where the values are the same. So I have this list:
List('a','a','b')
and I want to return something like List(('a', 2), 'b', 1) - because there two characters with the same values beside each other. I've had a bash at this with little success:
def recursivelyCompressList(list: List[(Char, Int)], newString: List[(Char, Int)]): List[(Char, Int)] = {
list match {
case Nil => newString
case s :: tail => {
if (tail.nonEmpty && s._1 == tail.head._1) {
recursivelyCompressList(tail, newString :+ (s._1, s._2 + 1))
} else {
recursivelyCompressList(tail, newString :+ s)
}
}
case _ => newString
}
}
Grateful for any guidance.

Answer 1

This should work.
I would expect the code to be self-explaining, but if you have any question, do not doubt to ask.
def compressList[T](list: List[T]): List[(T, Int)] = {
#annotation.tailrec
def loop(remaining: List[T], currentValue: T, currentCount: Int, acc: List[(T, Int)]): List[(T, Int)] =
remaining match {
case Nil =>
((currentValue -> currentCount) :: acc).reverse
case t :: tail =>
if (t == currentValue)
loop(
remaining = tail,
currentValue,
currentCount + 1,
acc
)
else
loop(
remaining = tail,
currentValue = t,
currentCount = 1,
(currentValue -> currentCount) :: acc
)
}
list match {
case Nil =>
Nil
case t :: tail =>
loop(
remaining = tail,
currentValue = t,
currentCount = 1,
acc = List.empty
)
}
}
Which you can use like this:
compressList(List.empty[Char])
// res: List[(Char, Int)] = List()
compressList(List('a', 'b'))
// res: List[(Char, Int)] = List(('a', 1), ('b', 1))
compressList(List('a', 'a', 'b'))
// res: List[(Char, Int)] = List(('a', 2), ('b', 1))
compressList(List('a', 'a', 'b', 'b', 'b', 'a', 'c'))
// res: List[(Char, Int)] = List(('a', 2), ('b', 3), ('a', 1), ('c', 1))

Answer 2

can also use span instead of dropWhile and takeWhile to avoid double scan
def comp(xs:List[Char]):List[(Char,Int)] =
if(xs.isEmpty) Nil
else {
val h = xs.head
val (m,r) = xs.span(_ == h)
(h, m.length) :: comp(r)
}

Answer 3

Use takeWhile and dropWhile
Count consecutive
def count(xs: List[Char]): List[(Char, Int)] =
if (xs.isEmpty) Nil else
(xs.head, xs.takeWhile(_ == xs.head).length) :: count(xs.dropWhile(_ == xs.head))
Scala REPL
scala> def count(xs: List[Char]): List[(Char, Int)] =
| if (xs.isEmpty) Nil else
| (xs.head, xs.takeWhile(_ == xs.head).length) :: count(xs.dropWhile(_ == xs.head))
count: (xs: List[Char])List[(Char, Int)]
scala> count(List('a', 'a', 'b', 'c', 'c', 'c'))
res0: List[(Char, Int)] = List((a,2), (b,1), (c,3))
scala> count(List('a', 'a', 'b', 'a', 'c', 'c', 'c'))
res1: List[(Char, Int)] = List((a,2), (b,1), (a,1), (c,3))

Answer 4

You have not specified the behavior you want if there are multiple repeating sequences of the same character. Assuming you only want the longest repeating sequence, the following code would be a good starting point:
def rec(list : List[Char]) : Map[Char, Int] = {
#scala.annotation.tailrec
def helper(prev: Char, li : List[Char], len : Int, result : Map[Char, Int]) : Map[Char,Int] = {
if(li.isEmpty) {
if(!result.contains(prev)) result + (prev -> len)
else if(result(prev) < len) result + (prev -> len)
else result
}
else {
val cur = li.head
if(cur != prev) {
if(result.contains(prev)) {
if(result(prev) < len)
helper(li.head, li.tail, 1, result + (prev -> len))
else
helper(li.head, li.tail, 1, result)
} else {
helper(li.head, li.tail, 1, result + (prev -> len))
}
} else {
helper(li.head, li.tail, len + 1, result)
}
}
}
helper('\0', list, 0, Map.empty[Char, Int]) - '\0'
}
Running
rec(List('c', 'a', 'a', 'a', 'c', 'd' ,'c', 'c' , 'a', 'a', 'd', 'd', 'd', 'd','c','c','a', 'c','c','c'))
Output:
res0: Map[Char,Int] = Map(c -> 3, a -> 3, d -> 4)
The idea is just to look at the current character in the list and the previous character. When the character changes, the sequence count is stopped and current length is compared to what is stored in the map. It's pretty simple when you come to think about it.
I think this can be written more elegantly. But it could be a good starting point.