Tonight is card game night! You are the dealer and your task is to write a program to deal the cards to the players.

Given an array of card and a number of player, you need to split the array into hand for each player.

Rules

Your program will receive an non-empty array A , as well as a non-zero positive integer n. The array should then be split into n hands, if the length of the string isn't divisible by n any leftover at the end should be distributed as evenly as possible.

• If n is equals to 1, you will need to return an array of array A
  



• If n is greater than the length of A, you will need to return every hands and an empty hand. if n = 4 and array A = [1,2,3], you should return [[1],[2],[3]] or [[1],[2],[3],[]]. You are free to handle the empty hand with empty, undefined or null.




• The array can contain any type rather than a number.




• You should not change order (or direction) of any item from left to right. For example if n = 2 and A= [1,2,3]. Any result rather than [[1,3],[2]] will be invalid.

Test Cases

n   A               Output



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

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

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

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

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

Demo

def deal(cards, n):

	i = 0

	players = [[] for _ in range(n)]

	for card in cards:

		players[i % n].append(card)

		i += 1

	return players



hands = deal([1,2,3,4,5,6], 2)



print(hands)

Try it online!

This is code-golf, so you the shortest bytes of each language will be the winner.

Inspired from Create chunks from array by chau giang

R, 46 25 bytes

function(A,n)split(A,1:n)

Try it online!

splits A into groups defined by 1:n, recycling 1:n until it matches length with A.

Python 2, 37 bytes

Code:

lambda x,n:[x[i::n]for i in range(n)]

Try it online!

Perl 6, 33 24 bytes

->b{*.classify:{$++%b}}

Try it online!

Anonymous curried code block that takes a number and returns a Whatever lambda that takes a list and returns a list of lists. This takes the second option when given a number larger than the length of lists, e.g. f(4)([1,2,3]) returns [[1],[2],[3]]

Explanation:

->b{                  }  # Anonymous code block that takes a number

     *                    # And returns a Whatever lambda

      .classify           # That groups by

               :{$++%b}   # The index modulo the number

Japt, 2 bytes

Takes the array as the first input.

óV

Try it

Charcoal, 9 bytes

ＩＥθ✂ηιＬηθ

Try it online! Link is to verbose version of code. Takes input in the order [n, A] and outputs each value on its own line and each hand double-spaced from the previous. Explanation:

  θ         First input `n`

 Ｅ          Map over implicit range

    η       Second input `A`

   ✂        Sliced

     ι      Starting at current index

      Ｌη    Ending at length of `A`

        θ   Taking every `n`th element

Ｉ           Cast to string

            Implicitly print

Wolfram Language (Mathematica), 28 bytes

(s=#;GatherBy[#2,#~Mod~s&])&

Try it online!