Đưa ra một danh sách các số nguyên Lvà một số nguyên N, đầu ra được Lchia thành các Ndanh sách con có chiều dài bằng nhau.

Độ dài không chia hết

Nếu Nkhông phân chia độ dài Lthì không thể có tất cả các danh sách con có độ dài bằng nhau.

Trong mọi trường hợp, danh sách con cuối cùng của đầu ra là danh sách điều chỉnh độ dài của nó để chứa phần còn lại của danh sách.

Điều này có nghĩa là tất cả các danh sách con Lngoại trừ danh sách cuối cùng phải có độ dài length(L) // N, trong đó //phân chia nổi (ví dụ 3//2 = 1).

Một số quy tắc

• L có thể để trống

• N >= 1.

• Bạn có thể sử dụng bất kỳ tích hợp nào bạn muốn.

• Bạn có thể lấy đầu vào thông qua STDIN, làm đối số hàm hoặc bất cứ thứ gì tương tự.

• Bạn có thể in đầu ra STDOUT, trả lại từ một chức năng hoặc bất cứ thứ gì tương tự.

• Bạn có thể chọn bất kỳ định dạng nào cho danh sách và số nguyên miễn là nó là đại diện tự nhiên nhất của danh sách và số nguyên trong ngôn ngữ của bạn.

Các trường hợp thử nghiệm

Input:  [1,2,3,4], 2
Output: [[1,2],[3,4]]

Input:  [-1,-2,3,4,-5], 2
Output: [[-1,-2],[3,4,-5]]

Input:  [1,2,3,4], 1
Output: [[1,2,3,4]]

Input:  [4,8,15,16,23,42], 5
Output: [[4],[8],[15],[16],[23,42]]

Input:  [4,8,15,16,23,42], 7
Output: [[],[],[],[],[],[],[4,8,15,16,23,42]]

Input:  [2,3,5,7,11,13,17,19,23], 3
Output: [[2,3,5],[7,11,13],[17,19,23]]

Input:  [], 3
Output: [[],[],[]]

Input:  [1,2,3,4,5,6,7,8], 3
Output: [[1,2],[3,4],[5,6,7,8]]

Chấm điểm

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.

Bình thường, 11 10 byte

1 byte nhờ @FryAmTheEggman .

cJEt*R/lJQ

Bộ thử nghiệm.

Đưa đầu vào theo thứ tự đảo ngược.

Đầu vào mẫu:

5
[1,2,3,4,5,6,7]

Đầu ra mẫu:

[[1], [2], [3], [4], [5, 6, 7]]

Giải trình

cJEt*R/lJQ     Main function, first input:Q, second input:E.
cJEt*R/lJQQ    Implicit arguments.

c              The function c is special.
               It can chop arrays.
               If the second argument is a list of integers,
               then it chops the first array at the indices
               specified by the second array.

 JE            The first argument is the second input, stored
               to the variable J.

   t*R/lJQQ    This is the second argument.
      /lJQ     Yield length of J, integer-divided by Q.
    *R    Q    Multiply it to the following respectively:
                   [0,1,2,3,...,Q-1]
   t           Then throw away the first element.
               For example, if Q=3 and E=[1,2,3,4,5,6,7,8],
               we would now have [3,6].

JavaScript (ES6), 63 byte

(a,n,l=a.length/n|0)=>[...Array(n)].map(_=>--n?a.splice(0,l):a)

Python, 76 73 byte

lambda L,N:list(map(lambda x,r=len(L)//N:L[x*r:][:r+(x>N-2)*N],range(N)))

Về cơ bản là một chức năng không tên thực hiện nhiệm vụ. Cảm ơn LeakyNun cho các byte được lưu!

Lisp thông thường, 114 byte

(defun f(l n &optional(p(floor(length l)n))(i 1))(if(= i n)(list l)(cons(subseq l 0 p)(f(subseq l p)n p(+ i 1)))))

Ung dung:

(defun f (l n &optional (p (floor (length l) n)) (i 1))
  (if (= i n) (list l)
              (cons (subseq l 0 p)
                    (f (subseq l p) n p (+ i 1))))
  )

Cuộc gọi ví dụ:

(format t "~A~C~C" (f (read) (read)) #\return #\newline)

Hãy thử nó ở đây!

Về cơ bản:

• Nếu chúng tôi đang cắt nhóm cuối cùng, hãy trả lại bất cứ thứ gì còn lại của danh sách ban đầu.
• Mặt khác, lấy p = |L| / Ncác phần tử ra khỏi danh sách và nối nó với kết quả của một cuộc gọi đệ quy trên phần còn lại. ilà một bộ đếm lặp được sử dụng cho điều kiện dừng.

Lúc đầu tôi đã hiểu nhầm thử thách, nghĩ rằng chương trình nên xây dựng các nhóm Nyếu tố chứ không phải Nnhóm. Dù sao, phiên bản này thực hiện công việc thêm 10 byte. Lần này LisP sẽ không thắng nhưng tôi thực sự không thể bỏ lỡ cơ hội: ')

Haskell, 69 67 byte

a%b=a#b where l#1=[l];l#n|(h,t)<-splitAt(div(length a)b)l=h:t#(n-1)

Ví dụ sử dụng: [1,2,3,4] % 3-> [[1],[2],[3,4]].

Một cách tiếp cận đệ quy đơn giản, tương tự như câu trả lời của @ xnor .

Chỉnh sửa: @Will Ness đã lưu 2 byte. Cảm ơn!

PowerShell v2 +, 125 byte

param($l,$n)if($p=[math]::Floor(($c=$l.count)/$n)){1..$n|%{$l[(($_-1)*$p)..((($_*$p-1),$c)[!($_-$n)])]}}else{(,''*($n-1))+$l}

Cảm thấy quá dài, nhưng dường như tôi không thể tìm ra cách để cắt lát hoạt động vui vẻ nếu có các mảng trống trong đầu ra, vì vậy tôi cần đóng gói if/ elseđể xử lý các trường hợp đó. Ngoài ra, do mặc định của PowerShell .ToString()cho các mảng thông qua đầu ra của bảng điều khiển có thể trông hơi lạ, bạn có thể giải quyết một -join','để hiển thị các mảng dưới dạng phân tách bằng dấu phẩy thay vì phân tách dòng trên bảng điều khiển. Tôi đã thực hiện điều đó trong các ví dụ dưới đây để làm cho đầu ra rõ ràng hơn, nhưng bạn sẽ không muốn làm điều đó nếu bạn để đầu ra trên đường ống cho một lệnh khác nhận.

Giải trình

Lấy đầu vào param($l,$n)cho danh sách và số lượng phân vùng, tương ứng. Chúng tôi sau đó nhập một if/ elsetuyên bố. Nếu kích thước của mỗi phân vùng, $pkhác không (thiết lập trình trợ giúp $clà .countdọc theo đường đi), thì chúng tôi đang ở if.

Bên trong if, chúng ta lặp từ 1đến $nvới |%{...}, và mỗi lần lặp chúng ta đang thực hiện một lát cắt trông khá phức tạp $l[(($_-1)*$p)..((($_*$p-1),$c)[!($_-$n)])]. Parens đầu tiên là chỉ mục bắt đầu của chúng tôi, dựa trên phân vùng chúng tôi đang sử dụng và kích thước phân vùng của chúng tôi lớn như thế nào. Chúng tôi phạm vi rằng ..với chỉ số kết thúc của chúng tôi, được hình thành từ một giả ba . Ở đây, chúng tôi sẽ chọn giữa một trong hai $c(phần cuối của mảng) hoặc độ dài của phân vùng của chúng tôi, dựa trên việc chúng tôi có ở đoạn cuối $_-$nhay không.

Nếu không, chúng tôi đang ở else. Chúng tôi xây dựng một mảng trống với toán tử dấu phẩy ,''*bằng một ít phân vùng hơn yêu cầu và sau đó xử lý mảng đầu vào làm thành phần cuối cùng.

Ví dụ

Ở đây tôi đang hiển thị các phân vùng được phân tách bằng dòng mới và từng phần tử riêng biệt được phân tách bằng ,, như được mô tả ở trên.

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (1,2,3,4) 2
1,2
3,4

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (-1,-2,3,4,-5) 2
-1,-2
3,4,-5

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (1,2,3,4) 1
1,2,3,4

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (4,8,15,16,23,42) 5
4
8
15
16
23,42

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (4,8,15,16,23,42) 7






4,8,15,16,23,42

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (2,3,5,7,11,13,17,19,23) 3
2,3,5
7,11,13
17,19,23

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 $null 3



PS C:\Tools\Scripts\golfing> 

F #, 100 98 byte

fun n l->
let a=List.length l/n
List.init n (fun i->if i<n-1 then l.[a*i..a*i+a-1] else l.[a*i..])

Sử dụng cắt danh sách F #, với mệnh đề if quyết định chọn một phần tử hay tất cả các phần tử còn lại.

Prolog, 100 99 byte.

n(A,B):-length(B,A).
p(L,K,G):-n(K,G),append(A,[_],G),n(N,L),M is N//K,maplist(n(M),A),append(G,L).

Gọi ví dụ

? - p ([1,2,3,4,5,6,7], 3, X).
X = [[1, 2], [3, 4], [5, 6, 7]] .

PHP, 109 byte

<?for($n=(count($a=$_GET[0]))/($d=$_GET[1])^0;$i<$d;)$r[]=array_slice($a,$i*$n,++$i==$d?NULL:$n);print_r($r);

Tất cả các Testcase