Pisahkan daftar menjadi beberapa daftar dengan jumlah elemen tetap

Bagaimana cara membagi Daftar elemen menjadi daftar dengan paling banyak N item?

mis .: Diberikan daftar dengan 7 elemen, buat grup yang terdiri dari 4 elemen, biarkan grup terakhir mungkin memiliki lebih sedikit elemen.

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

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

Saya pikir Anda sedang mencari grouped. Ini mengembalikan iterator, tetapi Anda dapat mengonversi hasilnya menjadi daftar,

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

Ada cara yang jauh lebih mudah untuk melakukan tugas tersebut menggunakan metode geser. Ini bekerja seperti ini:

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

Katakanlah Anda ingin memecah daftar menjadi daftar ukuran 3 yang lebih kecil.

numbers.sliding(3, 3).toList

akan memberimu

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

Atau jika Anda ingin membuatnya sendiri:

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

Menggunakan:

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

sunting : setelah meninjau ini 2 tahun kemudian, saya tidak akan merekomendasikan implementasi ini karena sizeadalah O (n), dan karenanya metode ini adalah O (n ^ 2), yang akan menjelaskan mengapa metode built-in menjadi lebih cepat untuk daftar besar, seperti yang tercantum dalam komentar di bawah. Anda dapat mengimplementasikan secara efisien sebagai berikut:

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

atau bahkan (sedikit) lebih efisien menggunakan 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)
  }

Saya menambahkan versi rekursif ekor dari metode split karena ada beberapa diskusi tentang rekursi ekor versus rekursi. Saya telah menggunakan anotasi tailrec untuk memaksa compiler untuk mengeluh jika implementasinya tidak benar-benar bersifat tail-recusive. Saya yakin rekursi ekor berubah menjadi loop di bawah kap dan dengan demikian tidak akan menimbulkan masalah bahkan untuk daftar besar karena tumpukan tidak akan tumbuh tanpa batas.

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

Saya pikir ini adalah implementasi menggunakan splitAt, bukan 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)