Perché il metodo isFullHouse() accetta anche un semplice tris?

Question

Ho problemi con il metodo full house. Ho pensato che fosse semplice come controllare tris e una coppia. Ma con il mio codice corrente sto ottenendo un full con solo un tris. Il codice per isFullHouse() isThreeOfAKind() e isPair() è sotto grazie per tutto l'aiuto!

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

Controllare per accertarsi che la coppia è di una diversa rango rispetto al tris. In caso contrario, la tua funzione isPair() troverà le stesse carte del tris. Forse in questo modo:

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

(. Ho usato int, ma si potrebbe cambiare di utilizzare il tipo Pips se vi piace)

Answer 2

perché tre di un genere ha una coppia così (in realtà sarebbe probabilmente 2 coppie nel codice)

un modo per fare ciò è ordinare la mano in base al grado, quindi le sue sole condizioni per rilevare una barca.

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

ther emight essere un extra (in là, ma si ottiene l'idea ...

Answer 3

È necessario assicurarsi che la coppia è un diverso due carte rispetto al tris. Se la mano è AAA 7 8, quindi sia ThreeOfAKind che isPair restituiscono true perché si hanno tre assi (e una coppia di assi)

Answer 4

È necessario rimuovere prima le tre carte di un tipo dalla mano con cinque carte. true implica che due di un tipo sono veri I set devono essere disgiunti

Answer 5

Il tuo metodo isPair() restituirà sempre true quando ci sono tre carte di un tipo perché il tuo ciclo interno verifica sempre i valori y solo fino a x.

quindi con questi dati AAA78, quando x = 1 y = 0 si ottiene il conteggio == 1 nel ciclo interno e si restituisce true sebbene ci siano tris. È meglio ciclo sull'intero valori di matrice e conteggio quando

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

Inoltre - è preferibile utilizzare una funzione nella forma di isNOfAKind() che ottiene la quantità di carte come parametro poiché questi due metodi essenzialmente fanno la stesso.

Answer 6

Posso suggerire un modo per rendere la tua logica estremamente più semplice?

considerare un metodo di supporto chiamato 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]} 
} 

Ottenere il tipo di mano è davvero facile allora:

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

Questo aiuterà anche in seguito quando si inevitabilmente necessario verificare se una coppia è maggiore di un'altra coppia, ad es

Answer 7

Solo un'idea, non sarebbe più facile fare qualcosa di simile:

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

in modo da avere per esempio: 0 0 0 0 0 3 0 0 0 2 0 0 0 0 per un full.Una scala assomiglia a 5 di fila: 0 0 0 0 1 1 1 1 1 0 0 0.

Poiché i metodi sono pubblici, non mi piacerebbe che il metodo isPair() restituisse true se esiste una coppia. Dovrebbe restituire true solo se non c'è niente di meglio di una coppia.

Answer 8

Ti manca una terza condizione: la tripla deve essere una carta diversa dalla coppia. Soo ... visto che hai questo "carte" in comune matrice, probabilmente potrebbe "segnare" le carte come contate, e ripristinare lo stato contato per ogni passata:

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

Un approccio migliore generale al problema - questo è C#, ma la conversione in Java dovrebbe essere semplice:

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

Se siete solo che fare con le mani a cinque carte, contando il numero di coppie dovrebbe produrre una per una coppia, due per due coppie, tre per tre di un tipo (es. se uno ha As, Ad e Ac, le coppie sono As-Ad, As-Ac e Ad-Ac), quattro per un full e sei per quattro-of- a un tipo. Questa logica non funzionerà con sette mani di carte, dato che conterebbe tre per es. A-A-K-K-Q-Q-J (che dovrebbe valere solo come doppia coppia, non tris), e sei per A-A-A-K-K-K-Q (che dovrebbe valere come full, non come four-of-a-kind).

Answer 11

Secondo i vostri commenti del codice inline (exactly two matches parole) forse si sta cercando di attuare isPair metodo in modo che restituisca false in caso di tre di una combinazione tipo. Se è così, avete bisogno di cambiare il metodo di isPair per iterare su tutti gli elementi nella matrice, in questo modo:

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