Ce soir, c'est la nuit du jeu de cartes! Vous êtes le croupier et votre tâche est d'écrire un programme pour distribuer les cartes aux joueurs.

Étant donné un tableau de cartes et le nombre de joueurs, vous devez diviser le tableau de cartes en une main pour chaque joueur.

Règles

Votre programme recevra un tableau non vide A, ainsi qu'un entier positif non nul n. Le tableau doit ensuite être divisé en nmains. Si la longueur de la chaîne n'est pas divisible par nles restes, les cartes à la fin doivent être réparties aussi uniformément que possible.

• Si n==1, vous devrez retourner un tableau de tableau avec Acomme seul élément

• Si nest supérieur à la longueur de A, vous devrez retourner chaque main et une main vide. si n = 4et array A = [1,2,3], vous devez retourner [[1],[2],[3]]ou [[1],[2],[3],[]]. Vous êtes libre de gérer la main vide avec vide, indéfini ou nul.

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

• Vous ne devez pas modifier l'ordre du tableau pendant le traitement. Par exemple, if n = 2et A= [1,2,3], tout résultat plutôt que [[1,3],[2]]sera invalide.

Cas de test

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

Programme de démonstration

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)

Essayez-le en ligne!

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

Inspiré de Create chunks from array par chau giang

05AB1E , 3 1 octet

Enregistré 2 octets grâce à Adnan

ι

Essayez-le en ligne! ou comme suite de tests

Explication

ι  # uninterleave

Fait exactement ce que le défi demande

R , 46 25 octets

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

Essayez-le en ligne!

splits Aen groupes définis par 1:n, en recyclant 1:njusqu'à ce qu'il corresponde à la longueur A.

Perl 6 , 33 24 octets

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

Essayez-le en ligne!

Bloc de code curry anonyme qui prend un nombre et renvoie un lambda Whats qui prend une liste et retourne une liste de listes. Cela prend la deuxième option quand on lui donne un nombre supérieur à la longueur des listes, par exemple les f(4)([1,2,3])retours[[1],[2],[3]]

Explication:

->\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 octets

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

Essayez-le en ligne!

Japt, 2 octets

Prend le tableau comme première entrée.

óV

Essayez-le

Python 2 , 37 octets

Code:

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

Essayez-le en ligne!

Gelée , 6 2 octets

sZ

Essayez-le en ligne!

Merci à @JonathanAllan d'avoir économisé 4 octets

J , 13 , 11 , 10 , 9 octets

(|#\)</.]

Essayez-le en ligne!

comment (explication précédente, fondamentalement la même)

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

Fusain , 9 octets

ＩＥθ✂ηιＬηθ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend l'entrée dans l'ordre [n, A]et sort chaque valeur sur sa propre ligne et chaque main à double interligne de la précédente. Explication:

  θ         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 octets

import Data.Lists
(transpose.).chunksOf

Remarque: Data.Listsprovient des listes de bibliothèques tierces , qui ne sont pas sur Stackage et n'apparaîtront donc pas sur Hoogle.

Kotlin , 53 51 49 octets

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

L'ancienne solution incorrecte ne fonctionnait que pour les diviseurs de la longueur du tableau. Je suis certain que cela peut être minimisé.

Essayez-le en ligne!

JavaScript (Node.js) , 51 octets

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

Essayez-le en ligne!

JavaScript (Node.js) , 53 octets

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

Essayez-le en ligne!

APL + WIN 26 ou 31 octets

Si des mains individuelles peuvent être représentées comme des colonnes d'une matrice 2D, 26 octets si un tableau de tableaux ajoute 5 octets.

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

Essayez-le en ligne! gracieuseté de Dyalog Classic

ou

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

Essayez-le en ligne! Gracieuseté de Dyalog Classic

Explication:

une invite ← ⎕ pour le tableau de cartes

((l ← ⌈ (⍴a) ÷ n) × n ← ⎕) ↑ invite pour un entier, remplissez a avec des zéros pour donner des mains paires

(l, n) ⍴ créer une matrice 2D avec chaque colonne représentant chaque main

⊂ [1] si nécessaire, convertir en vecteur imbriqué - tableau APL de tableaux

TSQL, 44 octets

-- @       : 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

Essaye le

MathGolf , 9 octets

\ô_í\%q╞;

Essayez-le en ligne!

Explication

\           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 octets

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

Essayez-le en ligne!

Merci Olivier Grégoire pour la lambda et pour une meilleure incrémentation lors de l'itération.

Rubis, 81 octets

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

Essayez-le en ligne

PHP ,85 83 82 octets

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

Essayez-le en ligne!

Ce ne sera pas l'entrée la plus courte, mais j'ai pensé que ce serait amusant d'essayer de le faire en utilisant les fonctions intégrées des fonctions de tableau PHP. Résultat: long.

Production

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 octets

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

Essayez-le en ligne!

C # (Visual C # Interactive Compiler) , 43 octets

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

Essayez-le en ligne!

C (gcc), 5 octets

L'indicateur du compilateur -Df=(espace principal requis) remplit la spécification. f(n_cards,n_hands,card_ptr)évalue un pointeur sur une liste de mains.

Explication

En C, il est courant d'implémenter des listes de listes comme un seul tableau entrelacé, lorsque le nombre de listes reste constant mais que toutes les listes peuvent être étendues. Par exemple, dans ce cas de distribution de cartes, il est plus courant d'ajouter plus de cartes à chaque main que plus de mains à ajouter, il serait donc raisonnable d'implémenter une liste de mains en tant que liste entrelacée. Par coïncidence, le "deck" est une telle liste, et donc nous renvoyons le paramètre sans modification.

Ce défi aurait probablement dû être mis en bac à sable.

Perl 5 -la , 66 56 octets

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

Essayez-le en ligne!