爲什麼我的isFullHouse（）方法也接受一個簡單的三類？

Question

我有問題，我滿屋子的方法。我認爲這很簡單，就像檢查一種和一對三種一樣簡單。但是用我目前的代碼，我只有三種房產。代碼isFullHouse（）isThreeOfAKind（）和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

檢查，以確保對比三個類型的不同等級。否則，你的isPair()函數將找到與這三種相同的卡。也許是這樣的：

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

（我用int，但你可以改變，如果你想用你的Pips型）

Answer 2

因爲三張相同的牌有一對，以及（實際上很可能是2對你的代碼）

做到這一點的一種方法是按等級排序，然後通過它的條件來檢測船。

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

療法emight是一個額外的（在那裏，但你的想法...

Answer 3

你需要確保對是比三的一種不同的兩張牌。如果手AAA 7 8，那麼ThreeOfAKind和isPair都會返回true，因爲你有三個ace（和一對ace）。

Answer 4

你必須先從五張牌手中移除三張牌。真實意味着兩種是真實的，這些套件需要不相交

Answer 5

當有三種卡時，您的isPair（）方法將始終返回true，因爲您的內部循環始終只將y值測試至x。

所以用這個數據AAA78，當x = 1時y = 0你會在內循環中得到count == 1並返回true，儘管有三種。這是在整個陣列和計數值更好地循環，當

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

而且 - 這是最好使用一個功能isNOfAKind（的形式），其獲得的卡量作爲參數，因爲這兩種方法本質上做相同。

Answer 6

我可以提出一種讓您的邏輯更加簡單的方法嗎？

考慮helper方法命名爲partitionByRank()：

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 7

只是一個想法，那豈不是更容易做這樣的事情：

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

所以，你將有例如：0 0 0 0 0 3 0 0 0 2 0 0 0 0爲一個完整的家。直線看起來像連續5個：0 0 0 0 1 1 1 1 1 0 0 0。

由於方法是公開的，我不希望isPair()方法返回true，如果有一對。只有沒有比一對更好的東西，它纔會迴歸真實。

Answer 8

你錯過了第三個條件：三元組需要是不同的卡。洙......既然你有這個共享「卡」陣列，你也許可以「標記」出牌數，並重置每次穿過計數狀態：

//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

更好的一般方法的問題 - 這是C＃，但其轉換成Java應該直截了當：

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

如果你只用五張牌手處理，計算對數應該產生一個用於對，兩對兩對，三（如果有As，Ad和Ac，As-Ad，As-Ac和Ad-Ac），四人爲滿屋，六人爲四人，一種。這個邏輯對於七張牌手來說不起作用，因爲它對於例如A-K-K-Q-Q-J（應該只計爲兩對，而不是三類），A-A-K-K-K-Q（應該算作滿屋，不是四類）。

Answer 11

根據您的代碼內嵌評論（exactly two matches字）也許您試圖實施isPair方法，以便在三種情況下返回false。如果是這樣，你需要改變你的isPair方法遍歷數組中的所有項目，像這樣：

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