¿Por qué mi método isFullHouse() también acepta un triple simple?

Question

Estoy teniendo problemas con mi método completo. Pensé que era tan simple como buscar tres de una clase y un par. Pero con mi código actual, tengo una casa llena con solo un trío. El código de isFullHouse() isThreeOfAKind() y isPair() están debajo gracias por toda la ayuda.

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

Compruebe para asegurarse de que el par es de un rangodiferente que el tres de una clase. De lo contrario, su función isPair() encontrará las mismas cartas que las tres de un tipo. Tal como esto:

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

(. Solía ​​int, pero que podría cambiar para utilizar el tipo de Pips si se quiere)

Answer 2

porque tres de una especie tiene un par así (en realidad, probablemente sería 2 pares en su código)

una forma de hacerlo es ordenar la mano por rango, entonces es sólo condicional para detectar un barco.

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

Ther emight ser un extra (en allí, pero se entiende la idea ...

Answer 3

usted necesita para asegurarse de que el par es una de dos diferentes tarjetas que los tres de una especie. Si la mano es AAA 7 8, entonces tanto ThreeOfAKind como isPair devuelven true porque tiene tres ases (y un par de ases).

Answer 4

Primero debe quitar las tres cartas de la mano de las cinco cartas. true implica que dos de una clase son verdaderas. Los conjuntos deben estar disjuntos.

Answer 5

Su método isPair() siempre será verdadero cuando haya tres cartas del mismo tipo porque su bucle interno siempre prueba los valores y solo hasta x.

así que con estos datos AAA78, cuando x = 1 y = 0 obtendrá el recuento == 1 en el ciclo interno y devolverá verdadero aunque haya tres de un tipo. Es mejor bucle sobre la totalidad de los valores de la matriz y el recuento cuando

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

Además - es mejor utilizar una función en forma de isNOfAKind(), que recibe la cantidad de tarjetas como parámetro, ya que estos dos métodos esencialmente hacen lo mismo.

Answer 6

¿Puedo sugerir una forma de simplificar su lógica?

considerar un método de ayuda nombrado 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]} 
} 

Conseguir el tipo de mano es muy fácil, entonces:

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

Esto también ayudará más adelante, cuando inevitablemente necesario comprobar si una pareja es mayor que otro par, por ejemplo

Answer 7

Sólo una idea, ¿no sería más fácil hacer algo como esto:

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

por lo que tendrá por ejemplo: 0 0 0 0 0 3 0 0 0 2 0 0 0 0 para una casa completa.Una escalera se vería como 5 unidades seguidas: 0 0 0 0 1 1 1 1 1 0 0 0.

Dado que los métodos son públicos, no me gustaría que el método isPair() devuelva verdadero si hay un par. Solo debería volver verdadero si no hay nada mejor que un par.

Answer 8

Te estás perdiendo una tercera condición: el triple necesita ser cartas diferentes que el par. Soo ... ya que tiene esta "tarjetas" compartidos matriz, que probablemente podría contados "marcar" las tarjetas como, y restablece el estado de cuenta para cada pase:

//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 mejor enfoque general al problema - este es C#, pero su conversión a Java debe ser sencillo:

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

Si sólo está tratando con manos de cinco cartas, contando el número de pares debe rendir una para una pareja, dos por dos pares, tres para tres de un tipo (por ejemplo, si uno tiene As, Ad y Ac, los pares son As-Ad, As-Ac, y Ad-Ac), cuatro para una casa llena, y seis para cuatro-de- una especie. Esta lógica no funcionará con siete manos de cartas, ya que contaría tres por ej. A-A-K-K-Q-Q-J (que solo debería contar como dos pares, no tres de una clase), y seis para A-A-A-K-K-K-Q (que debería contar como full, no cuatro de una clase).

Answer 11

De acuerdo a su código inline comentarios (exactly two matches palabras) tal vez usted está tratando de poner en práctica el método isPair de tal manera que le proporcione false en el caso de tres de una combinación tipo. Si es así, debe cambiar su método isPair para iterar sobre todos los elementos de la matriz, como este:

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