복붙노트

[SCALA] 나는 두 개 이상의 목록 스칼라에서 함께 압축 할 수 있습니까?

SCALA

나는 두 개 이상의 목록 스칼라에서 함께 압축 할 수 있습니까?

다음 스칼라 목록을 감안할 때 :

val l = List(List("a1", "b1", "c1"), List("a2", "b2", "c2"), List("a3", "b3", "c3"))

어떻게 얻을 수 있습니다 :

List(("a1", "a2", "a3"), ("b1", "b2", "b3"), ("c1", "c2", "c3"))

지퍼가 두 목록을 결합 할 수 있기 때문에, 나는 당신이 / 반복 할 필요가 어떻게 든 주요 목록을 줄일 생각합니다. 아니나 다를까, 다음은 작동하지 않습니다

scala> l reduceLeft ((a, b) => a zip b)
<console>:6: error: type mismatch;
 found   : List[(String, String)]
 required: List[String]
       l reduceLeft ((a, b) => a zip b)

어떤 제안 일이 어떻게 할까? 나는 내가 할 수있는 매우 간단한 방법을 누락 생각합니다.

업데이트 : M 요소와 각각 N 목록의 목록을 가지고 M TupleNs의 목록을 만들 수있는 솔루션을 찾고 있어요.

업데이트 2 : 그것이 나오는 것에 따라 내가 호박의 반응을 수용하고 있으므로,리스트의 목록이 아니라 튜플의 목록을 가지고 더 나은 내 특정 유스 케이스입니다. 네이티브 방식을 사용하기 때문에 그것은 또한 간단합니다.

해결법

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

    1.나는 임의의 크기의 튜플의 목록을 생성하는 것이 가능하다 생각하지 않지만, 전치 기능을 대신 목록의 목록을 점점 마음을하지 않는 경우 정확하게 당신이 필요로한다.

    나는 임의의 크기의 튜플의 목록을 생성하는 것이 가능하다 생각하지 않지만, 전치 기능을 대신 목록의 목록을 점점 마음을하지 않는 경우 정확하게 당신이 필요로한다.

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

    2.

    scala> (List(1,2,3),List(4,5,6),List(7,8,9)).zipped.toList
    res0: List[(Int, Int, Int)] = List((1,4,7), (2,5,8), (3,6,9))
    

    미래를 참조하십시오.

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

    3.이 코드 조각은 영업 이익의 요구에 응답하지 않습니다 그래서, 이것은 4 살짜리 스레드이지만 제목의 질문에 대답하지, 아마 누군가가 심지어 유용하게 사용할 수뿐만 아니라 때문이다.

    이 코드 조각은 영업 이익의 요구에 응답하지 않습니다 그래서, 이것은 4 살짜리 스레드이지만 제목의 질문에 대답하지, 아마 누군가가 심지어 유용하게 사용할 수뿐만 아니라 때문이다.

    3 명 컬렉션을 압축하려면 :

    as zip bs zip cs map { 
      case ((a,b), c) => (a,b,c)
    }
    
  4. ==============================

    4.예, zip3와.

    예, zip3와.

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

    5.전치 트릭을 수행합니다. 가능한 알고리즘은 다음과 같습니다

    전치 트릭을 수행합니다. 가능한 알고리즘은 다음과 같습니다

    def combineLists[A](ss:List[A]*) = {
        val sa = ss.reverse;
        (sa.head.map(List(_)) /: sa.tail)(_.zip(_).map(p=>p._2 :: p._1))
    }
    

    예를 들면 :

    combineLists(List(1, 2, 3), List(10,20), List(100, 200, 300))
    // => List[List[Int]] = List(List(1, 10, 100), List(2, 20, 200))
    

    그 대답은 입력에 짧은리스트의 사이즈로 절단된다.

    combineLists(List(1, 2, 3), List(10,20))
    // => List[List[Int]] = List(List(1, 10), List(2, 20))
    
  6. ==============================

    6.그들은, 제품 특성에서 모든 상속을 할 때 실제로 데이터 값을 사용하는 모든 다른 클래스 등의 다른 튜플 크기의 스칼라 취급 (Tuple1, Tuple2, Tuple3, Tuple4는, ..., Tuple22) 특성은 충분한 정보를 전달하지 않습니다 튜플의 다른 크기에서 그들은 모두 같은 함수에 의해 반환 될 수 있다면. (그리고 스칼라의 제네릭 중 하나이 사건을 처리 할 수있을만큼 강력하지 있습니다.)

    그들은, 제품 특성에서 모든 상속을 할 때 실제로 데이터 값을 사용하는 모든 다른 클래스 등의 다른 튜플 크기의 스칼라 취급 (Tuple1, Tuple2, Tuple3, Tuple4는, ..., Tuple22) 특성은 충분한 정보를 전달하지 않습니다 튜플의 다른 크기에서 그들은 모두 같은 함수에 의해 반환 될 수 있다면. (그리고 스칼라의 제네릭 중 하나이 사건을 처리 할 수있을만큼 강력하지 있습니다.)

    가장 좋은 방법은 모든 22 개 튜플 크기에 대한 압축 기능의 쓰기 과부하이다. 코드 생성기는 아마 당신을 도울 것입니다.

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

    7.당신은 실용적 scalaz / 고양이 /를 (_, _) 구문은 중첩와 조금 어색하지만 경로 (여기 당신의 마음에 드는 기능 lib 디렉토리 삽입), 패턴 매칭,가는 방법, 그래서하자를 가고 싶어하지 않는 경우 변경 :

    당신은 실용적 scalaz / 고양이 /를 (_, _) 구문은 중첩와 조금 어색하지만 경로 (여기 당신의 마음에 드는 기능 lib 디렉토리 삽입), 패턴 매칭,가는 방법, 그래서하자를 가고 싶어하지 않는 경우 변경 :

    import scala.{Tuple2 => &}
    
    for (i1 & i2 & i3 & i4 <- list1 zip list2 zip list3 zip list4) yield (i1, i2, i3, i4)
    

    & 여기에 임의의 선택을해야 좋은 중위 보이는 것도있다. 당신은 가능성이 있지만, 코드 검토 중에 몇 눈썹을 얻을 것이다.

    또한 아무것도 작품은 당신이 (예를 들어, 선물)을 압축 할 수 있어야

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

    8.그게 반복하지 않고 가능하다고 생각하지 않습니다. 하나의 단순한 이유 : 당신은 당신이 요구하는 함수의 반환 유형을 정의 할 수 없습니다.

    그게 반복하지 않고 가능하다고 생각하지 않습니다. 하나의 단순한 이유 : 당신은 당신이 요구하는 함수의 반환 유형을 정의 할 수 없습니다.

    예를 들어, 경우 입력 목록 (목록 (1,2), 목록 (3,4)) 한 후 반환 형식은 목록 [Tuple2 [지능]]이 될 것입니다. 이 세 가지 요소를 가지고 있다면, 반환 형식 등등 목록 [Tuple3 [지능]] 등이 될 것입니다.

    당신은 [AnyRef] 목록을 반환하거나 목록 [제품], 다음의 경우 무리, 각 조건에 대해 하나를 만들 수 있습니다.

    일반 목록 전위에 관해서는,이 작품 :

    def transpose[T](l: List[List[T]]): List[List[T]] = l match {
      case Nil => Nil
      case Nil :: _ => Nil
      case _ => (l map (_.head)) :: transpose(l map (_.tail))
    }
    
  9. ==============================

    9.제품 컬렉션은 인수에 대응 (22)까지 aflatZip 작업이 있습니다.

    제품 컬렉션은 인수에 대응 (22)까지 aflatZip 작업이 있습니다.

    scala> List(1,2,3) flatZip Seq("a","b","c") flatZip Vector(1.0,2.0,3.0) flatZip Seq(9,8,7)
    res1: com.github.marklister.collections.immutable.CollSeq4[Int,String,Double,Int] = 
    CollSeq((1,a,1.0,9),
            (2,b,2.0,8),
            (3,c,3.0,7))
    
  10. ==============================

    10.Scalaz로 :

    Scalaz로 :

    import scalaz.Zip
    import scalaz.std.list._
    
    // Zip 3
    Zip[List].ap.tuple3(List("a1", "b1"),
                        List("a2", "b2"),
                        List("a3", "b3"))
    
    // Zip 4
    Zip[List].ap.tuple4(List("a1", "b1"),
                        List("a2", "b2"),
                        List("a3", "b3"),
                        List("a4", "b4"))
    
    // Zip 5
    Zip[List].ap.tuple5(List("a1", "b1"),
                        List("a2", "b2"),
                        List("a3", "b3"),
                        List("a4", "b4"),
                        List("a5", "b5"))
    

    더 5 이상의 경우 :

    // Zip 6
    Zip[List].ap.apply6(List("a1", "b1"),
                        List("a2", "b2"),
                        List("a3", "b3"),
                        List("a4", "b4"),
                        List("a5", "b5"),
                        List("a6", "b6"))((_, _, _, _, _, _))
    
    // Zip 7
    Zip[List].ap.apply7(List("a1", "b1"),
                        List("a2", "b2"),
                        List("a3", "b3"),
                        List("a4", "b4"),
                        List("a5", "b5"),
                        List("a6", "b6"),
                        List("a7", "b7"))((_, _, _, _, _, _, _))
    
    ...
    
    // Zip 12
    Zip[List].ap.apply12(List("a1", "b1"),
                         List("a2", "b2"),
                         List("a3", "b3"),
                         List("a4", "b4"),
                         List("a5", "b5"),
                         List("a6", "b6"),
                         List("a7", "b7"),
                         List("a8", "b8"),
                         List("a9", "b9"),
                         List("a10", "b10"),
                         List("a11", "b11"),
                         List("a12", "b12"))((_, _, _, _, _, _, _, _, _, _, _, _))
    
  11. from https://stackoverflow.com/questions/1664439/can-i-zip-more-than-two-lists-together-in-scala by cc-by-sa and MIT license