Su tarea es escribir un programa que, dado un conjunto y un número, necesita dividir el conjunto en trozos con el tamaño es número.

Reglas

Su programa recibirá una matriz A, así como un número entero positivo n. La matriz se debe dividir en trozos de longitud n, si la longitud de la cadena no es divisible por nlas sobras al final debe considerarse su propio fragmento.

• Si nes mayor que la longitud de la matriz A, deberá devolver la matriz A, por ejemplo: si n = 4y array A = [1,2,3], debe devolver[1,2,3]

• La matriz puede contener cualquier tipo en lugar de número.

• No debe cambiar el orden (o dirección) de ningún artículo de izquierda a derecha. Por ejemplo if n = 2y A= [1,2,3]. Cualquier resultado en lugar de [[1,2],[3]]será inválido.

Casos de prueba

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

Este es el código de golf , por lo que los bytes más cortos de cada idioma serán los ganadores.

05AB1E , 1 byte

ô

Pruébelo en línea o verifique todos los casos de prueba .

Builtins ftw. :)

JavaScript (ES6), 36 bytes

Toma entrada como (n)(array).

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

Pruébalo en línea!

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↑⍨⊣

Muchas gracias a Adám por hacer básicamente todo el golf (y básicamente por todos los conocimientos de APL que tengo actualmente> _>).

Explicación

 ⊂⍨           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

Ejecución

Argumentos 2, 1 2 3 4 5 6 7. Tenga en cuenta que las matrices APL son de la forma a b c, con paréntesis opcionales circundantes.

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

Pruébalo en línea!

Python 3 , 61 bytes

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

Pruébalo en línea!

Modifica la solución Python 3 existente de Henry T para producir una salida válida para n> = len (A).
Publicar como su propia respuesta debido a la falta de privilegios para comentar.

Prólogo (SWI) , 90 84 61 bytes

Código:

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

El formato de entrada puede ser un poco extraño, pero es:

A * n * Result.

Por ejemplo, para la entrada:

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

Tendría que usar [1, 2, 3, 4, 5, 6] * 2 * Result..

Pruébalo en línea!

Versión sin golf:

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

Pruébalo en línea! .

PHP, 15 bytes

$f=array_chunk;

requiere PHP 7. Llamar con $f(ARRAY, N).

Perl 6 , 13 bytes

{*.batch($_)}

Pruébalo en línea!

Función curry que envuelve el batchincorporado.

Limpio , 54 bytes

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

Pruébalo en línea!

Python 2 , 39 bytes

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

Pruébalo en línea!

Asume que 1 fragmento por línea es una salida aceptable.

Brainfuck, 71 bytes

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

No sé si esto cuenta o no ... 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

Toma la entrada y pone un espacio cada vez nque pasan los personajes

Explicación (sin comas porque eso rompería el 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 gracias a @Collin Phillips.

Pruébalo en línea!

CJam , 3 bytes

{/}

Este es un bloque anónimo que toma una matriz de números y un número de la pila, y los reemplaza por una matriz de matrices.

Pruébalo en línea!

Brachylog , 2 bytes

ġ₎

Pruébalo en línea!

Elixir , 16 bytes

Enum.chunk_every

Pruébalo en línea!

Carbón , 1 byte

⪪

Pruébalo en línea! La E / S predeterminada de Charcoal dificulta la demostración utilizando cualquier cosa excepto cadenas. Si desea un programa completo que tome listas numéricas y genere listas formateadas, puede hacerlo de la siguiente manera:

Ｅ⪪ＡＮ⪫ι,

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

  Ａ      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 interactivo de Visual C #) , 78 77 43 bytes

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

Pruébalo en línea!

Creo que deberíamos poder escribir simplemente int i;porque 0 es el valor predeterminado de int. Lo dejo para evitar el error: error CS0165: Use of unassigned local variable 'i'.

F # (.NET Core) , 15 bytes

Seq.chunkBySize

Pruébalo en línea!

Bueno F # tiene un incorporado ...

J , 4 bytes

<\~-

Pruébalo en línea!

Toma la matriz como argumento izquierdo y el tamaño del fragmento como argumento derecho.

Utiliza un gancho diádico y el adverbio infijo con un argumento negativo, que hace lo que queremos por definición.

Nota: El tipo de retorno debe estar encuadrado porque J solo permite tablas de elementos de igual tamaño.

Japt , 2 bytes

òV

Pruébalo en línea!

PHP , 45 bytes

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

Pruébalo en línea!

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 los trozos sin delimitador.

Pruébalo en línea.

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;}

En realidad, devuelve una lista de listas.

Pruébalo en línea.

Explicación:

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}

Pruébalo en línea!

Rubí , 25 bytes

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

Pruébalo en línea!

Si podemos devolver enumeradores en lugar de matrices, entonces se convierte simplemente en:

Ruby , 21 bytes

->n,a{a.each_slice n}

Pruébalo en línea!

PicoLisp , 75 74 bytes

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

Pruébalo en línea!

Coco , 8 bytes

groupsof

Pruébalo en línea!

V , 6 bytes

òÀf,r

Pruébalo en línea!

Hexdump:

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

Explicación:

ò           " 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 %)

construcciones supongo

Haskell , 26 bytes

import Data.Lists
chunksOf

Aquí hay una versión más interesante, con solo unos pocos bytes más (gracias a nimi por cinco bytes en cada solución):

Haskell , 31 bytes

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

Pruébalo en línea!

PowerShell , 67 65 bytes

-2 bytes gracias AdmBorkBork

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

Pruébalo en línea!

Gelatina , 1 byte

s

Pruébalo en línea!

Si bien la impresora hace que parezca que las divisiones de un solo elemento no están incluidas en listas, en realidad lo están.