Элементы zip с четными и нечетными индексами в списке
Я хочу архивировать четные и нечетные элементы в списке для вхождения в список пар, как этот:
["A", "B", "C", "D", "E", "F"] -> [("A", "B"), ("C", "D"), ("E", "F")]
Что самое краткое выражение должно выполнить в этом изящном функциональным способом?
6 ответов
В 2.8 вы, вероятно, будете использовать методы:
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))
(Это 2.8.0 Beta1; в последнем стволе есть collect вместо partialMap.)
В 2.7 - и неплохое второе место в 2. 8 - вы можете создать рекурсивный метод, как это сделал legoscia:
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: вот другой более короткий подход, который работает и в 2.7:
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))
(Обратите внимание на использование drop(1) вместо tail, так что он работает с пустыми списками)
Это позволяет использовать неполные пары:
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 }
Непроверено:
def ziptwo(l: List[String]): List[(String, String)] = l match {
case Nil => Nil
case a :: b :: rest =>
Pair(a,b) :: ziptwo(rest)
}
в Scala 2.8 вы можете:
def pairs[T](xs: List[T]) =
xs.grouped(2)
.map{case List(a, b) => (a,b)}
.toList
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!")
}
Единственное преимущество того, что все предлагают наиболее очевидные способы сделать это, заключается в том, что мне приходится больше думать об альтернативных решениях. Вот один из них, который работает на Scala 2.8. В Scala 2.7 замените view на 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
Строго говоря, view/projection не нужен, но он позволяет избежать ненужного создания промежуточных результатов.
Другие забавные способы:
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: Бонусное очко тому, кто поймет каламбур. ;-)