Votre tâche consiste à écrire un programme qui, étant donné un tableau et un numéro, vous devez diviser le tableau en morceaux dont la taille est le numéro.

Règles

Votre programme recevra un tableau A, ainsi qu'un entier positif n. Le tableau doit ensuite être divisé en morceaux de longueur n, si la longueur de la chaîne n'est pas divisible par un nreste à la fin doit être considérée comme son propre morceau.

• Si nest supérieur à la longueur du tableau A, vous devrez renvoyer le tableau A, par exemple: si n = 4et array A = [1,2,3], vous devez retourner[1,2,3]

• Le tableau peut contenir n'importe quel type plutôt que nombre.

• Vous ne devez pas changer l'ordre (ou la direction) d'un article de gauche à droite. Par exemple if n = 2et A= [1,2,3]. Tout résultat plutôt que [[1,2],[3]]sera invalide.

Cas de test

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

Il s'agit de code-golf , vous serez donc le gagnant des octets les plus courts de chaque langue.

05AB1E , 1 octet

ô

Essayez-le en ligne ou vérifiez tous les cas de test .

Builtins ftw. :)

JavaScript (ES6), 36 octets

Prend l'entrée comme (n)(array).

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

Essayez-le en ligne!

Commenté

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) , 12 octets ^SBCS

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

Un grand merci à Adám pour avoir fait pratiquement tout le golf (et pour pratiquement toutes les connaissances APL que j'ai actuellement> _>).

Explication

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

Exécution

Arguments 2, 1 2 3 4 5 6 7. Notez que les tableaux APL sont de la forme a b c, avec des parenthèses environnantes facultatives.

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

Essayez-le en ligne!

Python 3 , 61 octets

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

Essayez-le en ligne!

Modifie la solution Python 3 existante de Henry T pour produire une sortie valide pour n> = len (A).
Publication comme sa propre réponse en raison du manque de privilèges de commentaire.

Prolog (SWI) , 90 84 61 octets

Code:

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

Le format d'entrée peut être un peu bizarre, mais c'est:

A * n * Result.

Par exemple, pour l'entrée:

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

Vous auriez besoin d'utiliser [1, 2, 3, 4, 5, 6] * 2 * Result..

Essayez-le en ligne!

Version non golfée:

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

Essayez-le en ligne! .

PHP, 15 octets

$f=array_chunk;

nécessite PHP 7. Appelez avec $f(ARRAY, N).

Perl 6 , 13 octets

{*.batch($_)}

Essayez-le en ligne!

Fonction curry enveloppant le batchintégré.

Nettoyer , 54 octets

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

Essayez-le en ligne!

Python 2 , 39 octets

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

Essayez-le en ligne!

Suppose que 1 bloc par ligne est une sortie acceptable.

Brainfuck, 71 octets

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

Ne sais pas si cela compte ou non ... format d'entrée:

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

Prend l'entrée et place un espace à chaque fois que les npersonnages passent

Explication (pas de virgule car cela casserait le programme):

, 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 caractères

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

-1 merci à @Collin Phillips.

Essayez-le en ligne!

CJam , 3 octets

{/}

Il s'agit d'un bloc anonyme qui prend un tableau de nombres et un numéro de la pile et les remplace par un tableau de tableaux.

Essayez-le en ligne!

Brachylog , 2 octets

ġ₎

Essayez-le en ligne!

Elixir , 16 octets

Enum.chunk_every

Essayez-le en ligne!

Fusain , 1 octet

⪪

Essayez-le en ligne! Les E / S par défaut de Charcoal rendent difficile la démonstration de l'utilisation de tout sauf des chaînes. Si vous voulez un programme complet qui prend des listes numériques et génère des listes formatées, cela peut être fait comme suit:

Ｅ⪪ＡＮ⪫ι,

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

  Ａ      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 # (Visual C # Interactive Compiler) , 78 77 43 octets

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

Essayez-le en ligne!

Je pense que nous devrions être capables d'écrire simplement int i;parce que 0 est la valeur par défaut de int. Je l' ai laissé pour éviter l'erreur: error CS0165: Use of unassigned local variable 'i'.

F # (.NET Core) , 15 octets

Seq.chunkBySize

Essayez-le en ligne!

Eh bien F # a une fonction intégrée ...

J , 4 octets

<\~-

Essayez-le en ligne!

Prend le tableau comme argument gauche et la taille de bloc comme argument droit.

Utilise un crochet dyadique et l' adverbe infixe avec un argument négatif, ce qui fait ce que nous voulons par définition.

Remarque: Le type de retour doit être encadré car J n'autorise que les tables d'éléments de taille égale.

Japt , 2 octets

òV

Essayez-le en ligne!

PHP , 45 octets

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

Essayez-le en ligne!

Java 10, 106 80 octets

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

Imprime les morceaux sans délimiteur.

Essayez-le en ligne.

106 octets:

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

Retourne en fait une liste de listes.

Essayez-le en ligne.

Explication:

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 octets

{(0N,x)#y}

Essayez-le en ligne!

Rubis , 25 octets

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

Essayez-le en ligne!

Si nous pouvons renvoyer des énumérateurs au lieu de tableaux, cela devient simplement:

Rubis , 21 octets

->n,a{a.each_slice n}

Essayez-le en ligne!

PicoLisp , 75 74 octets

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

Essayez-le en ligne!

Noix de coco , 8 octets

groupsof

Essayez-le en ligne!

V , 6 octets

òÀf,r

Essayez-le en ligne!

Hexdump:

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

Explication:

ò           " 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 octets

#(partition %)

builtins je suppose

Haskell , 26 octets

import Data.Lists
chunksOf

Voici une version plus intéressante, avec juste quelques octets de plus (merci à nimi pour cinq octets dans chaque solution):

Haskell , 31 octets

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

Essayez-le en ligne!

PowerShell , 67 65 octets

-2 octets merci AdmBorkBork

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

Essayez-le en ligne!

Gelée , 1 octet

s

Essayez-le en ligne!

Bien que l'imprimante donne l'impression que les séparations à un seul élément ne sont pas regroupées dans des listes, elles le sont en réalité.