Hoje é noite de jogo de cartas! Você é o dealer e sua tarefa é escrever um programa para distribuir as cartas aos jogadores.

Dada uma série de cartas e o número de jogadores, você precisa dividir a série de cartas em uma mão para cada jogador.

Regras

Seu programa receberá uma matriz não vazia A, além de um número inteiro positivo diferente de zero n. A matriz deve ser dividida em nmãos. Se o comprimento da string não for divisível por nquaisquer cartões restantes no final, ele deve ser distribuído da maneira mais uniforme possível.

• Se n==1, você precisará retornar uma matriz de matriz com Aesse elemento.

• Se nfor maior que o comprimento de A, você precisará retornar todas as mãos e uma mão vazia. se n = 4e array A = [1,2,3], você deve retornar [[1],[2],[3]]ou [[1],[2],[3],[]]. Você é livre para lidar com a mão vazia com vazio, indefinido ou nulo.

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

• Você não deve alterar a ordem da matriz ao negociar. Por exemplo if n = 2e A= [1,2,3], qualquer resultado e não [[1,3],[2]]será inválido.

Casos de teste

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

Programa de demonstração

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)

Experimente online!

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

Inspirado em Criar pedaços da matriz por chau giang

05AB1E , 3 1 byte

Economizou 2 bytes graças a Adnan

ι

Experimente online! ou como um conjunto de testes

Explicação

ι  # uninterleave

Faz exatamente o que o desafio pede

R , 46 bytes 25

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

Experimente online!

splits Aem grupos definidos por 1:n, reciclando 1:naté que corresponda ao comprimento com A.

Perl 6 , 33 24 bytes

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

Experimente online!

Bloco de código ao curry anônimo que pega um número e retorna um lambda Whatever que pega uma lista e retorna uma lista de listas. Isso pega a segunda opção quando recebe um número maior que o tamanho das listas, por exemplo, f(4)([1,2,3])retorna[[1],[2],[3]]

Explicação:

->\b{                  }  # Anonymous code block that takes a number
     *                    # And returns a Whatever lambda
      .classify           # That groups by
               :{$++%b}   # The index modulo the number

Wolfram Language (Mathematica) , 28 bytes

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

Experimente online!

Japonês, 2 bytes

Toma o array como a primeira entrada.

óV

Tente

Python 2 , 37 bytes

Código:

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

Experimente online!

Geléia , 6 2 bytes

sZ

Experimente online!

Obrigado a @ Jonathanon Allan por salvar 4 bytes

J , 13 , 11 , 10 , 9 bytes

(|#\)</.]

Experimente online!

como (explicação anterior, fundamentalmente a mesma)

] </.~ (| #\)
  </.~          NB. box results of grouping
]               NB. the right arg by...
         |      NB. the remainders of dividing...
       [        NB. the left arg into...
           #\   NB. the length of each prefix of...
              ] NB. the right arg,
                NB. aka, the integers 1 thru
                NB. the length of the right arg

Carvão , 9 bytes

ＩＥθ✂ηιＬηθ

Experimente online! Link é a versão detalhada do código. Recebe entrada na ordem [n, A]e gera cada valor em sua própria linha e cada ponteiro com espaçamento duplo do anterior. Explicação:

  θ         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

Haskell , 39 bytes

import Data.Lists
(transpose.).chunksOf

Nota: Data.Listsé das listas de bibliotecas de terceiros , que não estão no Stackage e, portanto, não serão exibidas no Hoogle.

Kotlin , 53 51 49 bytes

{a,n->(0..n-1).map{a.slice(it..a.size-1 step n)}}

A solução antiga e incorreta funcionava apenas para divisores do comprimento da matriz. Estou certo de que isso pode ser jogado para baixo.

Experimente online!

JavaScript (Node.js) , 51 bytes

A=>n=>A.map((x,i)=>e[i%=n]=[...e[i]||[],x],e=[])&&e

Experimente online!

JavaScript (Node.js) , 53 bytes

A=>n=>g=(i=n)=>i?[...g(--i),A.filter(_=>i--%n==0)]:[]

Experimente online!

APL + WIN 26 ou 31 bytes

Se mãos individuais puderem ser representadas como colunas de uma matriz 2D, 26 bytes se uma matriz de matrizes adicionará 5 bytes.

(l,n)⍴((l←⌈(⍴a)÷n)×n←⎕)↑a←⎕

Experimente online! cortesia do Dyalog Classic

ou

⊂[1](l,n)⍴((l←⌈(⍴a)÷n)×n←⎕)↑a←⎕

Experimente online! Cortesia de Dyalog Classic

Explicação:

um ← ⎕ prompt para conjunto de cartões

((l ← ⌈ ()a) ÷ n) × n ← ⎕) ↑ solicita o número inteiro, preenche a com zeros para as mãos pares

(l, n) ⍴ crie uma matriz 2D com cada coluna representando cada mão

⊂ [1] se necessário converter para vetor aninhado - matriz de matrizes APL

TSQL, 44 bytes

-- @       : table containing the input 
-- column c: value of the card, 
-- column a: position on the card in the deck
-- @n      : number of players

DECLARE @ table(a int identity(0,1), c varchar(9))
DECLARE @n int = 4

INSERT @ values('1a'),('2c'),('3e'),('4g'),('5i'),('6k')

SELECT string_agg(c,',')FROM @ GROUP BY a%@n

Experimente

MathGolf , 9 bytes

\ô_í\%q╞;

Experimente online!

Explicação

\           swap top elements (pops both input onto stack)
 ô          start block of length 6
  _         duplicate TOS (will duplicate the list)
   í        get total number of iterations of for loop (the other input)
    \       swap top elements
     %      modulo (picks every n:th item of the list
      q     print without newline
       ╞    discard from left of string/array (makes the next player pick cards starting with the next in the deck)
        ;   discard TOS (removes some junk in the end)

Java (JDK) , 90 bytes

A->n->{var o="";for(int h=0,i;h<n;o+="\n")for(i=h++;i<A.length;i+=n)o+=" "+A[i];return o;}

Experimente online!

Agradecemos a Olivier Grégoire pela lambda e melhor incremento durante a iteração.

Ruby, 81 bytes

def s a,n;a.each_with_index.inject(([[]]*n).map(&:dup)){|b,(c,d)|b[d%n]<<c;b};end

Experimente Online

PHP ,85 83 82 bytes

function($a,$n){while($x<$n)$c[]=array_column(array_chunk($a,$n),+$x++);return$c;}

Experimente online!

Essa não será a entrada mais curta, mas achei que seria divertido tentar e fazer isso usando os recursos da função de matriz PHP. Resultado: longo.

Resultado

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],[]]
5   ["9C","QD","2S","4H","6D","AS","9D","TH","5C"]  [["9C","AS"],["QD","9D"],["2S","TH"],["4H","5C"],["6D"]]

Wolfram Language (Mathematica) , 25 bytes

#2[[i;;;;#]]~Table~{i,#}&

Experimente online!

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

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

Experimente online!

C (gcc), 5 bytes

O sinalizador do compilador -Df=(necessário espaço inicial) atende às especificações. f(n_cards,n_hands,card_ptr)avalia para um ponteiro para uma lista de mãos.

Explicação

Em C, é prática comum implementar listas de listas como uma única matriz intercalada, quando o número de listas permanece constante, mas todas as listas podem ser estendidas. Por exemplo, neste caso de cartas de distribuição, é mais comum que mais cartas sejam adicionadas a cada mão do que mais mãos a serem adicionadas, portanto, seria razoável implementar uma lista de mãos como uma lista intercalada. Coincidentemente, o "deck" é uma lista e, portanto, retornamos o parâmetro sem modificação.

Esse desafio provavelmente deveria ter sido protegido.

Perl 5 -la , 66 56 bytes

$,=<>;map{push@$_,shift@F}1..$,while@F;say"@$_"for 1..$,

Experimente online!