Biorąc pod uwagę listę liczb całkowitych Li liczbę całkowitą N, dane wyjściowe Lpodzielono na Nlisty podrzędne o jednakowej długości.

Długości niepodzielne

Jeśli Nnie dzieli długości L, nie jest możliwe, aby wszystkie listy podrzędne miały taką samą długość.

W każdym razie ostatnią podlistą wyniku jest ta, która dostosowuje jego długość, aby zawierała resztę listy.

Oznacza to, że wszystkie listy podrzędne z Lwyjątkiem ostatniej powinny mieć długość length(L) // N, gdzie //jest dzielenie dzielone (np 3//2 = 1).

Niektóre zasady

• L może być pusty.

• N >= 1.

• Możesz użyć dowolnego wbudowanego oprogramowania.

• Możesz wziąć dane wejściowe STDINjako argument funkcji lub coś podobnego.

• Możesz wydrukować wynik STDOUT, zwrócić go z funkcji lub coś podobnego.

• Możesz wybrać dowolny format list i liczb całkowitych, o ile jest to najbardziej naturalna reprezentacja list i liczb całkowitych w twoim języku.

Przypadki testowe

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

Punktacja

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.

Pyth, 11 10 bajtów

1 bajt dzięki @FryAmTheEggman .

cJEt*R/lJQ

Zestaw testowy.

Pobiera dane wejściowe w odwrotnej kolejności.

Przykładowe dane wejściowe:

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

Przykładowe dane wyjściowe:

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

Wyjaśnienie

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 bajty

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

Python, 76 73 bajtów

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

Zasadniczo nienazwana funkcja, która wykonuje zadanie. Dzięki LeakyNun za zapisane bajty!

Common Lisp, 114 bajtów

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

Nie golfowany:

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

Przykładowe wywołanie:

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

Wypróbuj tutaj!

Gruntownie:

• Jeśli wycinamy ostatnią grupę, zwróć wszystko, co pozostało z początkowej listy.
• W przeciwnym razie p = |L| / Nusuń elementy z listy i dołącz je do wyniku połączenia rekurencyjnego w pozostałej części. ijest licznikiem iteracji stosowanym do warunku zatrzymania.

Na początku źle zrozumiałem wyzwanie, myśląc, że program powinien budować grupy Nelementów, a nie Ngrupy. W każdym razie ta wersja wykonuje dodatkowe 10 bajtów. Tym razem LisP nie wygra, ale tak naprawdę nie mogłem przegapić okazji: ')

Haskell, 69 67 bajtów

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

Przykład użycia: [1,2,3,4] % 3-> [[1],[2],[3,4]].

Proste rekurencyjne podejście, podobne do odpowiedzi @ xnor .

Edycja: @ Ness zachowa 2 bajty. Dzięki!

PowerShell v2 +, 125 bajtów

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

Wydaje mi się, że jest za długo, ale nie wydaje mi się, aby wymyślić sposób, aby krojenie działało szczęśliwie, jeśli na wyjściu są puste tablice, więc potrzebuję enkapsulacji if/ elsedo obsługi tych przypadków. Dodatkowo, ponieważ domyślne ustawienia PowerShell .ToString()dla tablic za pośrednictwem wyjścia konsoli mogą wyglądać trochę dziwnie, możesz wybrać opcję, -join','aby wyświetlać tablice jako rozdzielone przecinkami, a nie jako znaki nowej linii na konsoli. Zrobiłem to w poniższych przykładach, aby wyjaśnić dane wyjściowe, ale nie będziesz tego chciał, jeśli zostawisz dane wyjściowe w potoku w celu odebrania innego polecenia.

Wyjaśnienie

Pobiera dane wejściowe odpowiednio param($l,$n)dla listy i liczby partycji. Następnie wprowadzamy instrukcję if/ else. Jeśli rozmiar każdej partycji, $pjest niezerowe (ustawienie pomocnika $cbyć .countpo drodze), jesteśmy w if.

Wewnątrz if, pętla od 1do $nz |%{...}oraz każdej iteracji robimy dość skomplikowany wyglądający kawałek tablicy $l[(($_-1)*$p)..((($_*$p-1),$c)[!($_-$n)])]. Pierwsze pareny to nasz indeks początkowy, oparty na partycji, na której się znajdujemy i jak dużym jest nasz rozmiar partycji. Przedzieramy to ..naszym indeksem końcowym, który jest utworzony z pseudo-trójki . Tutaj wybieramy albo $c(dosłowny koniec tablicy), albo długość naszej partycji, w zależności od tego, czy jesteśmy w ostatnim kawałku, $_-$nczy nie.

W przeciwnym razie jesteśmy w else. Konstruujemy pustą tablicę z przecinkiem ,''*równym jednej partycji mniej niż zażądano, a następnie przyczepiamy tablicę wejściową jako element końcowy.

Przykłady

Tutaj pokazuję partycje oddzielone znakami nowej linii i każdy pojedynczy element oddzielony ,, jak opisano powyżej.

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 bajtów

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

Korzystanie z listy F # krojenie, z klauzuli if decydującym czy odebrać do elementów lub wszystkie pozostałe elementy.

Prolog, 100 99 bajtów.

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

Zadzwoń np

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

PHP, 109 bajtów

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

Wszystkie przypadki testowe