Dada una lista de enteros Ly un entero N, la salida se Ldividió en Nsublistas de igual longitud.

Longitudes no divisibles

Si Nno divide la longitud de L, entonces no es posible que todas las sublistas tengan la misma longitud.

En cualquier caso, la última sublista de la salida es la que adapta su longitud para contener el resto de la lista.

Esto significa que todas las sublistas de, Lexcepto la última, deben ser largas length(L) // N, donde //se divide el piso (por ejemplo 3//2 = 1).

Algunas reglas

• L Puede estar vacío.

• N >= 1.

• Puede usar cualquier incorporado que desee.

• Puede tomar la entrada STDIN, como un argumento de función, o algo similar.

• Puede imprimir el resultado STDOUT, devolverlo desde una función o algo similar.

• Puede elegir cualquier formato para las listas y el entero, siempre que sea la representación más natural de las listas y los enteros en su idioma.

Casos de prueba

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

Puntuación

Este es el código de golf , por lo que gana la respuesta más corta en bytes.

Pyth, 11 10 bytes

1 byte gracias a @FryAmTheEggman .

cJEt*R/lJQ

Banco de pruebas.

Toma entradas en orden inverso.

Entrada de muestra:

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

Salida de muestra:

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

Explicación

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 bytes

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

Python, 76 73 bytes

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

Básicamente, una función sin nombre que realiza la tarea. ¡Gracias a LeakyNun por los bytes guardados!

Lisp común, 114 bytes

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

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

Llamada de ejemplo:

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

Pruébalo aquí!

Básicamente:

• Si estamos cortando el último grupo, devuelva lo que quede de la lista inicial.
• De lo contrario, elimine p = |L| / Nelementos de la lista y únalos al resultado de una llamada recursiva en el resto. ies un contador de iteraciones utilizado para la condición de detención.

Al principio había entendido mal el desafío, pensando que el programa debería construir grupos de Nelementos en lugar de Ngrupos. De todos modos, esta versión hace el trabajo por 10 bytes adicionales. LisP no ganará esta vez, pero realmente no podría perder la oportunidad: ')

Haskell, 69 67 bytes

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

Ejemplo de uso: [1,2,3,4] % 3-> [[1],[2],[3,4]].

Un enfoque recursivo simple, similar a la respuesta de @ xnor .

Editar: @Will Ness guardó 2 bytes. ¡Gracias!

PowerShell v2 +, 125 bytes

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

Se siente demasiado tiempo, pero parece que no puedo encontrar una manera de hacer que el corte funcione correctamente si hay matrices vacías en la salida, por lo que necesito encapsular if/ elsepara manejar esos casos. Además, dado que el valor predeterminado de PowerShell .ToString()para las matrices a través de la salida de la consola puede parecer un poco extraño, puede agregar a -join','para mostrar las matrices como separadas por comas en lugar de separadas por nueva línea en la consola. Lo hice en los ejemplos a continuación para aclarar el resultado, pero no querrá hacerlo si está dejando el resultado en la tubería para que otro comando lo tome.

Explicación

Toma entrada param($l,$n)para la lista y el número de particiones, respectivamente. Luego ingresamos una declaración if/ else. Si el tamaño de cada partición $pno es cero (configurando el asistente $cpara que esté .counten el camino), estamos en el if.

En el interior if, hacemos un bucle de 1a $ncon |%{...}, y en cada iteración estamos haciendo un corte de matriz de aspecto bastante complejo $l[(($_-1)*$p)..((($_*$p-1),$c)[!($_-$n)])]. Los primeros parens son nuestro índice de inicio, en función de en qué partición estamos y qué tan grande es el tamaño de nuestra partición. La alineamos ..con nuestro índice final, que se forma a partir de un pseudoternario . Aquí, estamos eligiendo entre $c(el extremo literal de la matriz) o la longitud de nuestra partición, en función de si estamos en el último fragmento $_-$no no.

De lo contrario, estamos en el else. Construimos una matriz vacía con el operador de coma ,''*igual a una partición menos de la solicitada, y luego agregamos la matriz de entrada como el elemento final.

Ejemplos

Aquí estoy mostrando las particiones separadas con líneas nuevas y cada elemento individual separado ,, como se describió anteriormente.

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 bytes

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 el corte de la lista F #, con una cláusula if que decide si elegir un elemento o todos los elementos restantes.

Prólogo, 100 99 bytes.

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

Llamar p. Ej.

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

PHP, 109 bytes

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

Todos los casos de prueba