Daha hızlı geçirgenlik oluşturucu

Question

Belirli bir listenin tüm permütasyonlarını üreten Scala listeleri için bir permütasyon jeneratörü yazdım. Şimdiye kadar, ben this Haskell implementation dayanarak aşağıdaki var (ve ben denedim diğer seçenekler daha verimli olduğunu düşünüyorum). Bunu daha da verimli hale getirmek için herhangi bir yol var mı yoksa tüm üslerimi mi kapsıyorum? 2.9 extempore skala koleksiyon sınıfı bazı faydalı yöntemler ekledik Scala

/** For each element x in List xss, returns (x, xss - x) */ 
    def selections[A](xss:List[A]):List[(A,List[A])] = xss match { 
     case Nil => Nil 
     case x :: xs => 
     (x, xs) :: (for((y, ys) <- selections (xs)) 
      yield (y, x :: ys)) 
    } 

    /** Returns a list containing all permutations of the input list */ 
    def permute[A](xs:List[A]):List[List[A]] = xs match { 
     case Nil => List(Nil) 

     //special case lists of length 1 and 2 for better performance 
     case t :: Nil => List(xs) 
     case t :: u :: Nil => List(xs,List(u,t)) 

     case _ => 
     for ((y,ys) <- selections(xs); ps <- permute(ys)) 
      yield y :: ps 
    } 

Answer 1

bu seq tüm permütasyonlarını üreten bir Seq.permutations bulunmaktadır. Bakınız link text. Ve daha iyi bir performansa sahip olacağını düşündüğüm, özyinelemeyen bir uygulama var. Bkz. A non-recursive implementation of SeqLike.permutations