Étant donné une liste d'entiers Let un entier N, la sortie est Ldivisée en Nsous-listes de longueurs égales.

Longueurs non divisibles

Si Nne divise pas la longueur de L, alors il n'est pas possible que toutes les sous-listes aient une longueur égale.

Dans tous les cas, la dernière sous-liste de la sortie est celle qui adapte sa longueur pour contenir le reste de la liste.

Cela signifie que toutes les sous-listes à l' Lexception de la dernière doivent être de longueur length(L) // N, où se //trouve la division au sol (par exemple 3//2 = 1).

Certaines règles

• L peut être vide.

• N >= 1.

• Vous pouvez utiliser n'importe quel module intégré de votre choix.

• Vous pouvez prendre l'entrée à travers STDIN, comme argument de fonction, ou quelque chose de similaire.

• Vous pouvez imprimer la sortie dans STDOUT, la renvoyer à partir d'une fonction ou quelque chose de similaire.

• Vous pouvez choisir n'importe quel format pour les listes et l'entier tant qu'il s'agit de la représentation la plus naturelle des listes et des entiers dans votre langue.

Cas de test

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

Notation

Il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte.

Pyth, 11 10 octets

1 octet grâce à @FryAmTheEggman .

cJEt*R/lJQ

Suite de tests.

Prend les entrées dans l'ordre inverse.

Exemple d'entrée:

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

Exemple de sortie:

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

Explication

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 octets

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

Python, 76 73 octets

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

Fondamentalement, une fonction sans nom qui exécute la tâche. Merci à LeakyNun pour les octets enregistrés!

Lisp commun, 114 octets

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

Non golfé:

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

Exemple d'appel:

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

Essayez-le ici!

Fondamentalement:

• Si nous coupons le dernier groupe, retournez tout ce qui reste de la liste initiale.
• Sinon, retirez les p = |L| / Néléments de la liste et joignez-les au résultat d'un appel récursif sur le reste. iest un compteur d'itérations utilisé pour la condition d'arrêt.

Au début, j'avais mal compris le défi, pensant que le programme devait constituer des groupes d' Néléments plutôt que des Ngroupes. Quoi qu'il en soit, cette version fait le travail pour 10 octets supplémentaires. LisP ne gagnera pas cette fois mais je ne pouvais pas vraiment rater l'occasion: ')

Haskell, 69 67 octets

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

Exemple d'utilisation: [1,2,3,4] % 3-> [[1],[2],[3,4]].

Une approche récursive simple, similaire à la réponse de @ xnor .

Edit: @Will Ness a enregistré 2 octets. Merci!

PowerShell v2 +, 125 octets

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

Cela semble trop long, mais je n'arrive pas à trouver un moyen de faire fonctionner le découpage avec bonheur s'il y a des tableaux vides dans la sortie, j'ai donc besoin de l'encapsulation if/ elsepour gérer ces cas. De plus, comme la valeur .ToString()par défaut de PowerShell pour les tableaux via la sortie de la console peut sembler un peu bizarre, vous pouvez ajouter un -join','pour afficher les tableaux comme séparés par des virgules plutôt que par des sauts de ligne sur la console. J'ai fait cela dans les exemples ci-dessous pour rendre la sortie plus claire, mais vous ne voudrez pas le faire si vous laissez la sortie sur le pipeline pour une autre commande à récupérer.

Explication

Prend une entrée param($l,$n)pour la liste et le nombre de partitions, respectivement. Nous entrons ensuite une instruction if/ else. Si la taille de chaque partition $pest différente de zéro (définissant helper $cpour être le .countlong du chemin), nous sommes dans le if.

À l'intérieur de if, nous bouclons de 1à $navec |%{...}, et chaque itération nous faisons une tranche de tableau d'aspect assez complexe $l[(($_-1)*$p)..((($_*$p-1),$c)[!($_-$n)])]. La première parens est notre index de départ, basé sur la partition sur laquelle nous nous trouvons et la taille de notre partition. Nous classons cela ..avec notre indice de fin, qui est formé à partir d'un pseudo-ternaire . Ici, nous choisissons entre $c(la fin littérale du tableau) ou la longueur de notre partition, selon que nous sommes dans le dernier morceau $_-$nou non.

Sinon, nous sommes dans le else. Nous construisons un tableau vide avec l'opérateur virgule ,''*égal à une partition de moins que demandé, puis clouons sur le tableau d'entrée en tant qu'élément final.

Exemples

Ici, je montre les partitions séparées par des sauts de ligne et chaque élément individuel séparé avec ,, comme décrit ci-dessus.

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 octets

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

Utilisation du découpage de liste F #, avec une clause if pour décider de choisir un élément ou tous les autres éléments.

Prolog, 100 99 octets.

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

Appelez par exemple

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

PHP, 109 octets

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

Tous les testcases