如何在多个阵列上使用Fisher-Yates Shuffle？

Question

I'm trying to generate a bridge deal, four players, which get 13 (randomized) cards each.

I figured i would just start with declaring some variables eg the suits, a deck containing the suits, and the players hands:

var deal = function() {
    var spades   = ['A', 'K', 'Q', 'J', 'T', 9, 8, 7, 6, 5, 4, 3, 2];
    var hearts   = ['A', 'K', 'Q', 'J', 'T', 9, 8, 7, 6, 5, 4, 3, 2];
    var diamonds = ['A', 'K', 'Q', 'J', 'T', 9, 8, 7, 6, 5, 4, 3, 2];
    var clubs    = ['A', 'K', 'Q', 'J', 'T', 9, 8, 7, 6, 5, 4, 3, 2];

    var deck = [spades, hearts, diamonds, clubs];

    //Next to do: get 13 random cards dealt to each player
    var northHand = [ [], [], [], [] ];
    var eastHand  = [ [], [], [], [] ];
    var southHand = [ [], [], [], [] ];
    var westHand  = [ [], [], [], [] ];


}

Then i came across this shuffle function based on the fisher-yates algorithm:

function shuffle(array) {
  var m = array.length, t, i;

  // While there remain elements to shuffle…
  while (m) {

    // Pick a remaining element…
    i = Math.floor(Math.random() * m--);

    // And swap it with the current element.
    t = array[m];
    array[m] = array[i];
    array[i] = t;
  }

  return array;
}

The problem is that my programming (and/or logical) skills, are too poor for finding out how i could apply this algoritm on my scenario, dealing with multiple arrays.

Is this a good start for my problem, or is there a better approach i should look into?

Answer 1

I think your problem is the way you're building your deck. That's fine for sequential, logical access. You want suits mixed up as well as cards in a suit. You'd be better off with a 52-element array containing either strings 2H , QD , etc or simple objects {'Suit': 'Hearts', 'Value': 'Q'}

Once you've got a single array, the shuffle implementation becomes trivial using the code you've provided

Once you've shuffled you can either give player 1 cards 0-12, 2 13-25, etc or you can "deal" them properly so player 1 gets cards from positions 0, 4, 6, 12, etc...

Instead of naming 4 arrays N/E/S/W, use a 2d array so you can access it easily.

Then loop through the cards something like...

for(var i=0;i<52;i++) {
    Pos = i % 4;
    Hands[Pos].push(Deck[i]);
}

Assuming your hands are defined as

var Hands = [ [], [], [], [] ];

You should be good to go (untested)

Answer 2

Suit and value of each card is significant, so you need to keep them together. A card is probably better represented as {suit: 'spades', value: 'A'} .

I would build the deck along these lines:

var deck = [];

var suits = ['spade', 'heart', 'club', 'diamond'];

var values = ['A', 'K', 'Q', 'J', '10', '9', '8', '7', '6', '5', '4', '3', '2'];

for (var sIdx = 0; sIdx < suits.length; sIdx++) {
    for (var vIdx = 0; vIdx < values.length; vIdx++) {
        deck.push({suit: suits[sIdx], value: values[vIdx]});
    }
}

Then use your shuffle to shuffle the deck, and slice() to split it into 4 hands of 13.

The approach you outlined (with a separate array for each suit) can totally work. But I feel this is one of those cases where making the data representation map cleanly to the thing being represented makes just about every operation you want to perform on the data easier.

Answer 3

First you need a way to distinguish between every card. Let's say all the cards are numbered from 0 to 51 as follows:

1. Hearts are numbered from 0 to 12.
2. Spades are numbered from 13 to 25.
3. Diamonds are numbered from 26 to 38.
4. Clubs are numbered from 39 to 51.

In each suit the cards are numbered as follows:

1. Ace to 10 are numbered from 0 to 9.
2. Jack is 10.
3. Queen is 11.
4. King is 12.

Note that these numbers are just used to identify the cards. They don't represent the values of any card. Hence they can be used for all card games. Given a number you can find its suit and rank as follows:

var suits = ["Hearts","Spades","Diamonds","Clubs"];

var ranks = ["Ace","2","3","4","5","6","7","8","9","10","Jack","Queen","King"];

function getSuite(card) {
    return suits[Math.floor(card / 13)];
}

function getRank(card) {
    return ranks[card % 13];
}

Now your deck is simply an array of numbers from 0 to 51. Hence you can use Fischer Yates to shuffle it:

function deal() {
    var deck = shuffle(range(0, 51));

    var northHand = deck.slice(0, 13);
    var eastHand  = deck.slice(13, 26);
    var southHand = deck.slice(26, 39);
    var westHand  = deck.slice(39, 52);
}

function range(from, to) {
    if (from > to) return [];
    else return [from].concat(range(from + 1, to));
}

That's all.

Answer 4

You cannot use Fisher-Yates shuffle here, since you want to move values randomly between arrays. This should do it and still be random:

var hands = [northHand, eastHand, southHand, westHand];
var numberofcards = 4*13;
for (var i=0; i<4; i++) {
    for (var j=0; j<13; j++) {
        // draw card:
        var card = Math.floor(Math.random() * numberofcards--);
        // check which card it is:
        for (var suit=4; suit-- && card > deck[suit].length; )
            card -= deck[suit].length;
        // remove from deck and assign to player
        hands[i][suit].push(deck[suit].splice(card, 1)[0]);
    }
}

However, representing a single card as an object with suit and value will probably be easier to deal with - you then can also use the shuffle method before slicing the deck into four parts.