Dada uma lista de números inteiros Le um número inteiro N, a saída Ldividida em Nsublistas de comprimento igual.

Comprimentos não divisíveis

Se Nnão divide o comprimento de L, então não é possível que todas as sublistas tenham o mesmo comprimento.

De qualquer forma, a última sub-lista da saída é a que adapta seu comprimento para conter o restante da lista.

Isso significa que todas as sublistas de, Lexceto a última, devem ter comprimento length(L) // N, onde //está a divisão com piso (por exemplo 3//2 = 1).

Algumas regras

• L pode estar vazio.

• N >= 1.

• Você pode usar qualquer built-in que desejar.

• Você pode levar a entrada por meio de STDIN, como argumento de função, ou algo semelhante.

• Você pode imprimir a saída STDOUT, retorná-la de uma função ou algo semelhante.

• Você pode escolher qualquer formato para as listas e o número inteiro, desde que seja a representação mais natural de listas e números inteiros no seu idioma.

Casos de teste

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

Pontuação

Isso é código-golfe , então a resposta mais curta em bytes vence.

Pitão, 11 10 bytes

1 byte graças a @FryAmTheEggman .

cJEt*R/lJQ

Suíte de teste.

Recebe entradas em ordem inversa.

Entrada de amostra:

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

Saída de amostra:

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

Explicação

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

Basicamente, uma função sem nome que executa a tarefa. Obrigado a LeakyNun pelos bytes salvos!

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

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

Chamada de exemplo:

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

Experimente aqui!

Basicamente:

• Se estivermos cortando o último grupo, retorne o que resta da lista inicial.
• Caso contrário, retire os p = |L| / Nelementos da lista e junte-os ao resultado de uma chamada recursiva no restante. ié um contador de iteração usado para a condição de parada.

Eu havia entendido mal o desafio a princípio, pensando que o programa deveria criar grupos de Nelementos em vez de Ngrupos. De qualquer forma, esta versão faz o trabalho por 10 bytes extras. O LisP não ganhará desta vez, mas não pude perder a oportunidade: ')

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)

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

Uma abordagem recursiva simples, semelhante à resposta do @ xnor .

Edit: @Will Ness salvou 2 bytes. Obrigado!

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}

Parece muito longo, mas não consigo encontrar uma maneira de fazer com que o fatiamento funcione feliz se houver matrizes vazias na saída, portanto, preciso do encapsulamento if/ elsepara lidar com esses casos. Além disso, como o padrão do PowerShell .ToString()para matrizes via saída do console pode parecer um pouco estranho, você pode usar um -join','para mostrar as matrizes como separadas por vírgula, em vez de separadas por nova linha no console. Fiz isso nos exemplos abaixo para tornar a saída mais clara, mas você não vai querer fazer isso se estiver deixando a saída no pipeline para outro comando pegar.

Explicação

Recebe entrada param($l,$n)para a lista e o número de partições, respectivamente. Em seguida, inserimos uma instrução if/ else. Se o tamanho de cada partição $pfor diferente de zero (definindo o auxiliar $ccomo .counto caminho), estamos no if.

Dentro do if, fazemos um loop de 1para $ncom |%{...}, e a cada iteração, estamos fazendo uma fatia de matriz bastante complexa $l[(($_-1)*$p)..((($_*$p-1),$c)[!($_-$n)])]. A primeira parênteses é o nosso índice inicial, com base em qual partição estamos e quão grande é o tamanho da partição. Variamos isso ..com nosso índice final, formado a partir de um pseudo-ternário . Aqui, estamos escolhendo entre $c(o final literal da matriz) ou o comprimento da nossa partição, com base no fato de estarmos no último bloco $_-$nou não.

Caso contrário, estamos no else. Construímos uma matriz vazia com o operador de vírgula ,''*igual a menos partições que o solicitado e, em seguida, aderimos à matriz de entrada como o elemento final.

Exemplos

Aqui, estou mostrando as partições separadas por novas linhas e cada elemento individual por separado ,, conforme descrito acima.

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 o faturamento da lista F #, com uma cláusula if que decide se deve escolher um elemento ou todos os elementos restantes.

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

Ligue por exemplo

a - 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 os casos de teste