Question

我正在创建一个程序来确定谁赢得了扑克游戏。

对于上下文，输入数据的格式为：

8C TS KC 9H 4S 7D 2S 5D 3S AC

第一个字符表示卡的强度（A = Ace，T = 10，J = Jack等），第二个字符表示套装。前5张牌是第一名，最后5张是第二名。

数据已被读入数组，分成两个数组，包含每个玩家的手，playerOneHands和playerTwoHands。然后将这个数组进一步拆分成一个数组，描述卡片的强度（将字符串转换为整数并将＆＃34; T＆＃34;转换为int 10，＆＃34; J＆＃34;转换为int 11等），playerOneCardStrengths和playerTwoCardStrengths，以及西装，playerOneCardSuits和playerTwoCardSuits。然后使用

按照从最高到最低的顺序对强度数组进行排序

Array.Sort(playerOneCardStrengths, playerOneCardSuits);

我现在想通过一个函数来传递这些值，该函数检查皇家同花顺是否已经发生。它会输入这两个数组并输出一个布尔值来描述皇家同花顺是否已经发生。

皇家同花顺在扑克中被定义为包含Ace，King，Queen，Jack和Ten的手牌。

这是我到目前为止所做的：

static bool determineRoyalFlush(int[] cardStrengths, string[] cardSuits)
    {
        bool royalFlush = false;
        if (cardSuits[0] != cardSuits[1])
        {
            return royalFlush = false;
        }
        else
        {
            if (cardStrengths[0] != 14)
            {
                return royalFlush = false;
            }
            else
            {
                if (cardStrengths[0] - cardStrengths[1] == 1 
                    && cardStrengths[1] - cardStrengths[2] == 1
                    && cardStrengths[2] - cardStrengths[3] == 1
                    && cardStrengths[3] - cardStrengths[4] == 1)
                {
                    return royalFlush = true;
                }
                else
                {
                    royalFlush = false;
                }
            }
        }

    }

我的两个问题：

是否有更简洁的方法来检查cardStrengths数组是否包含数字行中的连续数字？上面的最后一段代码基本上检查cardStrengths [0] = 14和[1] = 13和[2] = 12等。但我想重复使用此代码来检查常规刷新，并且我是只是很好奇我怎么能检查一个数百万个整数的数组，无论它们是否都计入1 2 3 4 ..等等，或者再次倒数。

其次，更重要的是，我收到了错误＆＃34;并非所有代码路径都返回一个值＆＃34;但我无法看到任何不返回的情况对或错？我忽略了某个地方。

谢谢！

Answer 1

解决您的第二个问题：

你的最后一个声明(royalFlush = False )不会返回任何内容。应将代码更改为return False。

Answer 2

您可以使用for循环将项目与之前的项目进行比较，方法是使用第二个项目开始循环（即使用索引1而不是0）。

if (cardStrengths[0] != 14) {
    return false;
}
for (int i = 1; i < cardStrengths.Length; i++) {
    if (cardStrengths[i - 1] - cardStrengths[i] != 1) {
        return false;
    }
}
return true;

不需要变量royalFlush。

如果你通过添加一些代表游戏概念的类型来构建游戏，那么它会增加很多清晰度

public enum Suit
{
    Club,
    Diamond,
    Heart,
    Spade
}

public enum Rank
{
   Two = 2, Three = 3, Four = 4, Five = 5, Six = 6, Seven = 7, Eight = 8, Nine = 9, Ten = 10,
   Jack = 11, Queen = 12, King = 13, Ace = 14
}

与rank == Rank.Ace比较比比较rank == 14更容易理解。

卡片可以这样表示：

public class Card
{
    public Rank Rank { get; }
    public Suit Suit { get; }

    public Card(Rank rank, Suit suit)
    {
        Rank = rank;
        Suit = suit;
    }

    public Card(string s)
    {
        switch (s[0]) {
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                Rank = (Rank)(s[0] - '0');
                break;
            case 'T':
                Rank = Rank.Ten;
                break;
            case 'J':
                Rank = Rank.Jack;
                break;
            case 'Q':
                Rank = Rank.Queen;
                break;
            case 'K':
                Rank = Rank.King;
                break;
            case 'A':
                Rank = Rank.Ace;
                break;
        }
        switch (s[1]) {
            case 'C':
                Suit = Suit.Club;
                break;
            case 'D':
                Suit = Suit.Diamond;
                break;
            case 'H':
                Suit = Suit.Heart;
                break;
            case 'S':
                Suit = Suit.Spade;
                break;
        }
    }
}

请注意，我添加了2个构造函数。一个允许您通过指定值直接定义卡。另一个解析像"8C"这样的字符串，并将其转换为相应的值。

Hand类允许您将评分方法放在某处并从裸阵列中抽象出来。这里再次有2个构造函数。

public class Hand
{
    public Hand(params Card[] cards)
    {
        Cards = cards;
    }

    public Hand(string s)
    {
        // E.g. s = "8C TS KC 9H 4S"
        string[] parts = s.Split();
        Cards = parts
            .Select(p => new Card(p))
            .ToArray();
    }

    public Card[] Cards { get; }

    public bool IsRoyalFlush()
    {
        if (Cards[0].Rank != Rank.Ace) {
            return false;
        }
        for (int i = 1; i < Cards.Length; i++) {
            if (Cards[i - 1].Rank - Cards[i].Rank != 1) {
                return false;
            }
        }
        return true;
    }

    //TODO: Add more scoring methods.
}

在Code Review上，用户Glitch提供了一个结构良好的游戏（2048 console game (C#)）。

In my answer我通过分离游戏的不同方面提出了更多的结构。它首先看起来更有效，但是一旦建立了良好的结构，就可以更容易地处理代码。

如何检查数组是否包含连续的，均匀间隔的数字？

2 个答案: