[SCALA] 연속 동일한 요소를 그룹화하는 스칼라 목록 기능

연속 동일한 요소를 그룹화하는 스칼라 목록 기능

예컨대 감안할 때 :

List(5, 2, 3, 3, 3, 5, 5, 3, 3, 2, 2, 2)

나는에 도착하고 싶습니다 :

List(List(5), List(2), List(3, 3, 3), List(5, 5), List(3, 3), List(2, 2, 2))

나는이 작업을 수행하는 간단한 목록 기능이 있다고 가정하지만, 그것을 찾을 수없는 나는 것입니다.

해결법

1. ==============================

   1.이것은 내가 일반적으로 사용하는 트릭입니다 :

   이것은 내가 일반적으로 사용하는 트릭입니다 :

   def split[T](list: List[T]) : List[List[T]] = list match {
     case Nil => Nil
     case h::t => val segment = list takeWhile {h ==}
       segment :: split(list drop segment.length)
   }
   

   사실 ... 그것은 꼬리 재귀 수집 유형 및 최적화를 통해 나는 보통 추상, 아니다뿐만 아니라,하지만 대답은 간단을 유지하고 싶었다.

2. ==============================

   2.

   val xs = List(5, 2, 3, 3, 3, 5, 5, 3, 3, 2, 2, 2)
   

   여기에 또 다른 방법입니다.

   (List(xs.take(1)) /: xs.tail)((l,r) =>
     if (l.head.head==r) (r :: l.head) :: l.tail else List(r) :: l
   ).reverseMap(_.reverse)
   

3. ==============================

   3.내가 가고 싶어 답을 쓰기 위해, 렉스 커 젠장. 작은 문체의 차이가 있기 때문에, 여기에 내 걸릴입니다 :

   내가 가고 싶어 답을 쓰기 위해, 렉스 커 젠장. 작은 문체의 차이가 있기 때문에, 여기에 내 걸릴입니다 :

   list.tail.foldLeft(List(list take 1)) { 
       case (acc @ (lst @ hd :: _) :: tl, el) => 
           if (el == hd) (el :: lst) :: tl 
           else (el :: Nil) :: acc 
   }
   

   요소가 동일하기 때문에, 나는 하위 목록을 반전 귀찮게하지 않았다.

4. ==============================

   4.

   list.foldRight(List[List[Int]]()){
     (e, l) => l match {
       case (`e` :: xs) :: fs => (e :: e :: xs) :: fs
       case _ => List(e) :: l
     }
   }
   

   또는

   list.zip(false :: list.sliding(2).collect{case List(a,b) => a == b}.toList)
    .foldLeft(List[List[Int]]())((l,e) => if(e._2) (e._1 :: l.head) :: l.tail 
                                          else List(e._1) :: l ).reverse
   

   [편집하다]

   //find the hidden way 
   //the beauty must be somewhere
   //when we talk scala
   
   def split(l: List[Int]): List[List[Int]] = 
     l.headOption.map{x => val (h,t)=l.span{x==}; h::split(t)}.getOrElse(Nil)
   

5. ==============================

   5.나는이 구현은 컬렉션 방법에 작동 주위에 거짓말이있다. 결국 나는 inits와 꼬리의 간단한 구현에 확인하고 클러스터를 떠났다. 모든 새로운 메소드는 외부에서 볼 어려운 큰 세금을 수집하기까지 얼마나 간단한 지 끝을 중요하지 않습니다. 그러나 여기 내가 사용하지 않은 구현입니다.

   나는이 구현은 컬렉션 방법에 작동 주위에 거짓말이있다. 결국 나는 inits와 꼬리의 간단한 구현에 확인하고 클러스터를 떠났다. 모든 새로운 메소드는 외부에서 볼 어려운 큰 세금을 수집하기까지 얼마나 간단한 지 끝을 중요하지 않습니다. 그러나 여기 내가 사용하지 않은 구현입니다.

   import generic._
   import scala.reflect.ClassManifest
   import mutable.ListBuffer
   import annotation.tailrec
   import annotation.unchecked.{ uncheckedVariance => uV }
   
   def inits: List[Repr] = repSequence(x => (x, x.init), Nil)
   def tails: List[Repr] = repSequence(x => (x, x.tail), Nil)
   def cluster[A1 >: A : Equiv]: List[Repr] =
     repSequence(x => x.span(y => implicitly[Equiv[A1]].equiv(y, x.head)))
   
   private def repSequence(
     f: Traversable[A @uV] => (Traversable[A @uV], Traversable[A @uV]),
     extras: Traversable[A @uV]*): List[Repr] = {
   
     def mkRepr(xs: Traversable[A @uV]): Repr = newBuilder ++= xs result
     val bb = new ListBuffer[Repr]
   
     @tailrec def loop(xs: Repr): List[Repr] = {
       val seq = toCollection(xs)
       if (seq.isEmpty)
         return (bb ++= (extras map mkRepr)).result
   
       val (hd, tl) = f(seq)
       bb += mkRepr(hd)
       loop(mkRepr(tl))
     }
   
     loop(self.repr)
   }
   

   [편집 : 나는 다른 사람들이 내부를 알 수 없습니다 잊어 버려. 이 상자 밖으로 실행되지 않을 것이다, 그래서이 코드는, TraversableLike의 내부에서 작성된 것입니다.]

6. ==============================

   6.여기 @Kevin 라이트와 @Landei에서 영감 꼬리 재귀 솔루션입니다 :

   여기 @Kevin 라이트와 @Landei에서 영감 꼬리 재귀 솔루션입니다 :

   @tailrec
   def sliceEqual[A](s: Seq[A], acc: Seq[Seq[A]] = Seq()): Seq[Seq[A]] = {
     s match {
       case fst :: rest =>
         val (l, r) = s.span(fst==)
         sliceEqual(r, acc :+ l)
       case Nil => acc
     }
   }
   

7. ==============================

   7.여기에 약간 클리너 하나입니다 :

   여기에 약간 클리너 하나입니다 :

   def groupConsequtive[A](list: List[A]): List[List[A]] = list match {
     case head :: tail =>
       val (t1, t2) = tail.span(_ == head)
       (head :: t1) :: groupConsequtive(t2)
     case _ => Nil  
   }
   

   꼬리 재귀 버전

   @tailrec
   def groupConsequtive[A](list: List[A], acc: List[List[A]] = Nil): List[List[A]] = list match {
     case head :: tail =>
       val (t1, t2) = tail.span(_ == head)
       groupConsequtive(t2, acc :+ (head :: t1))
     case _ => acc
   }
   

8. ==============================

   8.이 간단 할 수있다 :

   이 간단 할 수있다 :

   val input = List(5, 2, 3, 3, 3, 5, 5, 3, 3, 2, 2, 2)
   input groupBy identity values
   

from https://stackoverflow.com/questions/4761386/scala-list-function-for-grouping-consecutive-identical-elements by cc-by-sa and MIT license