Chia danh sách thành nhiều danh sách với số phần tử cố định

Làm thế nào để tách Danh sách các phần tử thành danh sách có nhiều nhất N mục?

ví dụ: Cho một danh sách có 7 phần tử, tạo nhóm 4 phần tử, để lại nhóm cuối cùng có thể có ít phần tử hơn.

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

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

Tôi nghĩ bạn đang tìm kiếm grouped. Nó trả về một trình lặp, nhưng bạn có thể chuyển đổi kết quả thành một danh sách,

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

Có nhiều cách dễ dàng hơn để thực hiện tác vụ bằng phương pháp trượt. Nó hoạt động theo cách này:

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

Giả sử bạn muốn chia danh sách thành các danh sách nhỏ hơn có kích thước 3.

numbers.sliding(3, 3).toList

sẽ cho bạn

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

Hoặc nếu bạn muốn tự làm:

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

Sử dụng:

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

chỉnh sửa : khi xem xét điều này 2 năm sau, tôi sẽ không khuyến nghị triển khai này vì sizelà O (n), và do đó phương pháp này là O (n ^ 2), điều này sẽ giải thích tại sao phương pháp tích hợp trở nên nhanh hơn đối với các danh sách lớn, như đã lưu ý trong bình luận bên dưới. Bạn có thể triển khai hiệu quả như sau:

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

hoặc thậm chí (một chút) hiệu quả hơn bằng cách sử dụng 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)
  }

Tôi đang thêm một phiên bản đệ quy đuôi của phương pháp tách vì đã có một số cuộc thảo luận về đệ quy đuôi so với đệ quy. Tôi đã sử dụng chú thích tailrec để buộc trình biên dịch phải phàn nàn trong trường hợp việc triển khai thực sự không đúng đuôi. Tôi tin rằng đệ quy đuôi biến thành một vòng lặp dưới mui xe và do đó sẽ không gây ra vấn đề ngay cả đối với một danh sách lớn vì ngăn xếp sẽ không phát triển vô thời hạn.

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

Tôi nghĩ đây là cách triển khai sử dụng splitAt thay vì 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)