[SCALA] 스칼라 방법은 다른의 각 요소와 함께 반복자의 각 요소를 결합?

스칼라 방법은 다른의 각 요소와 함께 반복자의 각 요소를 결합?

나는이있는 경우 :

val a = Array("a ","b ","c ")
val b = Array("x","y")

나는 그런 방법이 날이 첫 컬렉션을 통과 할 것이다 존재하는지 알고, 그리고 그것의 각 요소에 대해, 전체 두 번째 컬렉션을 걸을 것이다. 우리는 어레이 A를 수행하는 경우 예를 들어, 우리는, X, A, Y, B, X, B, Y, C, X, C, Y을 가질 것이다. 나는 우편으로 알고 있지만 내가 본 것을에서는 같은 크기의 컬렉션에서 작동하고 동일한 위치에서 요소를 연결합니다.

해결법

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

   1.난 안 확실히 "방법"의 해요, 그러나 이것은 단지 중첩 / 화합물로 표현 될 수있다 :

   난 안 확실히 "방법"의 해요, 그러나 이것은 단지 중첩 / 화합물로 표현 될 수있다 :

   val a = Array("a ","b ","c ")
   val b = Array("x","y")
   for (a_ <- a; b_ <- b) yield (a_, b_)
   
   res0: Array[(java.lang.String, java.lang.String)] = Array((a ,x), (a ,y), (b ,x), (b ,y), (c ,x), (c ,y))
   

   해피 코딩.

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

   2.다른 길이의, 그리고 아마도 다른 유형의 목록의 알 수없는 숫자의 목록은이를 사용할 수 있습니다 :

   다른 길이의, 그리고 아마도 다른 유형의 목록의 알 수없는 숫자의 목록은이를 사용할 수 있습니다 :

   def xproduct (xx: List [List[_]]) : List [List[_]] = 
     xx match {
       case aa :: bb :: Nil => 
         aa.map (a => bb.map (b => List (a, b))).flatten       
       case aa :: bb :: cc => 
         xproduct (bb :: cc).map (li => aa.map (a => a :: li)).flatten
       case _ => xx
   }
   

   당신은 그것을 부를 것이다

   xproduct List (List ("a ", "b ", "c "), List ("x", "y"))
   

   하지만 너무 다른 종류의 목록으로 호출 할 수 있습니다 :

   scala>  xproduct (List (List ("Beatles", "Stones"), List (8, 9, 10), List ('$', '€')))  
   res146: List[List[_]] = List(List(Beatles, 8, $), List(Stones, 8, $), List(Beatles, 8, €), List(Stones, 8, €), List(Beatles, 9, $), List(Stones, 9, $), List(Beatles, 9, €), List(Stones, 9, €), List(Beatles, 10, $), List(Stones, 10, $), List(Beatles, 10, €), List(Stones, 10, €))
   

   배열은 목록에 변환 할 수 있고, 당신이 목록을 사용할 수없는 경우 결과는 배열로 다시 변환.

   게으른 컬렉션 향해 중에서, I (0에서 조합 - 사이즈 - 1)의 인덱스로부터 기능적 맵핑을 만들어 결과적으로 그 위치를 쉽게 조금 농도가 필요하고, 모듈러스 나눗셈 계산 :

   def combicount (xx: List [List[_]]): Int = (1 /: xx) (_ * _.length)
   
   def combination (xx: List [List[_]], i: Int): List[_] = xx match {
       case Nil => Nil
       case x :: xs => x(i % x.length) :: combination (xs, i / x.length)
   }
   
   def xproduct (xx: List [List[_]]): List [List[_]] = 
     (0 until combicount (xx)).toList.map (i => combination (xx, i))
   

   그것은 긴 대신에, 또는에서 BigInt를 사용하는 아무 문제 없습니다.

   class Cartesian (val ll: List[List[_]]) extends Iterator [List[_]] {
   
     def combicount (): Int = (1 /: ll) (_ * _.length)
   
     val last = combicount - 1 
     var iter = 0
   
     override def hasNext (): Boolean = iter < last
     override def next (): List[_] = {
       val res = combination (ll, iter)
       iter += 1
       res
     }
   
     def combination (xx: List [List[_]], i: Int): List[_] = xx match {
         case Nil => Nil
         case x :: xs => x (i % x.length) :: combination (xs, i / x.length) 
     }
   }
   

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

   3.나는 내 코드에서 광범위하게 다음을 사용하고 있습니다. 이 목록의 임의의 수를 위해 노력하고 있습니다. 당신이 메모리에 잠재적으로 엄청난 결과를 저장하지 않아도 그것은 모음 대신 Iterator를 만드는 것입니다.

   나는 내 코드에서 광범위하게 다음을 사용하고 있습니다. 이 목록의 임의의 수를 위해 노력하고 있습니다. 당신이 메모리에 잠재적으로 엄청난 결과를 저장하지 않아도 그것은 모음 대신 Iterator를 만드는 것입니다.

   모든 개선은 매우 환영합니다.

   /**
     * An iterator, that traverses every combination of objects in a List of Lists.
     * The first Iterable will be incremented fastest. So consider the head as 
     * the "least significant" bit when counting.*/
   
   class CombinationIterator[A](val components: List[Iterable[A]]) extends Iterator[List[A]]{
     private var state: List[BufferedIterator[A]] = components.map(_.iterator.buffered)
     private var depleted = state.exists(_.isEmpty)
   
     override def next(): List[A] = {
       //this function assumes, that every iterator is non-empty    
       def advance(s: List[(BufferedIterator[A],Iterable[A])]): List[(BufferedIterator[A],A)] = {
         if( s.isEmpty ){
           depleted = true
           Nil
         }
         else {
           assert(!s.head._1.isEmpty)
   
           //advance and return identity
           val it = s.head._1
           val next = it.next()
           if( it.hasNext){
             //we have simply incremented the head, so copy the rest
             (it,next) :: s.tail.map(t => (t._1,t._1.head))
           } else {
             //we have depleted the head iterator, reset it and increment the rest
             (s.head._2.iterator.buffered,next) :: advance(s.tail)
           }
         }
       }
       //zipping the iterables to the iterators is needed for resseting them
       val (newState, result) = advance(state.zip(components)).unzip
   
       //update state
       state = newState    
   
       result
     }
   
     override def hasNext = !depleted
   }
   

   이 하나를 사용 그래서, 당신은 모든 조합을 통과 반복자를 얻기 위해 새로운 CombinationIterator (목록 (A, B))를 작성해야합니다.

   다음 버전이 최적이 아닌 것을 참고 (성능 현명한) :

   .

   scala> def combination(xx: List[List[_]], i: Int): List[_] = xx match {
        | case Nil => Nil
        | case x :: xs => x(i % x.length) :: combination(xs, i/x.length)
        | }
   combination: (xx: List[List[_]], i: Int)List[_]
   
   scala> def combinationIterator(ll: List[List[_]]): Iterator[List[_]] = {
        | Iterator.from(0).takeWhile(n => n < ll.map(_.length).product).map(combination(ll,_))
        | }
   combinationIterator: (ll: List[List[_]])Iterator[List[_]]
   
   scala> List(List(1,2,3),List("a","b"),List(0.1,0.2,0.3))
   res0: List[List[Any]] = List(List(1, 2, 3), List(a, b), List(0.1, 0.2, 0.3))
   
   scala> combinationIterator(res0)
   res1: Iterator[List[_]] = non-empty iterator
   
   scala> res1.mkString("\n")
   res2: String = 
   List(1, a, 0.1)
   List(2, a, 0.1)
   List(3, a, 0.1)
   List(1, b, 0.1)
   List(2, b, 0.1)
   List(3, b, 0.1)
   List(1, a, 0.2)
   List(2, a, 0.2)
   List(3, a, 0.2)
   List(1, b, 0.2)
   List(2, b, 0.2)
   List(3, b, 0.2)
   List(1, a, 0.3)
   List(2, a, 0.3)
   List(3, a, 0.3)
   List(1, b, 0.3)
   List(2, b, 0.3)
   List(3, b, 0.3)
   

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

   4.더 높은 kinded 유형 및 카테고리 이론의 당신의 깊은 지식을 과시하려는 경우, 당신은 쓸 수 있습니다 :

   더 높은 kinded 유형 및 카테고리 이론의 당신의 깊은 지식을 과시하려는 경우, 당신은 쓸 수 있습니다 :

   trait Applicative[App[_]] {
     def pure[A](a: A): App[A]
     def fmap[A,B](f: A => B, appA: App[A]): App[B]
     def star[A,B](appF: App[A => B], appA: App[A]): App[B]
   }
   
   object ListApplicative extends Applicative[List] {
     override def pure[A](a: A): List[A] = List(a)
     override def fmap[A,B](f: A => B, listA: List[A]): List[B] = listA.map(f)
     override def star[A,B](listF: List[A => B], listA: List[A]):List[B] = 
       for(f <- listF; a <- listA) yield f(a)
   }
   
   import ListApplicative._
   
   def pairs[A,B](listA: List[A], listB: List[B]) = 
     star(fmap((a:A) => ((b:B) => (a,b)), listA), listB)
   

   내가 태평양 표준시의 솔루션을 선호하는 것 이외에 ...

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

   5.여기 ziggystar의 마지막 편집 @ 같은 일을하지만,리스트의 인덱스 액세스를 사용하지 않는 이상 하나입니다.

   여기 ziggystar의 마지막 편집 @ 같은 일을하지만,리스트의 인덱스 액세스를 사용하지 않는 이상 하나입니다.

   def combinationIterator[A](xs: Iterable[Iterable[A]]): Iterator[List[A]] = {
     xs.foldRight(Iterator(List[A]())) { (heads, tails) =>
       tails.flatMap { tail =>
         heads.map(head => head :: tail)
       }
     }
   }
   

   그리고 설탕 버전 :

   def combinationIterator[A](xs: Iterable[Iterable[A]]): Iterator[List[A]] = {
     (xs :\ Iterator(List[A]())) { (heads, tails) =>
       for (tail <- tails; head <- heads) yield head :: tail
     }
   }
   

from https://stackoverflow.com/questions/5955797/scala-method-to-combine-each-element-of-an-iterable-with-each-element-of-another by cc-by-sa and MIT license