yếu tố Zip với chỉ số lẻ và thậm chí trong một danh sách

Question

Tôi muốn nén thậm chí và các yếu tố kỳ lạ trong một danh sách để thực hiện một danh sách các cặp, như vậy:

["A", "B", "C", "D", "E", "F"] -> [("A", "B"), ("C", "D"), ("E", "F")] 

biểu thức ngắn gọn nhất để làm điều này là gì thanh lịch theo cách chức năng?

Answer 1

Trong 2.8, bạn có thể muốn sử dụng phương pháp:

scala> val a = "ABCDEF".toList.map(_.toString) 
a: List[java.lang.String] = List(A, B, C, D, E, F) 

scala> a.grouped(2).partialMap{ case List(a,b) => (a,b) }.toList 
res0: List[(java.lang.String, java.lang.String)] = List((A,B), (C,D), (E,F)) 

(Đây là 2.8.0 Beta1; thân mới nhất có collect thay cho partialMap.)

Trong 2,7 - và không phải là một xấu Á hậu trong 2.8 - bạn có thể tạo ra một phương pháp đệ quy như legoscia đã làm:

def zipPairs[A](la : List[A]): List[(A,A)] = la match { 
    case a :: b :: rest => (a,b) :: zipPairs(rest) 
    case _ => Nil 
} 

scala> zipPairs(a) 
res1: List[(java.lang.String, java.lang.String)] = List((A,B), (C,D), (E,F)) 

Edit: đây là một cách tiếp cận ngắn hơn hoạt động trên 2,7 cũng:

scala> (a zip a.drop(1)).zipWithIndex.filter(_._2 % 2 == 0).map(_._1) 
res2: List[(java.lang.String, java.lang.String)] = List((A,B), (C,D), (E,F)) 

(Lưu ý việc sử dụng drop(1) thay vì tail để nó hoạt động với danh sách rỗng.)

Answer 2

chưa được kiểm tra:

def ziptwo(l: List[String]): List[(String, String)] = l match { 
    case Nil => Nil 
    case a :: b :: rest => 
     Pair(a,b) :: ziptwo(rest) 
} 

Answer 3

trong Scala 2.8 bạn có thể làm:

def pairs[T](xs: List[T]) = 
    xs.grouped(2) 
    .map{case List(a, b) => (a,b)} 
    .toList 

Answer 4

def pairify[T](list: List[T]): List[(T, T)] = list match { 
    case Nil => Nil 
    case x :: y :: xs => (x, y) :: pairify(xs) 
    case _ => error("odd length list!") 
} 

Answer 5

Ưu điểm duy nhất của h aving tất cả mọi người đến với những cách rõ ràng nhất để làm điều đó là tôi phải suy nghĩ nhiều hơn về các giải pháp thay thế. Vì vậy, đây là một trong đó hoạt động trên Scala 2,8. Trên Scala 2.7, thay thế view bằng projection.

def everyNofM[T](l: List[T], n: Int, m: Int) = 
    l.view.zipWithIndex.filter(_._2 % m == n).map(_._1) 
def evens[T](l: List[T]) = everyNofM(l, 0, 2) 
def odds[T](l: List[T]) = everyNofM(l, 1, 2) 
def zip[T](l: List[T]) = evens(l) zip odds(l) toList 

Nói đúng ra, view/projection là không cần thiết, nhưng nó tránh được sự sáng tạo không cần thiết của kết quả trung gian.

cách thú vị khác để làm việc đó:

def zip[T](l: List[T]) = l.indices.partition(_ % 2 == 0).zipped.map(
    (x: Int, y: Int) => (l(x), l(y)) 
).toList 

def zip[T](l: List[T]) = l.zipWithIndex.partition(_._2 % 2 == 0).zipped.map(
    (x, y) => (x._1, y._1) 
) 

PS: Bonus điểm để bất cứ ai nhận được chơi chữ. ;-)

Answer 6

này cho phép cặp không đầy đủ:

def pairwise [T] (xs: List[T]) : List [(Option[T], Option[T])] = xs match { 
    case (x :: y :: xsr) => (Some (x), Some (y)) :: pairwise (xsr)    
    case (x :: Nil) => List ((Some (x), None))         
    case (_) => Nil }