Dato un elenco di numeri interi Le un numero intero N, l'output è Lsuddiviso in Nliste secondarie di uguale lunghezza.

Lunghezze non divisibili

Se Nnon divide la lunghezza di L, non è possibile che tutte le liste secondarie abbiano la stessa lunghezza.

In ogni caso, l'ultimo elenco secondario dell'output è quello che adatta la sua lunghezza per contenere il resto dell'elenco.

Ciò significa che tutte le liste secondarie di Ltranne l'ultima dovrebbero essere lunghe length(L) // N, dove //è suddivisa la pavimentazione (es 3//2 = 1.).

Alcune regole

• L può essere vuoto.

• N >= 1.

• È possibile utilizzare qualsiasi built-in desiderato.

• È possibile accettare l'input STDIN, come argomento di funzione o qualcosa di simile.

• È possibile stampare l'output STDOUT, restituirlo da una funzione o qualcosa di simile.

• Puoi scegliere qualsiasi formato per gli elenchi e per i numeri interi purché sia ​​la rappresentazione più naturale di elenchi e numeri interi nella tua lingua.

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

punteggio

Questo è code-golf , quindi vince la risposta più breve in byte.

Pyth, 11 10 byte

1 byte grazie a @FryAmTheEggman .

cJEt*R/lJQ

Suite di test.

Accetta gli input in ordine inverso.

Input di esempio:

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

Uscita campione:

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

Spiegazione

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

Fondamentalmente una funzione senza nome che esegue l'attività. Grazie a LeakyNun per i byte salvati!

Lisp comune, 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)))))

Ungolfed:

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

Esempio di chiamata:

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

Provalo qui!

Fondamentalmente:

• Se stiamo tagliando l'ultimo gruppo, restituisce ciò che resta dell'elenco iniziale.
• Altrimenti, estrarre p = |L| / Nelementi dall'elenco e unirli al risultato di una chiamata ricorsiva sul resto. iè un contatore di iterazioni utilizzato per la condizione di arresto.

All'inizio avevo frainteso la sfida, pensando che il programma dovesse costruire gruppi di Nelementi anziché Ngruppi. Comunque, questa versione fa il lavoro per altri 10 byte. Questa volta il LisP non vincerà, ma non potevo davvero perdere l'occasione: ')

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)

Esempio di utilizzo: [1,2,3,4] % 3-> [[1],[2],[3,4]].

Un semplice approccio ricorsivo, simile alla risposta di @ xnor .

Modifica: @ Will Ness ha salvato 2 byte. Grazie!

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}

Sembra troppo lungo, ma non riesco a trovare un modo per far funzionare felicemente lo slicing se ci sono array vuoti nell'output, quindi ho bisogno dell'incapsulamento if/ elseper gestire quei casi. Inoltre, poiché l'impostazione predefinita di PowerShell .ToString()per le matrici tramite l'output della console può sembrare un po 'strana, è possibile virare su a -join','per mostrare le matrici come separate da virgola anziché da newline sulla console. L'ho fatto negli esempi seguenti per rendere più chiaro l'output, ma non vorrai farlo se lasci l'output sulla pipeline per un altro comando da raccogliere.

Spiegazione

Riceve input param($l,$n)per l'elenco e il numero di partizioni, rispettivamente. Inseriamo quindi un'istruzione if/ else. Se la dimensione di ogni partizione $pè diversa da zero (impostando l'helper $cin modo che sia .countlungo la strada), siamo nel if.

All'interno di if, eseguiamo il loop da 1a $ncon |%{...}, e ogni iterazione stiamo eseguendo una porzione di array dall'aspetto piuttosto complesso $l[(($_-1)*$p)..((($_*$p-1),$c)[!($_-$n)])]. La prima parentesi è il nostro indice iniziale, basato su quale partizione siamo e su quanto è grande la nostra dimensione della partizione. Lo spaziamo ..con il nostro indice finale, che è formato da uno pseudo-ternario . Qui, stiamo scegliendo tra $c(la fine letterale dell'array) o la lunghezza della nostra partizione, in base al fatto che siamo nell'ultimo blocco $_-$no meno.

Altrimenti, siamo nel else. Costruiamo un array vuoto con l'operatore virgola ,''*pari a un numero inferiore di partizioni rispetto a quello richiesto, quindi puntiamo sull'array di input come elemento finale.

Esempi

Qui sto mostrando le partizioni separate da newline e ogni singolo elemento separato con ,, come descritto sopra.

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

Usando lo slicing dell'elenco F #, con una clausola if che decide se scegliere un elemento o tutti gli elementi rimanenti.

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

Chiama ad es

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

Tutti i test