J'essaie d'exécuter une simulation de poker et j'ai les données suivantes sur une table de poker
lecteur [0] .Core == lecteur [1] .core code>, ils sont liés) li>
ul> Je suis bloqué en calculant combien chaque joueur devrait gagner sans avoir à créer des écrans secondaires et à affecter des joueurs à chacun d'eux. P>
Par exemple, P>
player[0].received = 20
player[1].received = 180
player[2].received = 0
3 Réponses :
Premier tri par marquage décroissant, vous allez donc vous retrouver avec deux groupes: {0, 2}, {1}.
Ensuite, triez chaque groupe par la commande qu'ils ont contribué ascendante: {2 (20), 0 (100)}, {1 (80)}.
Maintenant, divisez le pot dans cet ordre:
Tout d'abord, vous prendrez (max) 20 loin de chaque contribution des joueurs pour créer le premier pot. Et divisez-le uniformément sur 2 et 0. Le premier pot sera (20 + 20 + 20 = 60. Les deux 0 et 2 seront donc donnés 30). Après cela, les premiers gains de joueurs sont terminés et vous êtes laissé avec: {0 (80)}, {1 (60)}.
MAINTENANT, vous allez prendre (max) 80 loin de chaque contribution des joueurs pour créer le pot suivant (80 + 60 = 140). Et donnez-le à 0 (aucune division nécessaire car il n'y en a plus plus d'un dans le groupe supérieur, de sorte que 0 recevra le tout 140). Vous serez laissé avec: {1 (0)}.
Plus de contributions à gauche, vous avez donc terminé.
Donc, au total dans votre exemple, 0 recevrait 170 et 2 recevraient 30.
Je commence à la mettre en œuvre, mais ça fait beaucoup de sens merci!
Comment géreriez-vous un joueur pliant?
Comment décidez-vous qui va le deuxième côté-pot? Et s'il y a trois gagnants qui sont liés? Et un quatrième non-gagnant qui a contribué plus que tous, comment obtiendrait-il le dernier pot-de-pot?
@Christ vraisemblablement, donne leur main le score minimum.
@DavidisenstatStat whoops j'ai oublié de commenter que j'ai géré cela, il y a un drapeau plié pour chaque joueur et que le code qui distribue les contributions vous saute sur eux (si vous pliez, vous ne devez jamais obtenir aucun des gains). Je pense que simplement définir le score à un numéro négatif de travailler aussi si
Le code suivant a un très grand nombre d'affirmations, mais 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);
}
}
}
J'ai une solution, relativement non testée, écrite en C #:
Je sais que cela ne répond pas à votre question, c'est pourquoi je commente et ne répond pas mais que je ne réponds pas, mais en fonction de la mise en œuvre, je pense que ce serait une meilleure pratique de créer les pots latéraux individuels, car il serait plus clair de la représentation de chaque fraction de la fraction du Total qui devrait être gagné, je l'imaginerais aussi qu'il rend plus rapide de calculer si le pot doit être divisé