有没有比这更简单的方法来计算扑克中的顺子？
我有一个算法来计算德州扑克中玩家的牌是否为顺子。它工作得很好，但我想知道是否有一种更简单的方法来做到这一点，不涉及数组/字符串转换等。
这是我所拥有的简化版本。假设玩家拿到的手牌是由 52 个元素组成的牌值数组：
var rawHand = [1,0,0,0,0,0,0,0,0,0,0,0,0, //clubs
0,0,0,0,0,0,0,0,0,0,0,0,0, //diamonds
0,1,1,0,1,0,0,0,0,0,0,0,0, //hearts
0,0,0,1,0,0,0,0,1,0,0,0,0];//spades
1 代表该牌值槽中的一张牌。上面的手牌有 2 梅花、无方块、3 红心、4 红心、6 红心、5 黑桃和 10 黑桃。现在我看着它找到一个直的。
var suits = []; //array to hold representations of each suit
for (var i=0; i<4; i++) {
var index = i*13;
// commenting this line as I removed the rest of its use to simplifyy example
//var hasAce = (rawHand[i+13]);
//get a "suited" slice of the rawHand, convert it to a string representation
//of a binary number, then parse the result as an integer and assign it to
//an element of the "suits" array
suits[i] = parseInt(rawHand.slice(index,index+13).join(""),2);
}
// OR the suits
var result = suits[0] | suits[1] | suits[2] | suits[3];
// Store the result in a string for later iteration to determine
// whether straight exists and return the top value of that straight
// if it exists; we will need to determine if there is an ace in the hand
// for purposes of reporting a "low ace" straight (i.e., a "wheel"),
// but that is left out in this example
var resultString = result.toString(2);
//Show the result for the purposes of this example
alert("Result: " + resultString);
这里的技巧是对各种花色进行“或”运算，这样就只有一个 2 比 A 的表示形式。我认为必须有一种更简单的方法来做到这一点是错误的吗？
I have an algorithm for calculating whether a player's hand holds a straight in Texas Hold'em. It works fine, but I wonder if there is a simpler way to do it that does not involve array/string conversions, etc.
Here's a simplified version of what I have. Say the player is dealt a hand that is a 52-element array of card values:
var rawHand = [1,0,0,0,0,0,0,0,0,0,0,0,0, //clubs
0,0,0,0,0,0,0,0,0,0,0,0,0, //diamonds
0,1,1,0,1,0,0,0,0,0,0,0,0, //hearts
0,0,0,1,0,0,0,0,1,0,0,0,0];//spades
A 1 represents a card in that value slot. The above hand has a 2-clubs, no diamonds, a 3-hearts, 4-hearts, and 6-hearts, a 5-spades and a 10-spades. Now I look at it to find a straight.
var suits = []; //array to hold representations of each suit
for (var i=0; i<4; i++) {
var index = i*13;
// commenting this line as I removed the rest of its use to simplifyy example
//var hasAce = (rawHand[i+13]);
//get a "suited" slice of the rawHand, convert it to a string representation
//of a binary number, then parse the result as an integer and assign it to
//an element of the "suits" array
suits[i] = parseInt(rawHand.slice(index,index+13).join(""),2);
}
// OR the suits
var result = suits[0] | suits[1] | suits[2] | suits[3];
// Store the result in a string for later iteration to determine
// whether straight exists and return the top value of that straight
// if it exists; we will need to determine if there is an ace in the hand
// for purposes of reporting a "low ace" straight (i.e., a "wheel"),
// but that is left out in this example
var resultString = result.toString(2);
//Show the result for the purposes of this example
alert("Result: " + resultString);
The trick here is to OR the various suits so there is just one 2-to-Ace representation. Am I wrong in thinking there must be a simpler way to do this?
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（7）
好吧，顺子必须包含 5 或 10，因此如果这手牌没有其中之一或其他，您可以先将其扔掉：
Well, a straight must include a 5 or a 10, so you can start by throwing out the hand if it doesn't have one or other:
您可以使用整数值作为牌值的位字段，A 获得低位和高位两个位置。然后，您将按位结束与十个可能的直线进行比较。
或者使用 for 循环并检查五个连续的数字 - 实际上它们都是相同的。
You can use an integer value as a bitfield for the card values, ace gets two spots low and high. Then you compare with bitwise end against the ten possible straights.
Or use a for-loop and check for five consecutive numbers - effectively it's all the same.
这个问题引起了我的兴趣。我最终太过分了。并写了一个网页来计算任意手牌。它可能不是最有效的，但它确实有效。我仅使用 JavaScript（无 jQuery）完成此操作。这是一个 演示 http://jsbin.com/izuto4/2/
下面是代码：
This question got me interested. I ended up going way overboard. And wrote a web page to calculate any hand. Its probably not the most efficient but it does work. I did this with just JavaScript (No jQuery). Here is a demo http://jsbin.com/izuto4/2/
Below is the code:
不，这就是最简单的事情。我不久前研究过扑克手牌评估，我认为最快的方法是使用像你这样的方法。请参阅此网站中的第一个结果。它使用按位运算来计算手。
编辑：第一个结果，我的意思是“Pokersource Poker-Eval Evaluator”。
No, that's about as simple as it gets. I looked into poker hand evaluation a while ago, and I think the fastest way uses an approach like yours. See the first result in this site. It uses bitwise operations to compute hands.
EDIT: By first result, I mean "Pokersource Poker-Eval Evaluator".
为什么不按等级对卡片进行排序，然后检查每个等级是否比前一个等级多一级。 “ranks”是一个长度为 5 的数组，其中 ACE = 1、2 = 2、... J = 11、Q = 12、K = 13。
我认为这比这里介绍的其他方法更简单。
Why not sort the cards by rank, and then check that each rank is one more than the previous. "ranks" is an array of length 5 with ACE = 1, 2 = 2, ... J = 11, Q = 12, K = 13.
I think this is more simple than the other methods presented here.
您可以使用此处发布的 SpecialK 的 7 张牌和 5 张牌评估器，并要求其对牌进行排名。如果返回的等级介于 5854 和 5863（均包含）之间或介于 7453 和 7462（均包含）之间，则您的手牌（无论是 5 张牌还是 7 张牌）分别是顺子或包含顺子。
请注意，黑桃 A 表示为 0，红桃 A 表示为 1，一直到梅花二表示为 51。该算法将“添加”您的牌并在一个小表中查找排名，占用9MB 内存。它还会做更多的事情，但是嘿......
You can use SpecialK's 7-card and 5-card evaluators posted here and ask it to rank hands. If the rank that is returned is between 5854 and 5863 (both inclusive) or between 7453 and 7462 (both inclusive) then your hand, be it of 5 or 7 cards, respectively is or contains a straight.
Note the Ace of Spades is denoted by 0, the Ace of Hearts by 1, through to the Two of Clubs which is represented by 51. The algorithm will "add" up your cards and look up the rank in a small table, taking up 9MB of RAM. It will also do a lot more, but hey...
代码所做的几乎所有工作都是类型转换。如果您一开始就以位格式存储手（需要 > 32 位类型），您可以执行以下操作：
使用单行循环的等效操作将是：
这更短且更易于理解。
与按位表示法相互转换需要的代码和 CPU 时间比使用按位 OR 运算符节省的代码和 CPU 时间要多。
Almost all of the work your code does is type conversion. If you just had the hand stored in bit format to begin with(needs > 32 bit type), you could do something like:
The equivalent using a one line loop would be:
This is much shorter and easier to understand.
Converting to and from a bit-wise representation takes more code and CPU time than you save by using the bit-wise OR operator.