CODEWITHSUNDEEP
java
user3242607
user3242607

Reputation: 219

Straight hand in Java poker game

I am having trouble finishing the straight method for a poker hand. I don't understand why my code doesn't work. 

public static boolean containsStraight(int [] hand)
{
boolean straight = false;
for(int i = 0; i < 5; i++)
{
  if (hand[i] == 2 && hand[i] == 3 && hand[i] == 4 && hand[i] == 5 &&               hand[i] == 6)
  {
    straight = true;
  }
  if (hand[i] == 3 && hand[i] == 4 && hand[i] == 5 && hand[i] == 6 && hand[i] == 7)
  {
    straight = true;
  }
  if (hand[i] == 4 && hand[i] == 5 && hand[i] == 6 && hand[i] == 7 && hand[i] == 8)
  {
    straight = true;
  }
  if (hand[i] == 5 && hand[i] == 6 && hand[i] == 7 && hand[i] == 8 && hand[i] == 9)
  {
    straight = true;
  }
}
return straight;

}

Upvotes: 0

Views: 6640

Answers (3)

Chris Forrence
Chris Forrence

Reputation: 10114

As pL4Gu33 has already stated in his answer, your comparison is faulty. Essentially, each step through the for-loop leaves hand[i] at a constant value (say, 4). That means that your if-statements are checking:

if(4 == 4 && 4 == 5 && 4 == 6 && 4 == 7 && 4 == 8) {
    ...
}

This will never evaluate to true. If you knew for certain that you had five elements in the hand and that the hand was already sorted, you could do

if (hand[0] == 2 && hand[1] == 3 && hand[2] == 4 && hand[3] == 5 && hand[4] == 6) {
    ...
}

However, I'm going to show you a better answer.

The first thing you should do is to sort your hand. Once you do that, it's easy to step through the hand and check to see if the next card in the hand is exactly one greater than the previous card. If you get to the end and this holds true, then it's a straight.

/*
 * You will need to import java.util.Arrays
 */

public boolean isStraight(int[] hand) {

    if(hand == null || hand.length != 5) {
        return false;
    }
    else {
        // Automatically sort the hand
        Arrays.sort(hand);

        // Set the "previous" variable to a theoretically impossible value
        int prev = -1;

        // Iterate through the hand and see if the next card is exactly one more than
        //    the previous one.
        for(int i = 0; i < hand.length; i++) {

            // If prev is -1, then this is the first time through the for-loop
            // If the card that we're on has a value of the previous card + 1,
            //     we still have the possibility of a straight.
            if(prev == -1 || (prev + 1) == hand[i]) {
                prev = hand[i];
            }
            else {
                return false;
            }
        }
        return true;
    }
}

Upvotes: 3

Warlord
Warlord

Reputation: 2826

The problem is, that you are using the cycle incorrectly, because you are always checking the value of the same card in hand[i]. My suggestion would be either to do a sort first, or if you want to be more efficient, you can use a second field of booleans, that would indicate, whether a card of given value is present in your hand. This way you can easily check, if you have any number of cards in succesion.

public static boolean containsStraight(int[] cards) {

    int count = 0;
    boolean[] valueInHand = new boolean[10];

    for (int card : cards) {
        valueInHand[card] = true;
    }

    for (boolean value : valueInHand) {
        if (value == true) {
            count++;
        } else {
            count = 0;
        }
        // works for any number of cards
        if (count == cards.length) {
            return true;
        }
    }
    return false;
}

Upvotes: 0

pL4Gu33
pL4Gu33

Reputation: 2095

You say in every iteration hand[i] must be 2 AND 3 AND 4 AND 5. That is impossible. There is only one number in hand[i].

Upvotes: 2

Related Questions