Question

我正在玩扑克游戏。到目前为止，我仍然坚持比较扑克手。我有点想知道怎么做，但我不确定我的代码有什么问题。有人可以指出什么是错的吗？

因此，让我简单介绍一下我的代码在做什么。

我程序的另一部分将通过我手中的卡片列出阵列中卡片值的频率。

h = Hearts
c = Clubs
d = Diamonds
s = Spades
d4 = 4 of Diamond

所以，让我说我手里拿着 c3，h4，d4，s4,2d 我会打电话给我程序的另一部分来读取我手中的卡片并返回一个计数器阵列。我手上的计数数组将是[0,0,1,1,3,0,0,0,0,0,0,0,0,0]所以这个数组所说的几乎就是我的手有一个2，一个3和三个4.

现在这是我试图找到三种类型的方法，它应该返回虚假的满屋（这是三种加一对）

public boolean hasThreeOfAKind() {
    int [] temp;
    temp = this.getCounts();
    for (int i = 0; i< temp.length; i++){
        if (temp [i] == 3 ){
            for (int j = 0; j < temp.length ; j++)
                if ( temp [j] != 2){
                    return true;
                }
        }
    }return false;

所以我上面要做的是首先，我运行数组，如果有任何3.如果有3，我再次运行数组，看看是否有2.如果没有2，那我知道它是三种。如果有2，那么它是满屋，我应该返回false。我认为我的逻辑是正确的，但我的代码有问题。

而我遇到麻烦的第二只手就是如何确定我的手是否只有一对。如果只有一对，它只返回true。如果有两对等则返回false。

public boolean hasOnePair() {
    int [] temp;
    temp = this.getCounts();

    for (int i = 0; i< temp.length; i++){
        if (temp [i] == 2 ){
            return true;
        }
    }return false;

对于这个，我正在考虑按降序或升序对数组中的值进行排序。如果我选择降序，我首先读取数组并查看是否有2，然后我可以扫描下一个数据，看看前2个后面的下一个值是否也是2.如果还有另外2个，那么它将返回false。

有人可以看看我的代码，并指出哪里出错了？非常感谢你。

Answer 1

你为什么要使用这种低级原语？您是否有理由不使用完整的Card类？你的代码会简单得多。

class Card
  enum Value {
    TWO,
    ...
    ACE
  };

  enum Suit {
    SPADES,
    ...
    CLUBS

  };
  private Suit suit;
  private Value value;

  public Card(Suit suit, Value value) {
    this.suit = suit;
    this.value = value;
  }
}

public class Hand {
  private final List<Card> cards;
  public Hand(Card first, Card second, Card third, Card fourth, Card fifth) {
     // add to cards list.

     // sort ascending by value

  }

  public boolean hasThreeOfAKind() {
    for (int i = 0; i < 3; i++) {
      Value firstValue = cards.get(i).getValue();
      Value secondValue = cards.get(i+1).getValue();
      Value thirdValue = cards.get(i+2).getValue();
      if (firstValue == secondValue && secondValue == thirdValue) {
        return true;
      }
    }
    return false;
  }
}

这并没有直接回答你的问题，但在我看来，这种代码更易读和可维护，并且比仅涉及整数的代码更容易调试。 Java不是C，你通过像C一样对待它并没有太大的收获。

Answer 2

在您的hasThreeOfAKind()中，您出现以下错误：

for (int j = 0; j < temp.length ; j++) 
  if ( temp [j] != 2){ 
    return true; 
  } 
}

这将在第一次找到非2 j时返回true（对于刚刚检查过的3，它将对其进行满足 - 因此返回true以获得满屋。您需要：

boolean foundTwo = false;
for (int j = 0; j < temp.length ; j++) 
  if ( temp [j] == 2){ 
    foundTwo = true; 
  }
} 
if (!foundTwo) {
  return false;
}

与另一个相似：你需要检查你是否发现了另一个与你已经发现的不同的另外一个：

for (int i = 0; i< temp.length; i++) {  
  if (temp [i] == 2 ){
    boolean foundAnother = false;
    for (int j = 0; j< temp.length; j++) { 
      if (i != j && temp [j] == 2 ){
        foundAnother = true;  
      }  
    }
    if (!foundAnother) {
      return true;
    }
  }  
}
return false;

您可以做的另一件事是为每个识别的手设置过滤器：一对过滤器，一个三过滤器，一个全屋过滤器等，并通过手操作所有这些过滤器。如果有更好的（更高值）匹配，请不要担心，只看到哪些过滤器返回true（找到他们正在寻找的模式）并选择通过的那些中的最高点值

Answer 3

在你的threeOfAKind方法中，第二个for循环只会被执行一次，除非你的数组中存储的第一个数字是2，它应该看起来更像这样：

public boolean hasThreeOfAKind() {
    int [] temp;
    temp = this.getCounts();
    for (int i = 0; i< temp.length; i++){
        if (temp [i] == 3 ){
            for (int j = 0; j < temp.length ; j++)
                if ( temp [j] == 2){
                    return false;
                }
        }
    }
    return true;
}

在上面的代码中，第一次碰到一对时，它意识到手是满屋而不是三种，并返回false。

至于你的另一个方法hasOnePair（），它看起来应该更像：

public boolean hasOnePair() {
    int [] temp;
    temp = this.getCounts();
    int count = 0;

    for (int i = 0; i< temp.length; i++){
        if (temp [i] == 2  ){
            count++;
        }
    }
    return count == 1;
}

Answer 4

查找每张相似卡的编号并制作数组。 SO卡{1,1,2,2,2,5,7}（让我们暂时忽略套装）将映射到（3,2,1,1），即一个完整的房子，你可以轻松检查第二个阵列

Answer 5

我正在帮助儿子上大学的Java课程（我曾经教过的课程）遇到类似的问题，这就是我的建议。

首先，将您的牌从最低2到最高2依次分类为A类，无论是否适合。然后做比较。如果card [0] == card [3]或card [1] == card [4]，则有4种，请忽略接下来的2行。如果card [0] == card [2]或card [1] == card [3]或card [2] == card [4]，则您有3种，请忽略下一行。如果card [0] == card [1]或card [1] == card [2]或card [2] == card [3]或card [3] == card [4]，则您有一对。

在java中比较扑克手

5 个答案: