確定不會產生副作用盆撲克中獎金額

Question

我試圖運行一個撲克模擬和具有約牌桌

• 每個球員多少促成了鍋下面的數據
• 一個「手得分」（翻牌後）爲每個玩家（即，如果player[0].score == player[1].score，他們並列）

我被困計算每個球員都應該有多少，而不需要創建sidepots和他們每個人分配的玩家獲勝。

例如，

player[0].contributed = 100 
player[1].contributed = 80 
player[2].contributed = 20 

player[0].score = 10 
player[1].score = 2 
player[2].score = 10 

total_pot = 200; 

在這個例子中，我需要先返回player[0] 20回，並從盆中取出呢？

而且，由於player[0]和player[2]已經並列第一點， 和player[1]已經失去，如果鍋被劃分爲：

player[0].received = 170 
player[1].received = 0 
player[2].received = 30 

而隨後，如果player[1]贏了，應在鍋內被劃分：

player[0].received = 20 
player[1].received = 180 
player[2].received = 0 

Answer 1

按分數降序排序第一，所以你會用兩組結束： {0，2}，{1}。

然後，按照它們貢獻率上升的順序排序每個組： {2（20），0（100）}，{1（80）}。

現在，劃分鍋的順序：

1. 首先，您需要（最大）20遠離每個球員的貢獻，創造了第一桶金。並且將它均勻地分爲2和0.第一個鍋將是（20 + 20 + 20 = 60。因此0和2都將被給出30）。之後，第一名玩家贏得獎金，並且剩下：{0（80）}，{1（60）}。現在，你將從每個玩家的貢獻中抽取（最多）80，以創建下一個底池（80 + 60 = 140）。並將它賦予0（不需要劃分，因爲頂級組中不再有多於一個，所以0會得到整個140）。您將剩下：{1（0）}。

2. 沒有更多的貢獻，所以你完成了。

所以，在你的例子總，0將接受170和2將獲得30

Answer 2

下面的代碼有一個非常大的數量的斷言，但要小心，因爲我沒有測試過它仔細。目前還不清楚如何處理這些奇怪的籌碼。我把它們交給了後來出現在系列中的選手。

import java.util.*; 

public class Player { 
    int contributed, score, received; 

    static void winnings(Collection<Player> players) { 
     for (Player player : players) { 
      assert player.contributed >= 0; 
      player.received = 0; 
     } 
     int potCutoff = 0; 
     while (true) { 
      int playerCount = 0; 
      int nextPotCutoff = Integer.MAX_VALUE; 
      int scoreMax = Integer.MIN_VALUE; 
      int winnerCount = 0; 
      for (Player player : players) { 
       if (player.contributed <= potCutoff) { 
        continue; 
       } 
       playerCount++; 
       assert playerCount > 0; 
       nextPotCutoff = Math.min(nextPotCutoff, player.contributed); 
       if (player.score > scoreMax) { 
        scoreMax = player.score; 
        winnerCount = 1; 
       } else if (player.score == scoreMax) { 
        winnerCount++; 
        assert winnerCount > 0; 
       } else { 
        assert player.score < scoreMax; 
       } 
      } 
      if (playerCount == 0) { 
       break; 
      } 
      assert playerCount > 0; 
      assert nextPotCutoff > potCutoff; 
      assert potCutoff >= 0; 
      assert Integer.MAX_VALUE/(nextPotCutoff - potCutoff) >= playerCount; 
      int potTotal = playerCount * (nextPotCutoff - potCutoff); 
      assert potTotal > 0; 
      assert winnerCount > 0; 
      assert winnerCount <= playerCount; 
      for (Player player : players) { 
       if (player.contributed <= potCutoff) { 
        continue; 
       } 
       assert player.contributed >= nextPotCutoff; 
       if (player.score == scoreMax) { 
        assert winnerCount > 0; 
        int winnerShare = potTotal/winnerCount; 
        winnerCount--; 
        assert winnerShare > 0; 
        assert potTotal >= winnerShare; 
        potTotal -= winnerShare; 
        player.received += winnerShare; 
        assert player.received > 0; 
       } else { 
        assert player.score < scoreMax; 
       } 
      } 
      assert winnerCount == 0; 
      assert potTotal == 0; 
      potCutoff = nextPotCutoff; 
     } 
    } 

    public static void main(String[] args) { 
     Player p0 = new Player(), p1 = new Player(), p2 = new Player(); 
     p0.contributed = 100; 
     p1.contributed = 80; 
     p2.contributed = 20; 
     p0.score = 10; 
     p1.score = 2; 
     p2.score = 10; 
     Collection<Player> players = new ArrayList<Player>(); 
     players.add(p0); 
     players.add(p1); 
     players.add(p2); 
     winnings(players); 
     for (Player player : players) { 
      System.out.println(player.received); 
     } 
    } 
}