0

我有一个名为的数组mainDeck，它保存一副扑克牌的值。接下来我要做的是将该数组中的卡片分发到两个名为的单独数组中playerDeck，computerDeck并且每个卡片组必须包含一张唯一的卡片。

我遇到的问题是分配具有唯一价值的卡片 - 每副牌 26 张卡片。我尝试了几种不同的方法，评论底部的编码是我在不得不离开上课之前尝试做的最后剩余的事情。

注意：我的编程技能仅限于请解释您的答案，而不是仅仅提供解决方案，因为这并不能进一步加深我的理解。

static void Main(string[] args)
{
        // 1 = Ace , 13 = King : 0 = Hearts, 1 = Diamonds, 2 = Clubs, 3 = Spades
        int[] mainDeck = new int[52];
        FillDeck(mainDeck);

        int[] playerDeck = new int[26];
        int[] computerDeck = new int[26];
        // Check mainDeck elements
        foreach (int number in mainDeck)
        {
            Console.WriteLine(number);
        }

    }
    public static void FillDeck(int [] mainDeck)
    {
        int cardType = 1;
        List<int> deck = new List<int>();            

        // Add cards to a list
        for (int x = 0; x < 13; x++)
        for(int y = 0; y < 4; y++)
        {
            deck.Add(cardType);
            if (y == 3)
                ++cardType;
        }

        // Insert deck list into a new Array
        int[] cards = deck.GetRange(0, 52).ToArray();

        // Add cards array to mainDeck
        for (int x = 0; x < 52; ++x)
        {
            mainDeck[x] = cards[x];
        }
    }
    //public static void Distribute()
    //{
    //    RandomNumber number = new RandomNumber();
    //    int value = number.RandomNum;

    //    List<int> playerCards = new List<int>();
    //    for (int x = 0; x < 2; ++x)
    //    {
    //        Console.WriteLine(number.RandomNum);
    //    }
    //}
}
//class RandomNumber
//{
//    private int randomNum;
//    Random ranNumberGenerator;

//    public RandomNumber()
//    {
//        ranNumberGenerator = new Random();
//    }

//    public int RandomNum
//    {
//        get
//        {
//            randomNum = ranNumberGenerator.Next(1, 26);
//            return randomNum;
//        }
//    }
//}
4

5 回答 5

2

如果您尝试像在典型纸牌游戏中那样随机分配纸牌，这里有一篇关于洗牌的文章。- http://www.dotnetperls.com/shuffle - 它应该做你想做的事。

在你洗牌 mainDeck 数组后，你只需循环遍历它，以与现实生活中发牌相同的方式将牌交替分配给玩家牌组和计算机牌组。

于 2012-05-30T17:42:53.693 回答
2

纸牌游戏套牌的通用解决方案

  1. 使用所有可用卡创建套牌
  2. 洗牌
  3. 从顶部获取卡片

所以代码:)

public enum CardColor
{
  Hearts = 0,
  Diamonds = 1,
  Clubs = 2,
  Spades = 3
}

public enum CardValue
{
  Ace = 1,
  Two,
  Three,
  Four,
  Five,
  Six,
  Seven,
  Eight,
  Nine,
  Ten,
  Jack,
  Queen,
  King
}

public class Card
{
  public Card(CardValue value, CardColor color)
  {
    Value = value;
    Color = color;
  }

  public readonly CardValue Value;
  public readonly CardColor Color;
}

public class Deck
{
  private Queue<Card> deckInternal;

  public Deck()
  {
    var deck = new List<Card>();
    for(int index = 0; index < 52; index++)
    {
      var cardValue = (CardValue)(index % 4) + 1;
      var cardColor = (CardColor)index / 4;
      dec.Add(new Card(cardValue, cardColor));
    }

    var rand = new Random();
    dec = dec
      .OrderBy(c => rand.Next(52))
      .ToList();

    deckInternal = new Queue<Card>(deck);
  }

  public Card GetCard()
  {
    return deckInternal.Dequeue();
  }
}

获取甲板并将其拆分，您可以下一步

var deck = new Deck();

var player = new List<Card>();
var computer = new List<Card>();

for(int index = 0; index < 52; index++)
{
  if(index % 2 == 0)
  {
    player.Add(deck.GetCard());
  }
  else
  {
    computer.Add(deck.GetCard());
  }
}
于 2012-05-30T17:44:05.840 回答
1

您有两个选项可以在此处保持牌组中的值唯一。您可以创建一个表示卡片的新类，它具有等级和花色的属性，或者如果您想保持简单（无论如何从编译器的角度来看），您可以使用该值来指示等级和花色，而您' 仅使用 1 到 13 来表示排名。

对于后一种解决方案，您可能希望使用数字 0 到 12 表示 A 到红心 K，13 到 25 表示 A 到方块 K，依此类推。获得您将使用的任何卡片的等级card % 13并获得您将使用的卡片的花色card / 4。

不过，我更喜欢前一种解决方案，并且会创建一个这样的类（您也可以用 Enums 替换 int 属性以获得更高的可读性）：

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

之后，您可以创建一个循环，该循环一直运行直到主牌组为空，并从主牌组中随机选择一张牌放入其他两个牌组。在伪代码中，它可能看起来像：

while (mainDeck has any elements)
    num = random number between 0 and elements in mainDeck - 1, inclusive
    deckToAddTo = alternate between playerDeck and computerDeck
    remove card num from mainDeck and insert into deckToAddTo
于 2012-05-30T17:52:55.467 回答
0

给玩家前 26 张牌。

playerDeck = mainDeck.Take(26).ToArray();

跳过玩家的牌并获得接下来的 26 张牌。

computerDeck = mainDeck.Skip(26).Take(26).ToArray();
于 2012-05-30T17:47:29.693 回答
0 
Random  rnd = new Random();
// you can Shuffle Array and Take random 26 items using Linq as below
int[] playerDeck = mainDeck.OrderBy(x => rnd.Next()).Take(26).ToArray();
// get rest of the items using Except linq method 
int[] computerDeck = mainDeck.Except(playerDeck).ToArray();
于 2012-05-30T17:54:47.587 回答