elementos postales con índices impares y pares en una lista

Question

que quiere comprimir aún y elementos extraños en una lista para hacer una lista de pares, así:

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

¿Cuál es la expresión más concisa para hacer esto de manera elegante y funcional?

Answer 1

En 2,8, lo que probablemente utilizar métodos:

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)) 

(Esto es 2.8.0 Beta1; el último tronco tiene collect en lugar de partialMap.)

En 2.7 - y no un mal segundo en 2,8 - que podría crear un método recursivo como lo hizo 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)) 

Editar: aquí hay otro enfoque más breve que funciona en 2.7 también:

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)) 

(Observe el uso de drop(1) en lugar de tail por lo que funciona con listas vacías.)

Answer 2

No comprobado:

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

Answer 3

en Scala 2.8 que puede hacer:

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

la única ventaja de h Después de que todos descubran las formas más obvias de hacerlo es que tengo que pensar más en las soluciones alternativas. Así que aquí hay uno que funciona en Scala 2.8. En Scala 2.7, reemplace view con 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 

en sentido estricto, view/projection es innecesario, sino que evita la creación innecesaria de los resultados intermedios.

Otras formas divertidas de hacerlo:

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: punto de bonificación para el que llegue el juego de palabras. ;-)

Answer 6

Esto permite pares incompletas:

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 }