1

我正在做一个扑克游戏。到目前为止，我一直在比较扑克牌。我对如何做到这一点有一个想法，但我不确定我的代码有什么问题。有人可以指出什么问题吗？

所以让我简要描述一下我的代码在做什么。

我程序的另一部分将遍历我手中的牌，并在一个数组中列出一张牌值的频率。

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。

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

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，那么它将返回错误。

有人可以看看我的代码并指出问题所在吗？非常感谢。

4

5 回答 5

4

你为什么要使用如此低级的原语？您没有使用完整的 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 来对待，你并没有真正获得太多收益。

于 2012-04-28T01:44:00.290 回答
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;
}

另一个类似：您需要检查是否找到另一个与您已经找到的不同的 2：

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（找到他们正在寻找的模式）并在通过的过滤器中选择最高点值

于 2012-04-28T01:33:26.893 回答
0

在您的 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;
}
于 2012-04-28T01:37:54.173 回答
0

查找每张相似卡片的数量并制作数组。SO 牌{1,1,2,2,2,5,7}（让我们暂时忽略花色）将映射到 (3,2,1,1) 即满屋，您可以轻松检查第二个数组

于 2015-07-29T00:54:56.177 回答
0

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

首先将您的牌从最低到最高 2 排序为 Ace，无论花色如何。然后进行比较。如果 card[0]==card[3] 或 card[1]==card[4]，你有 4 个，忽略接下来的 2 行。如果 card[0]==card[2] or card[1]==card[3] or card[2]==card[4]，你有 3 个，忽略下一行。如果 card[0]==card[1] or card[1]==card[2] or card[2]==card[3] or card[3]==card[4]，你有一对。

于 2019-12-03T01:13:03.817 回答