[SCALA] 스칼라의 크로스 제품

스칼라의 크로스 제품

나는 스칼라에 traversables로 작동하는 이항 연산자 크로스 (교차 제품 / 직교 제품)를 갖고 싶어 :

val x = Seq(1, 2)
val y = List('hello', 'world', 'bye')
val z = x cross y    # i can chain as many traversables e.g. x cross y cross w etc

assert z == ((1, 'hello'), (1, 'world'), (1, 'bye'), (2, 'hello'), (2, 'world'), (2, 'bye'))

스칼라에서이 작업을 수행하는 가장 좋은 방법에만 (즉 scalaz 같은 것을 사용하지 않는) 란 무엇입니까?

해결법

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

   1.당신은 암시 클래스와 스칼라 2.10에 대한-이해 꽤 노골적으로이 작업을 수행 할 수 있습니다

   당신은 암시 클래스와 스칼라 2.10에 대한-이해 꽤 노골적으로이 작업을 수행 할 수 있습니다

   implicit class Crossable[X](xs: Traversable[X]) {
     def cross[Y](ys: Traversable[Y]) = for { x <- xs; y <- ys } yield (x, y)
   }
   
   val xs = Seq(1, 2)
   val ys = List("hello", "world", "bye")
   

   그리고 지금:

   scala> xs cross ys
   res0: Traversable[(Int, String)] = List((1,hello), (1,world), ...
   

   이 수 전 2.10 - 그냥 아주 간결로, 당신은 클래스와 암시 적 변환 방법을 모두 정의해야 할 것 때문이다.

   당신은 또한이 쓸 수 있습니다 :

   scala> xs cross ys cross List('a, 'b)
   res2: Traversable[((Int, String), Symbol)] = List(((1,hello),'a), ...
   

   당신은 XS를 원하는 경우에 교차 YS는 Tuple3를 반환하는 ZS를 건너, 그러나, 당신은 상용구를 많이 또는 무형의 같은 라이브러리 중 하나가 필요합니다.

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

   2.크로스 x_list 및 y_list과 :

   크로스 x_list 및 y_list과 :

   val cross = x_list.flatMap(x => y_list.map(y => (x, y)))
   

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

   3.여기서 목록의 임의의 수의 순환 외적의 구현이다 :

   여기서 목록의 임의의 수의 순환 외적의 구현이다 :

   def crossJoin[T](list: Traversable[Traversable[T]]): Traversable[Traversable[T]] =
     list match {
       case xs :: Nil => xs map (Traversable(_))
       case x :: xs => for {
         i <- x
         j <- crossJoin(xs)
       } yield Traversable(i) ++ j
     }
   
   crossJoin(
     List(
       List(3, "b"),
       List(1, 8),
       List(0, "f", 4.3)
     )
   )
   
   res0: Traversable[Traversable[Any]] = List(List(3, 1, 0), List(3, 1, f), List(3, 1, 4.3), List(3, 8, 0), List(3, 8, f), List(3, 8, 4.3), List(b, 1, 0), List(b, 1, f), List(b, 1, 4.3), List(b, 8, 0), List(b, 8, f), List(b, 8, 4.3))
   

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

   4.

   class CartesianProduct(product: Traversable[Traversable[_ <: Any]]) {
     override def toString(): String = {
       product.toString
     }
   
     def *(rhs: Traversable[_ <: Any]): CartesianProduct = {
         val p = product.flatMap { lhs =>
           rhs.map { r =>
             lhs.toList :+ r
           }
         }
   
         new CartesianProduct(p)
     }
   }
   
   object CartesianProduct {
     def apply(traversable: Traversable[_ <: Any]): CartesianProduct = {
       new CartesianProduct(
         traversable.map { t =>
           Traversable(t)
         }
       )
     }
   }
   
   // TODO: How can this conversion be made implicit?
   val x = CartesianProduct(Set(0, 1))
   val y = List("Alice", "Bob")
   val z = Array(Math.E, Math.PI)
   
   println(x * y * z) // Set(List(0, Alice, 3.141592653589793), List(0, Alice, 2.718281828459045), List(0, Bob, 3.141592653589793), List(1, Alice, 2.718281828459045), List(0, Bob, 2.718281828459045), List(1, Bob, 3.141592653589793), List(1, Alice, 3.141592653589793), List(1, Bob, 2.718281828459045))
   
   // TODO: How can this conversion be made implicit?
   val s0 = CartesianProduct(Seq(0, 0))
   val s1 = Seq(0, 0)
   
   println(s0 * s1) // List(List(0, 0), List(0, 0), List(0, 0), List(0, 0))
   

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

   5.여기 밀라 드의 반응과 비슷한, 그러나 비 재귀입니다.

   여기 밀라 드의 반응과 비슷한, 그러나 비 재귀입니다.

   def cartesianProduct[T](seqs: Seq[Seq[T]]): Seq[Seq[T]] = {
     seqs.foldLeft(Seq(Seq.empty[T]))((b, a) => b.flatMap(i => a.map(j => i ++ Seq(j))))
   }
   

   이 블로그 게시물을 기반으로.

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

   6.다른 답변, 그냥 내 방식과 유사.

   다른 답변, 그냥 내 방식과 유사.

   def loop(lst: List[List[Int]],acc:List[Int]): List[List[Int]] = {
     lst match {
       case head :: Nil => head.map(_ :: acc)
       case head :: tail => head.flatMap(x => loop(tail,x :: acc))
       case Nil => ???
     }
   }
   val l1 = List(10,20,30,40)
   val l2 = List(2,4,6)
   val l3 = List(3,5,7,9,11)
   
   val lst = List(l1,l2,l3)
   
   loop(lst,List.empty[Int])
   

from https://stackoverflow.com/questions/14740199/cross-product-in-scala by cc-by-sa and MIT license