Warum akzeptiert meine isFullHouse() -Methode auch ein einfaches dreifaches?

Question

Ich habe Probleme mit meiner Full-House-Methode. Ich dachte, es sei so einfach wie die Suche nach Dreien und einem Paar. Aber mit meinem jetzigen Code bekomme ich ein volles Haus mit nur dreien. Code für isFullHouse() isThreeOfAKind() und isPair() ist unten danke für die Hilfe!

public boolean isPair() { 
    Pips[] values = new Pips[5]; 
    int count =0; 

    //Put each cards numeric value into array 
    for(int i = 0; i < cards.length; i++){ 
     values[i] = cards[i].getPip(); 
    } 

    //Loop through the values. Compare each value to all values 
    //If exactly two matches are made - return true 
    for(int x = 1; x < values.length; x++){ 
     for(int y = 0; y < x; y++){ 
      if(values[x].equals(values[y])) count++; 
     } 
     if (count == 1) return true; 
     count = 0; 
    } 
    return false; 
} 

public boolean isThreeOfAKind() { 
    Pips[] values = new Pips[5]; 
    int counter = 0; 

    for(int i = 0; i < cards.length; i++){ 
     values[i] = cards[i].getPip(); 
    } 

    //Same process as isPair(), except return true for 3 matches 
    for(int x = 2; x < values.length; x++){ 
     for(int y = 0; y < x; y++){ 
      if(values[x].equals(values[y])) 
       counter++; 
     } 
     if(counter == 2) return true; 
     counter = 0; 
    } 

    return false; 
} 

public boolean isFullHouse(){ 
    if(isThreeOfAKind() && isPair()) 
     return true; 
    return false; 
} 

Answer 1

überprüfen, um sicherzustellen, dass das Paar von einem als die drei einer Art Rang unterscheidet. Andernfalls wird Ihre isPair() Funktion die gleichen Karten wie die drei einer Art finden. Vielleicht so:

public boolean isFullHouse(){ 
    int three = isThreeOfAKind(); 
    int pair = isPair(); 
    if (three != 0 && pair != 0 && three != pair) { 
     return true; 
    } 
    return false; 
} 

(. Früher habe ich int, aber Sie könnten Ihren Pips Typen verwenden ändern, wenn Sie mögen)

Answer 2

weil drei eine Art als auch ein Paar hat (wäre eigentlich wahrscheinlich 2 Paare in Ihrem Code)

eine Möglichkeit, dies zu tun, ist die Hand nach Rang zu sortieren, dann ist es nur Bedingungen, um ein Boot zu erkennen.

if (((c1.rank == c2.rank == c3.rank) && (c4.rank == c5.rank)) || 
    (c1.rank == c2.rank) && (c3.rank == c4.rank == c5.rank)) 

ther emight ein extra sein (da drin, aber Sie bekommen die Idee ...

Answer 3

Sie müssen das Paar, um sicherzustellen, eine andere zwei Karten als die drei von einer Art ist. Wenn die Hand AAA 7 8, dann kehren sowohl ThreeOfAKind als auch isPair wahr zurück, weil du drei Asse hast (und ein Paar Asse)

Answer 4

Du musst zuerst die drei freundlichen Karten aus der Fünfkartenhand entfernen true impliziert, dass zwei von einer Art wahr sind. Die Sätze müssen disjunkt sein.

Answer 5

Ihre isPair() -Methode gibt immer true zurück, wenn drei Karten einer Art vorhanden sind, da Ihre innere Schleife die y-Werte immer nur bis x testet.

Also mit diesen Daten AAA78, wenn x = 1 y = 0 Sie erhalten Count == 1 in der inneren Schleife und zurück wahr, obwohl es drei einer Art sind. Es ist besser, eine Schleife über die gesamte Array und Zählwerte, wenn

if(values[x].equals(values[y]) && x != y) 

Außerdem - es besser ist, eine Funktion in der Form von isNOfAKind() zu verwenden, die die Anzahl der Karten als Parameter erhält, da diese beiden Methoden im wesentlichen das tun gleich.

Answer 6

Kann ich Ihnen einen Weg vorschlagen, Ihre Logik dramatisch zu vereinfachen?

eine Hilfsmethode Erwägen partitionByRank() genannt:

public class RankSet { 
    private int count; 
    private Rank rank; 
} 

/** 
* Groups the hand into counts of cards with same rank, sorting first by 
* set size and then rank as secondary criteria 
*/ 
public List<RankSet> partitionByRank() { 
    //input e.g.: {Kh, Qs, 4s, Kd, Qs} 
    //output e.g.: {[2, K], [2, Q], [1, 4]} 
} 

die Art von Hand zu bekommen ist einfach dann:

public boolean isFullHouse() { 
    List<RankSet> sets = partitionByRank(); 
    return sets.length() == 2 && sets.get(0).count == 3 && sets.get(1).count() == 2; 
} 

public boolean isTrips() { 
    //... 
    return sets.length() == 3 && sets.get(0).count = 3; 
} 

Dies wird auch später helfen, wenn Sie unweigerlich, ob ein Paar überprüfen müssen ist größer als ein anderes Paar, z

Answer 7

Nur eine Idee, wäre es nicht einfacher sein, so etwas zu tun:

int[] count=new int[13];//size of all ranks 
for (i=0;i<5;i++) 
    count[ card[i].rank ] ++; 

So werden Sie zum Beispiel haben: 0 0 0 0 0 3 0 0 0 2 0 0 0 0 für ein volles Haus.Ein Straight würde wie 5 hintereinander aussehen: 0 0 0 0 1 1 1 1 1 0 0 0.

Da die Methoden öffentlich sind, möchte ich nicht, dass die Methode isPair() True zurückgibt, wenn es ein Paar gibt. Es sollte nur wahr zurückgegeben werden, wenn es nichts besseres als ein Paar gibt.

Answer 8

Sie vermissen eine dritte Bedingung: das Tripel muss andere Karten als das Paar sein. Soo ... da Sie haben dieses shared „Karten“ Array, werden Sie wahrscheinlich könnte „Zeichen“ die Karten als gezählt, und stellen Sie den gezählten Status für jeden Durchlauf:

//Same process as isPair(), except return true for 3 matches 
for(int x = 2; x < values.length; x++){ 
    cards[x].setCounted(true); // by default, count the start card 
    for(int y = 0; y < x; y++){ 
     // make sure the card isn't already counted: 
     if(!cards[y].isCounted() && values[x].equals(values[y])) { 
      counter++; 
      cards[x].setCounted(true); // count it 
     } 
    } 
    if(counter == 2) return true; 
    counter = 0; 
    // reset counted cards 
    for(int z=0, zlen=values.length; z < zlen; z++) { cards[z].setCounted(false); } 
} 

Answer 9

Eine bessere allgemeine Herangehensweise an das Problem - das C# ist, sollte es zu Java Umwandlung aber einfach sein: die Anzahl der Paare zählen Wenn Sie mit fünf-Karten-Händen nur zu tun haben

int[] countOfRank = new int[13]; 
int[] countOfSuit = new int[4]; 
for(int i = 0; i < cards.length; i++) 
{ 
    countOfRank[cards[i].Rank]++; 
    countOfSuit[cards[i].Suit]++; 
} 

for (int i=0; i < countOfSuit.length; i++) 
{ 
    isFlush = isFlush || countOfSuit[i] == 5; 
} 

int[] countOfTuple = new int[5]; 
int runLength=0; 
for (int i=0; i < countOfRank.length; i++) 
{ 
    if (countOfRank[i] == 1) 
    { 
     runLength++; 
     isStraight = (isStraight || runLength == 5); 
    } 
    else 
    { 
     runLength=0; 
    } 
    countOfTuple[countOfRank[i]]++; 
} 
isPair = (countOfTuple[2] == 1 && countOfTuple[3] == 0); 
isTwoPair = (countOfTuple[2] == 2); 
isFullHouse = (countOfTuple[2] == 1 && countOfTuple[3] == 1); 
isThreeOfAKind = (countOfTuple[2] == 0 && countOfTuple[3] == 1); 
isFourOfAKind = (countOfTuple[4] == 1); 
isStraightFlush = (isStraight && isFlush); 
isStraight = (isStraight && !isStraightFlush); 
isFlush = (isFlush && !isStraightFlush); 
isRoyalFlush = (isStraightFlush && countOfRank[12] == 1); 
isStraightFlush = (isStraightFlush && !isRoyalFlush); 

Answer 10

sollte drei, für ein Paar, zwei für zwei Paare einer Ausbeute für Dreiling (zB wenn man As, Ad und Ac hat, sind die Paare As-Ad, As-Ac und Ad-Ac), vier für ein volles Haus und sechs für vier von eine Art. Diese Logik funktioniert nicht mit Sieben-Karten-Händen, da sie z. A-A-K-K-Q-Q-J (das nur als Zweipaar, nicht als Dreifach-Paar zählen sollte) und sechs für A-A-A-K-K-K-Q (das als Vollhaus, nicht als Vierer zählen sollte).

Answer 11

nach Ihren Code inlined Kommentare (exactly two matches Wörter) vielleicht Sie versuchen isPair Verfahren so zu implementieren, dass es false bei drei einer Art Kombination zurück. Wenn dies der Fall ist, müssen Sie Ihre isPair-Methode so ändern, dass alle Elemente im Array durchlaufen werden: