¡Esta noche es la noche del juego de cartas! Usted es el distribuidor y su tarea es escribir un programa para repartir las cartas a los jugadores.

Dado un conjunto de cartas y la cantidad de jugadores, debes dividir el conjunto de cartas en una mano para cada jugador.

Reglas

Su programa recibirá una matriz no vacía A, así como un entero positivo no cero n. La matriz debería dividirse en nmanos. Si la longitud de la cadena no es divisible por nlas cartas sobrantes al final, debe distribuirse de la manera más uniforme posible.

• Si n==1, tendrá que devolver una matriz de matriz con Asu único elemento

• Si nes mayor que la longitud de A, deberá devolver cada mano y una mano vacía. si n = 4y array A = [1,2,3], debe regresar [[1],[2],[3]]o [[1],[2],[3],[]]. Usted es libre de manejar la mano vacía con vacía, indefinida o nula.

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

• No debe cambiar el orden de la matriz mientras trata. Por ejemplo if n = 2y A= [1,2,3], cualquier resultado en lugar de [[1,3],[2]]será inválido.

Casos de prueba

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 demostración

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)

Pruébalo en línea!

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

Inspirado en Crear fragmentos de matriz por chau giang

05AB1E , 3 1 byte

Guardado 2 bytes gracias a Adnan

ι

Pruébalo en línea! o como un conjunto de pruebas

Explicación

ι  # uninterleave

Hace exactamente lo que pide el desafío

R , 46 25 bytes

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

Pruébalo en línea!

splits Aen grupos definidos por 1:n, reciclando 1:nhasta que coincida con la longitud A.

Perl 6 , 33 24 bytes

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

Pruébalo en línea!

Bloque de código curioso anónimo que toma un número y devuelve un Lambda Cualquiera que tome una lista y devuelva una lista de listas. Esta toma la segunda opción cuando se le da un número mayor que la longitud de las listas, por ejemplo, f(4)([1,2,3])devuelve[[1],[2],[3]]

Explicación:

->\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&])&

Pruébalo en línea!

Japt, 2 bytes

Toma la matriz como la primera entrada.

óV

Intentalo

Python 2 , 37 bytes

Código:

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

Pruébalo en línea!

Jalea , 6 2 bytes

sZ

Pruébalo en línea!

Gracias a @JonathanAllan por guardar 4 bytes

J , 13 , 11 , 10 , 9 bytes

(|#\)</.]

Pruébalo en línea!

cómo (explicación previa, fundamentalmente la misma)

] </.~ (| #\)
  </.~          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

Carbón de leña , 9 bytes

ＩＥθ✂ηιＬηθ

Pruébalo en línea! El enlace es a la versión detallada del código. Toma la entrada en el orden [n, A]y genera cada valor en su propia línea y cada mano a doble espacio de la anterior. Explicación:

  θ         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.Listses de las listas de bibliotecas de terceros , que no está en Stackage y, por lo tanto, no aparecerá en Hoogle.

Kotlin , 53 51 49 bytes

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

La antigua solución incorrecta solo funcionaba para los divisores de la longitud de la matriz. Estoy seguro de que esto se puede jugar golf.

Pruébalo en línea!

JavaScript (Node.js) , 51 bytes

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

Pruébalo en línea!

JavaScript (Node.js) , 53 bytes

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

Pruébalo en línea!

APL + WIN 26 o 31 bytes

Si las manos individuales se pueden representar como columnas de una matriz 2D, entonces 26 bytes si una matriz de matrices agrega 5 bytes.

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

Pruébalo en línea! cortesía de Dyalog Classic

o

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

Pruébalo en línea! Cortesía de Dyalog Classic.

Explicación:

un aviso ← ⎕ para una variedad de tarjetas

((l ← ⌈ (⍴a) ÷ n) × n ← ⎕) ↑ solicitud de número entero, rellene a con ceros a las manos pares

(l, n) ⍴ crea una matriz 2D con cada columna que representa cada mano

⊂ [1] si es necesario convertir a vector anidado - matriz de matrices 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

Pruébalo

MathGolf , 9 bytes

\ô_í\%q╞;

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Gracias Olivier Grégoire por la lambda y mejor incremento al iterar.

Ruby, 81 bytes

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

Pruébalo en línea

PHP ,85 83 82 bytes

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

Pruébalo en línea!

Esta no será la entrada más corta, pero pensé que sería divertido intentar hacerlo utilizando las funciones integradas de la matriz de PHP. Resultado: largo.

Salida

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,#}&

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 43 bytes

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

Pruébalo en línea!

C (gcc), 5 bytes

El indicador del compilador -Df=(se requiere espacio inicial) cumple la especificación. f(n_cards,n_hands,card_ptr)evalúa a un puntero a una lista de manos.

Explicación

En C, es una práctica común implementar listas de listas como una sola matriz intercalada, cuando el número de listas permanece constante pero todas las listas se pueden extender. Por ejemplo, en este caso de repartir cartas, es más común agregar más cartas a cada mano que agregar más manos, por lo que sería razonable implementar una lista de manos como una lista intercalada. Casualmente, el "mazo" es una lista de este tipo y, por lo tanto, devolvemos el parámetro sin modificar.

Este desafío probablemente debería haber sido sandboxed.

Perl 5 -la , 66 56 bytes

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

Pruébalo en línea!