如何在 Javascript 中使用递归来找到最好的德州扑克？

Question

我试图想出一种快速的方法来评估一手扑克牌，该手牌由通常的五张公共牌和两张每个玩家独有的牌组成，因此总共七张牌。

我读到了article 的一篇关于扑克评估器算法的文章，该算法使用递归首先将牌的数量从七张减少到五张，然后从中计算结果。

我在大学时不得不使用递归几次，但我看不出它如何适用于这种情况。

据我了解，这家伙是在说：我们计算每七手组合的最佳五张牌结果，因此这意味着整个评估器逻辑将包含在此递归循环中，但我不看看 a) 这个递归循环如何最终达到它的基本情况，以及 b) 如何实现它。

任何帮助将不胜感激！

源代码

var suits = ['Clubs', 'Spades', 'Hearts', 'Diamonds'];
var ranks = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'Jack', 'Queen', 'King', 'Ace'];
var combinations = ['Royal Flush', 'Straight Flush', 'Four of a Kind', 'Full House', 'Flush', 'Straight', 'Three of a Kind', 'Two Pair', 'One Pair'];
var deck = [];
var players = [new Player(), new Player()];
var table = [];

function Player()  {
    this.hand = [];
    this.result;
}

function Card(suit, rank)   {
    this.suit = suit;
    this.rank = rank;
    this.name = rank + ' of ' + suit;
}


function initDeck() {
    deck = [];

    for(var i = 0; i < 4; i++)   {
        for(var j = 0; j < 13; j++)   {
            deck.push(new Card(suits[i], ranks[j]));
        }
    }

}

function drawCard() {
    var randNumber = Math.floor(Math.random() * deck.length);
    var drawnCard = deck[randNumber];
    deck.splice(randNumber, 1);

    return drawnCard;
}


function dealCards()    {
    for(var i = 0; i < 2; i++)   {
        for(var j = 0; j < players.length; j++)   {
            var drawnCard = drawCard();
            players[j].hand.push(drawnCard);
        }
    }
}

function flop() {
    for(var i = 0; i < 3; i++)   {
        var drawnCard = drawCard();
        table.push(drawnCard);
    }
}

function turn()    {
    var drawnCard = drawCard();
    table.push(drawnCard);
}

function river()    {
    var drawnCard = drawCard();
    table.push(drawnCard);
}

function showDown() {
    for(var i = 0; i < players.length; i++)   {        

        evaluate(i);
        document.write("<br>");   

    }

}

function evaluate(player)  {
    var totalHand = players[player].hand.concat(table);


}


initDeck();
dealCards();
document.write("Player 1: " + players[0].hand[0].name + ' and ' + players[0].hand[1].name + '<br>');
document.write("Player 2: " + players[1].hand[0].name + ' and ' + players[1].hand[1].name + '<br><br>');
flop();
document.write("Flop: " + table[0].name + ', ' + table[1].name + ' and ' + table[2].name + '<br>');
turn();
document.write("Turn: " + table[0].name + ', ' + table[1].name + ', ' + table[2].name + ' and ' + table[3].name + '<br>');
river();
document.write("River: " + table[0].name + ', ' + table[1].name + ', ' + table[2].name + ', ' + table[3].name + ' and ' + table[4].name + '<br>');
showDown();

Answer 1

我不知道递归，但你可以用 for 循环强制它：

var suits = ['Clubs', 'Spades', 'Hearts', 'Diamonds'];
var ranks = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'Jack', 'Queen', 'King', 'Ace'];
var deck = [];
var allSets = [];
var combinations = [{
  name: 'Straight flush',
  test: function(cards) {
    //All must have same suit
    if (cards.some(function(card) {
        return card.suit != cards[0].suit;
      })) {
      return false;
    }
    //Is consecutive
    var arr = cards
      .map(function(card) {
        return card.rank;
      })
      .sort(function(a, b) {
        return a - b;
      });
    return Math.abs(arr[0] - arr[arr.length - 1]) <= 4;
  },
  success: function() {
    //return a score modifier
    return 100;
  }
}];
//Card class
var Card = (function() {
  function Card(suit, rank) {
    this.suit = suit;
    this.rank = rank;
    this.id = Card._id++;
  }
  return Card;
}());
Card._id = 0;
//Build deck
for (var suit = 0; suit < suits.length; suit++) {
  for (var rank = 0; rank < ranks.length; rank++) {
    deck.push(new Card(suit, rank));
  }
}
//Find sets
for (var index0 = 0; index0 < deck.length; index0++) {
  for (var index1 = index0 + 1; index1 < deck.length; index1++) {
    for (var index2 = index1 + 1; index2 < deck.length; index2++) {
      for (var index3 = index2 + 1; index3 < deck.length; index3++) {
        for (var index4 = index3 + 1; index4 < deck.length; index4++) {
          var set = [deck[index0], deck[index1], deck[index2], deck[index3], deck[index4]];
          var score = 0;
          for (var index = 0; index < set.length; index++) {
            score += set[index].rank;
          }
          for (var combinationIndex = 0; combinationIndex < combinations.length; combinationIndex++) {
            var combination = combinations[combinationIndex];
            if (combination.test(set)) {
              score += combination.success();
              break;
            }
          }
          allSets.push({
            set: set.slice(0),
            score: score
          });
        }
      }
    }
  }
}
//Sort sets
allSets = allSets
  .sort(function(a, b) {
    return b.score - a.score;
  });
//Display 100 best sets
console.log("100 best:", allSets
  .slice(0, 100).map(function(a) {
    a.set = a.set
      .map(function(b) {
        return suits[b.suit] + "" + ranks[b.rank];
      })
      .join(", ");
    return a;
  }));

只需使用您希望运行的任何测试扩展组合列表即可。