Teilen Sie die Liste in mehrere Listen mit einer festen Anzahl von Elementen auf

Wie teile ich eine Liste von Elementen in Listen mit höchstens N Elementen auf?

Beispiel: Erstellen Sie bei einer Liste mit 7 Elementen 4er-Gruppen, wobei die letzte Gruppe möglicherweise weniger Elemente enthält.

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

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

Ich denke du suchst grouped. Es gibt einen Iterator zurück, aber Sie können das Ergebnis in eine Liste konvertieren.

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

Es gibt eine viel einfachere Möglichkeit, die Aufgabe mithilfe der Gleitmethode auszuführen. Es funktioniert so:

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

Nehmen wir an, Sie möchten die Liste in kleinere Listen der Größe 3 aufteilen.

numbers.sliding(3, 3).toList

werde dir geben

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

Oder wenn Sie Ihre eigenen machen wollen:

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

Verwenden:

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 : Wenn ich dies 2 Jahre später überprüfe, würde ich diese Implementierung nicht empfehlen, da sie sizeO (n) ist, und daher ist diese Methode O (n ^ 2), was erklären würde, warum die eingebaute Methode für große Listen schneller wird. wie in den Kommentaren unten angegeben. Sie können Folgendes effizient implementieren:

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

oder sogar (etwas) effizienter mit 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)
  }

Ich füge eine rekursive Schwanzversion der Split-Methode hinzu, da einige Diskussionen über Schwanzrekursion und Rekursion geführt wurden. Ich habe die Annotation tailrec verwendet, um den Compiler zu zwingen, sich zu beschweren, falls die Implementierung tatsächlich nicht tail-recusive ist. Ich glaube, die Schwanzrekursion wird zu einer Schleife unter der Haube und verursacht daher auch bei einer großen Liste keine Probleme, da der Stapel nicht unbegrenzt wächst.

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

Ich denke, dies ist die Implementierung mit splitAt anstelle von 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)