Dividir la lista en varias listas con un número fijo de elementos

¿Cómo dividir una lista de elementos en listas con como máximo N elementos?

Ej .: Dada una lista con 7 elementos, cree grupos de 4, dejando el último grupo posiblemente con menos elementos.

split(List(1,2,3,4,5,6,"seven"),4)

=> List(List(1,2,3,4), List(5,6,"seven"))

Creo que estás buscando grouped. Devuelve un iterador, pero puede convertir el resultado en una lista,

scala> List(1,2,3,4,5,6,"seven").grouped(4).toList
res0: List[List[Any]] = List(List(1, 2, 3, 4), List(5, 6, seven))

Hay una forma mucho más sencilla de realizar la tarea mediante el método deslizante. Funciona de esta manera:

val numbers = List(1, 2, 3, 4, 5, 6 ,7)

Supongamos que desea dividir la lista en listas más pequeñas de tamaño 3.

numbers.sliding(3, 3).toList

Te regalaré

List(List(1, 2, 3), List(4, 5, 6), List(7))

O si quieres hacer el tuyo propio:

def split[A](xs: List[A], n: Int): List[List[A]] = {
  if (xs.size <= n) xs :: Nil
  else (xs take n) :: split(xs drop n, n)
}

Utilizar:

scala> split(List(1,2,3,4,5,6,"seven"), 4)
res15: List[List[Any]] = List(List(1, 2, 3, 4), List(5, 6, seven))

editar : al revisar esto 2 años después, no recomendaría esta implementación ya que sizees O (n), y por lo tanto este método es O (n ^ 2), lo que explicaría por qué el método integrado se vuelve más rápido para listas grandes, como se indica en los comentarios a continuación. Puede implementar de manera eficiente de la siguiente manera:

def split[A](xs: List[A], n: Int): List[List[A]] =
  if (xs.isEmpty) Nil 
  else (xs take n) :: split(xs drop n, n)

o incluso (un poco) más eficientemente usando splitAt:

def split[A](xs: List[A], n: Int): List[List[A]] =
  if (xs.isEmpty) Nil 
  else {
    val (ys, zs) = xs.splitAt(n)   
    ys :: split(zs, n)
  }

Estoy agregando una versión recursiva de cola del método de división ya que hubo alguna discusión sobre recursión de cola versus recursión. He usado la anotación tailrec para obligar al compilador a quejarse en caso de que la implementación no sea realmente recusiva. Creo que la recursividad de cola se convierte en un bucle bajo el capó y, por lo tanto, no causará problemas incluso para una lista grande, ya que la pila no crecerá indefinidamente.

import scala.annotation.tailrec


object ListSplitter {

  def split[A](xs: List[A], n: Int): List[List[A]] = {
    @tailrec
    def splitInner[A](res: List[List[A]], lst: List[A], n: Int) : List[List[A]] = {
      if(lst.isEmpty) res
      else {
        val headList: List[A] = lst.take(n)
        val tailList : List[A]= lst.drop(n)
        splitInner(headList :: res, tailList, n)
      }
    }

    splitInner(Nil, xs, n).reverse
  }

}

object ListSplitterTest extends App {
  val res = ListSplitter.split(List(1,2,3,4,5,6,7), 2)
  println(res)
}

Creo que esta es la implementación que usa splitAt en lugar de take / drop

def split [X] (n:Int, xs:List[X]) : List[List[X]] =
    if (xs.size <= n) xs :: Nil
    else   (xs.splitAt(n)._1) :: split(n,xs.splitAt(n)._2)