在扑克中分发侧底池

Question

嗨，我正在开发一个扑克应用程序，我在分发侧底池时遇到了一些问题。

主要问题是我不知道如何分配弃牌玩家的筹码(死筹码(。

现在我的代码执行以下操作：

1. 获得全押玩家的最低赌注。
2. 将其乘以下注超过该金额的玩家数量。
3. 将底池交给下注超过金额的玩家之间的获胜者。
将
4. 全押注减去以下边底池。
5. 重复数字 1，直到没有更多的花盆要分发。

当所有玩家都全力以赴时，这是有效的，但如果一个人折叠，事情就会变得棘手。

例如：

A bet(200). 
B all-in (80). 
C all-in (400). 
A folds. 
B wins the hand. 

所以第一个锅将是 B(80( + C(80(，剩下的将交给 C。

答： +0.

乙： +80.

C： +520.

显然在这里做错了什么，因为 B 有权争取 A 下注的 80 个筹码。

Answer 1

考虑每个玩家下注的第n个筹码。有资格获得该筹码的玩家是那些没有弃牌并且至少下注 n 的玩家。将筹码分配给持有最佳手牌的合格玩家。

在您的示例中：

A 200 fold
B 80  call  [best hand]
C 400 call

• 来自 A 的筹码 1-80 有 2 名符合条件的玩家(B 和 C(，B 拥有最好的手牌。所以B需要80。
• 来自 A 的筹码 81-200 有 1 名符合条件的玩家 (C(。C 需要 120。
• 来自 B 的筹码 1-80 有 2 名符合条件的玩家(B 和 C(，B 拥有最好的手牌。所以B需要80。
• 来自C的筹码1-80有2个符合条件的玩家(B和C(，B拥有最好的手牌。所以B需要80。
• 来自 C 的筹码 81-400 有 1 个符合条件的玩家 (C(。C 需要 320。

总的来说，B 需要 240，C 需要 440。

我将描述写成逐个筹码的工作，但您可以通过考虑所有未弃牌玩家的下注大小(即：在您的示例中为 80 和 400(切割的筹码范围来优化(就像我在工作示例中所做的那样(。

Answer 2

此代码应处理所有情况，并处理将筹码分发给折叠的玩家。 我猜你的代码已经完成了很长时间，但我无法在 StackOverflow 上找到在我处理这个扑克端底池问题时有意义的代码示例，所以我分享我自己的......

using System;
using System.Collections.Generic;
public class Player
{
public ulong potCommitment;
public uint handStrength;
public ulong chipsRemaining;
public bool folded = false;
public Player(ulong pc, uint hs, ulong chipsBehind, bool isFolded): this(pc, hs, chipsBehind)
{
folded = isFolded;
}
public Player(ulong pc, uint hs, ulong chipsBehind)
{
potCommitment = pc;
handStrength = hs;
chipsRemaining = chipsBehind;
}
}
public class Program
{
public static List<Player> winners = new List<Player>();
public static List<Player> players = new List<Player>();
public static void Main()
{
players.Add(new Player(200, 60, 0, true));
players.Add(new Player(80, 100, 0));
players.Add(new Player(400, 85, 0, false));

// Loop through players until no unclaimed chips in pot.
while (PotChipsRemaining(players) > 0)
PayOutWinners(CalculateAndSortWinners(players), players);
// Refund players if remaining chips in pot (bigger/folded stacks)
foreach (var player in players)
{
player.chipsRemaining += player.potCommitment;
player.potCommitment = 0;
}
Console.WriteLine($"***********************nFinal results:");
PotChipsRemaining(players);
}
public static List<Player> CalculateAndSortWinners(List<Player> playersInHand)
{
uint highHand = 0;
// Get highHand, skipping folded and empty pots
foreach (var player in players) if (player.potCommitment > 0 && !player.folded)
{
if (player.handStrength > highHand)
{
winners.Clear();
highHand = player.handStrength;
winners.Add(player);
}
else if (player.handStrength == highHand)
{
winners.Add(player);
}
}
winners.Sort((x, y) => x.potCommitment.CompareTo(y.potCommitment));
return winners;
}
public static void PayOutWinners(List<Player> winners, List<Player> playersInHand)
{
ulong collectedSidePot;
ulong currentCommitment, collectionAmount;
List<Player> paidWinners = new List<Player>();
foreach (var playerPot in winners)
{
collectedSidePot = 0;
currentCommitment = playerPot.potCommitment;
// Collect from all players who have money in pot
foreach (var player in playersInHand) if (player.potCommitment > 0)
{
collectionAmount = Math.Min(currentCommitment, player.potCommitment);
player.potCommitment -= collectionAmount;
collectedSidePot += collectionAmount;
}
int winnersToPay = 0;
Console.WriteLine($"winners.count {winners.Count}");

foreach (var player in winners) if (paidWinners.IndexOf(player) == -1) winnersToPay++;
Console.WriteLine($"collectedSidePot: {collectedSidePot}  winnersToPay: {winnersToPay}");

// Pay unpaid winners, tip dealer with remainders...
foreach (var player in winners) if (paidWinners.IndexOf(player) == -1)
{
player.chipsRemaining += collectedSidePot / (ulong)winnersToPay;
if (player.potCommitment <= 0)
{
paidWinners.Add(player);
Console.WriteLine($"Player {players.IndexOf(player)} paid out.");
}
}
}
winners.Clear();
}
// Only count potchips for unfolded players. Also prints status to Console.
public static ulong PotChipsRemaining(List<Player> playersInHand)
{
ulong tally = 0;
foreach (var player in playersInHand) if (!player.folded)
{
Console.WriteLine($"Player {players.IndexOf(player)} chips: {player.chipsRemaining}  Commitment: {player.potCommitment} tHandStrength: {player.handStrength}tFolded: {player.folded}");
tally += player.potCommitment;
}
foreach (var player in playersInHand) if (player.folded)
Console.WriteLine($"Player {players.IndexOf(player)} chips: {player.chipsRemaining}  Commitment: {player.potCommitment} tHandStrength: {player.handStrength}tFolded: {player.folded}");
return tally;
}
}

根据您的示例，我得到以下结果：

Final results:
Player A chips: 0      HandStrength: 60    Folded: True
Player B chips: 240    HandStrength: 100   Folded: False
Player C chips: 440    HandStrength: 85    Folded: False

如果您有任何问题，请告诉我。

这是小提琴，因此可以测试场景： https://dotnetfiddle.net/P0wgR5