Determinar la cantidad obtenida en el Poker sin crear secundarios ollas

Question

Estoy tratando de ejecutar una simulación de póquer y tienen los siguientes datos acerca de una mesa de póquer

• la cantidad de cada jugador contribuyó a la olla
• un " puntuación de la mano"(después de fracaso) para cada jugador (es decir, si player[0].score == player[1].score, ataron)

estoy atascado el cálculo de la cantidad que cada jugador debe ganar sin necesidad de crear sidepots y la asignación de los jugadores para cada uno de ellos.

Por ejemplo,

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; 

En este ejemplo, puedo tenga que regresar player[0] 20 de nuevo y sacarlo de la olla?

Entonces, dado que player[0] y player[2] han empatado en el primer lugar, y player[1] ha perdido, si el bote se dividirá como:

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

Y posteriormente, si player[1] habían ganado, si el bote se divide de la :

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

Answer 1

primero ordenar por puntuación descendente, por lo que va a terminar con dos grupos: {0, 2}, {1}.

Luego, ordene cada grupo por el orden que han contribuido de forma ascendente: {2 (20), 0 (100)}, {1 (80)}.

Ahora, divida el bote en ese orden:

1. Primero se va a tomar (máx) 20 lejos de cada uno de los jugadores contribuciones para crear la primera olla. Y divídalo en forma pareja en 2 y 0. El primer bote será (20 + 20 + 20 = 60. Por lo tanto, tanto 0 como 2 tendrán 30). Después de eso, se hacen las primeras ganancias de los jugadores, y le quedan: {0 (80)}, {1 (60)}.

2. Ahora, tomará (máximo) 80 de las contribuciones de cada jugador para crear el siguiente bote (80 + 60 = 140). Y déjelo en 0 (no se necesita división ya que no hay más de uno en el grupo superior, por lo que 0 recibirá el total de 140). Te quedarás con: {1 (0)}.

3. Ya no quedan más contribuciones, así que listo.

Así, en total, en su ejemplo, 0 recibirían 170 y 2 recibirían 30.

Answer 2

El siguiente código tiene un gran número de afirmaciones, pero TEN CUIDADO porque no he probado cuidadosamente No está claro qué hacer con las fichas impares; Se los doy a los jugadores que aparecen más adelante en la colección.

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); 
     } 
    } 
}