Sua tarefa é escrever um programa que, dada uma matriz e um número, você precise dividir a matriz em partes com tamanho e número.

Regras

Seu programa receberá uma matriz A, bem como um número inteiro positivo n. A matriz deve então ser dividida em partes de comprimento n, se o comprimento da sequência não for divisível por nqualquer sobra no final deve ser considerado seu próprio pedaço.

• Se nfor maior que o comprimento da matriz A, você precisará retornar a matriz A, por exemplo: se n = 4e array A = [1,2,3], deverá retornar[1,2,3]

• A matriz pode conter qualquer tipo e não número.

• Você não deve alterar a ordem (ou direção) de nenhum item da esquerda para a direita. Por exemplo if n = 2e A= [1,2,3]. Qualquer resultado, em vez de [[1,2],[3]]será inválido.

Casos de teste

n   A               Output

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

Isso é código-golfe , então você terá os bytes mais curtos de cada idioma.

05AB1E , 1 byte

ô

Experimente online ou verifique todos os casos de teste .

Builtins ftw. :)

JavaScript (ES6), 36 bytes

Toma entrada como (n)(array).

n=>g=a=>a+a&&[a.splice(0,n),...g(a)]

Experimente online!

Comentado

n =>                  // n = chunk size
  g = a =>            // g = recursive function taking the array a[]
    a + a             // if a[] is empty, stop recursion and return an empty string
    &&                // otherwise, return an array made of:
    [ a.splice(0, n), //   the next chunk
      ...g(a)         //   followed by the result of a recursive call
    ]                 //   (the last call leads to ...'', which adds nothing)

APL (Dyalog Unicode) , ^{SBCS de} 12 bytes

⊢⊂⍨(⍴⊢)⍴1↑⍨⊣

Muito obrigado a Adám por basicamente fazer basicamente todo o golfe (e basicamente todo o conhecimento sobre APL que tenho atualmente> _>).

Explicação

 ⊂⍨           Partitioned enclose (commuted, i.e. left and right switched) - for each ⍵ in left, ⍺ in right, if ⍺ = 0, create a new sub-array, push ⍵ to latest sub-array
⊢             Right argument of entire expression
       ⍴      Reshape - Change size of right into dimensions specified by left
   (⍴ )       Shape of (here, there is only one dimension - length)
     ⊢        Right argument of entire expression
         ↑⍨   Take (commuted) - takes ⍺ elements from left where ⍺ is right. Extra elements (zeroes here) are automatically added
        1     1
           ⊣  Left argument of entire expression

Execução

Argumentos 2, 1 2 3 4 5 6 7. Observe que as matrizes APL são do formato a b c, com parênteses opcionais.

           ⊣  2
        1     1
         ↑⍨   1↑2 = 1 0
     ⊢        1 2 3 4 5 6 7
   (⍴ )       ⍴1 2 3 4 5 6 7 = 7
       ⍴      7⍴1 0 = 1 0 1 0 1 0 1
⊢             1 2 3 4 5 6 7
 ⊂⍨           1 0 1 0 1 0 1⊂1 2 3 4 5 6 7 = (1 2)(3 4)(5 6)(7)

Experimente online!

Python 3 , 61 bytes

lambda A,n:[A,[A[x:x+n]for x in range(0,len(A),n)]][n<len(A)]

Experimente online!

Modifica a solução Python 3 existente de Henry T para produzir uma saída válida para n> = len (A).
Postagem como sua própria resposta devido à falta de privilégios para comentar.

Prolog (SWI) , 90 84 61 bytes

Código:

[]*_*[].
L*N*[P|R]:-length(P,N),append(P,T,L),T*N*R;P=L,R=[].

O formato de entrada pode ser um pouco estranho, mas é:

A * n * Result.

Por exemplo, para a entrada:

n = 2
 A = [1, 2, 3, 4, 5, 6]

Você precisaria usar [1, 2, 3, 4, 5, 6] * 2 * Result..

Experimente online!

Versão não destruída:

divide([], _, []).
divide(List, N, [Prefix | Result]) :-
    length(Prefix, N), append(Prefix, Remaining, List), divide(Remaining, N, Result) 
  ; Prefix = List, Result = [].

Experimente online! .

PHP, 15 bytes

$f=array_chunk;

requer PHP 7. Ligue com $f(ARRAY, N).

Perl 6 , 13 bytes

{*.batch($_)}

Experimente online!

Função ao curry envolvendo o batchbuilt-in.

Limpo , 54 bytes

import StdEnv
$n l=[l%(i,i+n-1)\\i<-[0,n..length l-1]]

Experimente online!

Python 2 , 39 bytes

i,j=input()
while j:print j[:i];j=j[i:]

Experimente online!

Assume que 1 pedaço por linha é uma saída aceitável.

Brainfuck, 71 bytes

,[>+>+<<-]>>>,[<[>.,<-]>>>++++[<++++++++>-]<.[-]<<<[<+>>+<-]<[->+<]>>>]

Não sei se isso conta ou não ... formato de entrada:

<character whose ascii is n>AAAAAAAAAAAAA
For example, in the input:
 1234567890123492034
n is 32 since the ASCII value of space is 32

Pega a entrada e coloca um espaço toda vez que os ncaracteres passam

Explicação (sem vírgulas porque isso interromperia o programa):

, take n
[>+>+<<-] copy into next two cells (destroys original)
>>>, take first of A into next cell
[ while that input exists
<[>.,<-] if n is nonzero output take next of A subtract one from n
>>>++++[<++++++++>-]<.[-]< n is zero so put a space
<<[<+>>+<-] copy the old n into surrounding cells
<[->+<] move from first cell to second
>>>] take input, do again

Python 3, 46 caracteres

lambda A,n:[A[:n],*(f(A[n:],n)if A[n:]else[])]

-1 graças a @Collin Phillips.

Experimente online!

CJam , 3 bytes

{/}

Este é um bloco anônimo que pega uma matriz de números e um número da pilha e os substitui por uma matriz de matrizes.

Experimente online!

Braquilog , 2 bytes

ġ₎

Experimente online!

Elixir , 16 bytes

Enum.chunk_every

Experimente online!

Carvão , 1 byte

⪪

Experimente online! A E / S padrão do carvão vegetal dificulta a demonstração do uso de qualquer coisa, exceto cadeias. Se você deseja um programa completo que utiliza listas numéricas e gera listas formatadas, isso pode ser feito da seguinte maneira:

Ｅ⪪ＡＮ⪫ι,

Experimente online! Link é a versão detalhada do código. Explicação:

  Ａ      Input array
 ⪪       Split into chunks of
   Ｎ     Input number
Ｅ       Map over chunks
     ι  Current chunk
    ⪫   Joined with
      , Literal `,`
        Implicitly print each chunk on its own line

C # (compilador interativo do Visual C #) , 78 77 43 bytes

a=>b=>{int i=0;return a.GroupBy(_=>i++/b);}

Experimente online!

Acho que devemos ser capazes de escrever apenas int i;porque 0 é o padrão de int. Eu deixá-lo para evitar o erro: error CS0165: Use of unassigned local variable 'i'.

F # (.NET Core) , 15 bytes

Seq.chunkBySize

Experimente online!

Bem, F # tem um builtin ...

J , 4 bytes

<\~-

Experimente online!

Pega a matriz como argumento à esquerda e o tamanho do bloco como argumento à direita.

Usa um gancho diádico e o infixo advérbio com um argumento negativo, que faz o que queremos por definição.

Nota: O tipo de retorno deve estar na caixa, pois J permite apenas tabelas de itens de tamanhos iguais.

Japonês , 2 bytes

òV

Experimente online!

PHP , 45 bytes

function f($a,$b){return array_chunk($a,$b);}

Experimente online!

Java 10, 106 80 bytes

L->n->{for(int l=L.size(),i=0;i<l;)System.out.print(L.subList(i,(i+=n)<l?i:l));}

Imprime os pedaços sem delimitador.

Experimente online.

106 bytes:

L->n->{var r=new java.util.Stack();for(int l=L.size(),i=0;i<l;)r.add(L.subList(i,(i+=n)<l?i:l));return r;}

Na verdade, retorna uma lista de listas.

Experimente online.

Explicação:

L->n->{                       // Method with List and integer parameters and List return-type
  var r=new java.util.Stack();//  Create an empty List
  for(int l=L.size(),         //  Determine the size of the input-List
      i=0;i<l;)               //  Loop `i` in the range [0, size):
    r.add(                    //   Add to the result-List:
      L.subList(i,            //    A sublist of the input-list in the range from `i`
        Math.min(i+=n,l)));   //    to the minimum of: `i` + input-integer or the size
                              //    (and increase `i` by the input-integer at the same)
  return r;}                  //  Return the List of Lists of integers as result

K (oK) , 10 bytes

{(0N,x)#y}

Experimente online!

Ruby , 25 bytes

->n,a{[*a.each_slice(n)]}

Experimente online!

Se podemos retornar enumeradores em vez de matrizes, torna-se simplesmente:

Ruby , 21 bytes

->n,a{a.each_slice n}

Experimente online!

PicoLisp , 75 74 bytes

(de f(n l)(if(>= n(length l))(list l)(cons(head n l)(f n(tail(- 0 n)l)))))

Experimente online!

Coco , 8 bytes

groupsof

Experimente online!

V , 6 bytes

òÀf,r

Experimente online!

Hexdump:

00000000: f2c0 662c 720a                           ..f,r.

Explicação:

ò           " Until an error happens:
  f         "   (f)ind the...
 À          "     n'th...
   ,        "     ","
            "   (If there are less than n commas after the cursor, throw an error)
    r       "   Replace the char under the cursor with...
     <cr>   "     A newline

Clojure, 14 bytes

#(partition %)

builtins eu acho

Haskell , 26 bytes

import Data.Lists
chunksOf

Aqui está uma versão mais interessante, com apenas mais alguns bytes (graças a nimi por cinco bytes em cada solução):

Haskell , 31 bytes

n![]=[]
n!x=take n x:n!drop n x

Experimente online!

PowerShell , 67 65 bytes

-2 bytes obrigado AdmBorkBork

param($n,$a)$a|%{$b+=,$_
if($b.Count-ge$n){,$b;rv b}}
if($b){,$b}

Experimente online!

Geléia , 1 byte

s

Experimente online!

Embora a impressora pareça que as divisões de elemento único não são agrupadas em listas, elas realmente são.