[SCALA] 두 목록의 직교 제품

두 목록의 직교 제품

숫자가 여러 문자에 연결된지도 감안할 때

scala> val conversion = Map("0" -> List("A", "B"), "1" -> List("C", "D"))
conversion: scala.collection.immutable.Map[java.lang.String,List[java.lang.String]] =
  Map(0 -> List(A, B), 1 -> List(C, D))

나는 숫자의 순서에 따라 모든 가능한 문자 시퀀스를 생성합니다. 예를 들면 :

"00" -> List("AA", "AB", "BA", "BB")
"01" -> List("AC", "AD", "BC", "BD")

나는 함축을 위해이 작업을 수행 할 수 있습니다

scala> val number = "011"
number: java.lang.String = 011

인덱스 당 가능한 일련의 문자 만들기

scala> val values = number map { case c => conversion(c.toString) }
values: scala.collection.immutable.IndexedSeq[List[java.lang.String]] =
  Vector(List(A, B), List(C, D), List(C, D))

가능한 모든 문자 시퀀스를 생성

scala> for {
     | a <- values(0)
     | b <- values(1)
     | c <- values(2)
     | } yield a+b+c
res13: List[java.lang.String] = List(ACC, ACD, ADC, ADD, BCC, BCD, BDC, BDD)

여기 가지 추한 및 만 세 자리 숫자의 시퀀스 작동합니다. 어떤 시퀀스 길이에 대한 동일한 결과를 얻을 수있는 방법이 있습니까?

해결법

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

   1.다음 제안은를위한 이해를 사용하지 않습니다. 그러나 나는 당신이 눈치 당신이 당신의 직교 제품의 특정 길이로 묶여있을 것입니다 있기 때문에, 결국 좋은 아이디어라고 생각하지 않습니다.

   다음 제안은를위한 이해를 사용하지 않습니다. 그러나 나는 당신이 눈치 당신이 당신의 직교 제품의 특정 길이로 묶여있을 것입니다 있기 때문에, 결국 좋은 아이디어라고 생각하지 않습니다.

   scala> def cartesianProduct[T](xss: List[List[T]]): List[List[T]] = xss match {
        |   case Nil => List(Nil)
        |   case h :: t => for(xh <- h; xt <- cartesianProduct(t)) yield xh :: xt
        | }
   cartesianProduct: [T](xss: List[List[T]])List[List[T]]
   
   scala> val conversion = Map('0' -> List("A", "B"), '1' -> List("C", "D"))
   conversion: scala.collection.immutable.Map[Char,List[java.lang.String]] = Map(0 -> List(A, B), 1 -> List(C, D))
   
   scala> cartesianProduct("01".map(conversion).toList)
   res9: List[List[java.lang.String]] = List(List(A, C), List(A, D), List(B, C), List(B, D))
   

   참고 재귀 함수는 꼬리 재귀되지 않습니다 위. 당신이 XSS에서 단일 목록을 많이하지 않는 한 XSS 짧은 것으로 이것은 문제가되지 않습니다. 결과의 크기 XSS 아닌 단일 요소의 수가 기하 급수적으로 증가하기 때문에, 경우이다.

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

   2.나는이 함께 올 수 있습니다 :

   나는이 함께 올 수 있습니다 :

   val conversion = Map('0' -> Seq("A", "B"), '1' -> Seq("C", "D"))
   
   def permut(str: Seq[Char]): Seq[String] = str match {
     case Seq()  => Seq.empty
     case Seq(c) => conversion(c)
     case Seq(head, tail @ _*) =>
       val t = permut(tail)
       conversion(head).flatMap(pre => t.map(pre + _))
   }
   
   permut("011")
   

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

   3.난 그냥 다음과 같이 작동하는지했다

   난 그냥 다음과 같이 작동하는지했다

       def cross(a:IndexedSeq[Tree], b:IndexedSeq[Tree]) = {
           a.map (p => b.map( o => (p,o))).flatten
       }
   

   너무 임의의 컬렉션에 대한 작업을 처리하고있는 $ 트리 유형이 표시되지 않습니다 ..

from https://stackoverflow.com/questions/8217764/cartesian-product-of-two-lists by cc-by-sa and MIT license