Diviser la liste en plusieurs listes avec un nombre fixe d'éléments

Comment diviser une liste d'éléments en listes avec au plus N éléments?

ex: Étant donné une liste de 7 éléments, créez des groupes de 4, laissant éventuellement le dernier groupe avec moins d'éléments.

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

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

Je pense que vous cherchez grouped. Il renvoie un itérateur, mais vous pouvez convertir le résultat en liste,

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

Il existe un moyen beaucoup plus simple d'effectuer la tâche en utilisant la méthode de glissement. Cela fonctionne de cette façon:

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

Disons que vous souhaitez diviser la liste en listes plus petites de taille 3.

numbers.sliding(3, 3).toList

te donnera

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

Ou si vous souhaitez créer le vôtre:

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

Utilisation:

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

edit : après avoir examiné cela 2 ans plus tard, je ne recommanderais pas cette implémentation car sizeest O (n), et donc cette méthode est O (n ^ 2), ce qui expliquerait pourquoi la méthode intégrée devient plus rapide pour les grandes listes, comme indiqué dans les commentaires ci-dessous. Vous pouvez mettre en œuvre efficacement comme suit:

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

ou même (légèrement) plus efficacement en utilisant 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)
  }

J'ajoute une version récursive de queue de la méthode de fractionnement car il y avait une discussion de la récursion de queue par rapport à la récursivité. J'ai utilisé l'annotation tailrec pour forcer le compilateur à se plaindre au cas où l'implémentation ne serait pas vraiment recusive. Je crois que la récursivité de la queue se transforme en boucle sous le capot et ne posera donc pas de problèmes, même pour une grande liste, car la pile ne croîtra pas indéfiniment.

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

Je pense que c'est l'implémentation utilisant splitAt au lieu 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)