java为什么我的isFullHouse（）方法也接受一个简单的三类？

Question

我对我的全套方法有问题。我觉得这很简单，只需检查三个同类和一对。但以我目前的代码，我得到了一个只有三个一类的房子。下面是isFullHouse（）和isPair（）的代码，谢谢大家的帮助

 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

你必须先从五张牌中取出三张同类牌。三个一类是真的意味着两个一类是真的。这些集合必须是不相交的

Answer 2

我能建议一种方法让你的逻辑大大简化吗

考虑一个辅助方法，名为{{CD1}}：

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]}
}

那么，获得这种类型的手真的很容易：

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

这也将有助于以后当你不可避免地需要检查一对是否大于另一对时，例如：

Answer 3

因为同一类型的三个也有一对（实际上在代码中可能有两对）

实现这一点的一种方法是按等级对手进行排序，然后它只是检测船的条件

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

可能会有额外的（在那里，但你得到的想法

Answer 4

你需要确保两张牌和三张牌是不同的。如果手是7-8，那么ThreeOfAKind和isPair都会返回true，因为你有三个A（和一对A）

Answer 5

检查以确保这一对与同一种类的三个不同。否则，你的isPair()函数将找到与同类三张相同的卡片。也许是这样：

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

（我使用了int，但如果您愿意，可以更改为使用Pips类型。）

Answer 6

你缺少了第三个条件：三张牌需要与两张牌不同。苏。。。由于您有这个共享的“卡片”阵列，您可能可以将卡片“标记”为已计数，并重置每次传递的已计数状态：

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