C# 我如何用C语言处理这套词典#

我有2名玩家，我希望他们每个人从这52张牌组中随机获得26张。有人知道我如何从52张牌中随机给每位玩家26张牌吗

这将清空原来的52卡片组字典，并创建2个较小的26卡片组字典

我已经为此奋斗了三天，并且已经做了所有我能做的研究。 这是我的甲板课：

class Deck
{
    public Dictionary<int, string> CreateNewDeck()
    {
        Dictionary<int, string> newDeck = new Dictionary<int, string>()
        {
            {1, "~/cards/c1.png"}, {2, "~/cards/c2.png"}, {3, "~/cards/c3.png"}, {4, "~/cards/c4.png"},
            {5, "~/cards/c5.png"}, {6, "~/cards/c6.png"}, {7, "~/cards/c7.png"}, {8, "~/cards/c8.png"},
            {9, "~/cards/c9.png"}, {10, "~/cards/c10.png"}, {11, "~/cards/cj.png"}, {12, "~/cards/cq.png"}, {13, "~/cards/ck.png"},
            {14, "~/cards/d1.png"}, {15, "~/cards/d2.png"}, {16, "~/cards/d3.png"}, {17, "~/cards/d4.png"},
            {18, "~/cards/d5.png"}, {19, "~/cards/d6.png"}, {20, "~/cards/d7.png"}, {21, "~/cards/d8.png"},
            {22, "~/cards/d9.png"}, {23, "~/cards/d10.png"}, {24, "~/cards/dj.png"}, {25, "~/cards/dq.png"}, {26, "~/cards/dk.png"},
            {27, "~/cards/h1.png"}, {28, "~/cards/h2.png"}, {29, "~/cards/h3.png"}, {30, "~/cards/h4.png"},
            {31, "~/cards/h5.png"}, {32, "~/cards/h6.png"}, {33, "~/cards/h7.png"}, {34, "~/cards/h8.png"},
            {35, "~/cards/h9.png"}, {36, "~/cards/h10.png"}, {37, "~/cards/hj.png"}, {38, "~/cards/hq.png"}, {39, "~/cards/hk.png"},
            {40, "~/cards/s1.png"}, {41, "~/cards/s2.png"}, {42, "~/cards/s3.png"}, {43, "~/cards/s4.png"},
            {44, "~/cards/s5.png"}, {45, "~/cards/s6.png"}, {46, "~/cards/s7.png"}, {47, "~/cards/s8.png"},
            {48, "~/cards/s9.png"}, {49, "~/cards/s10.png"}, {50, "~/cards/sj.png"}, {51, "~/cards/sq.png"}, {52, "~/cards/sk.png"},
        };
        return newDeck;
    }
}

类甲板
{
公共字典CreateNewDeck（）
{
字典newDeck=新字典（）
{
{1，“~/cards/c1.png”}，{2，“~/cards/c2.png”}，{3，“~/cards/c3.png”}，{4，“~/cards/c4.png”}，
{5，“~/cards/c5.png”}，{6，“~/cards/c6.png”}，{7，“~/cards/c7.png”}，{8，“~/cards/c8.png”}，
{9，“~/cards/c9.png”}，{10，“~/cards/c10.png”}，{11，“~/cards/cj.png”}，{12，“~/cards/cq.png”}，{13，“~/cards/ck.png”}，
{14，“~/cards/d1.png”}，{15，“~/cards/d2.png”}，{16，“~/cards/d3.png”}，{17，“~/cards/d4.png”}，
{18，“~/cards/d5.png”}，{19，“~/cards/d6.png”}，{20，“~/cards/d7.png”}，{21，“~/cards/d8.png”}，
{22，“~/cards/d9.png”}，{23，“~/cards/d10.png”}，{24，“~/cards/dj.png”}，{25，“~/cards/dq.png”}，{26，“~/cards/dk.png”}，
{27，“~/cards/h1.png”}，{28，“~/cards/h2.png”}，{29，“~/cards/h3.png”}，{30，“~/cards/h4.png”}，
{31，“~/cards/h5.png”}，{32，“~/cards/h6.png”}，{33，“~/cards/h7.png”}，{34，“~/cards/h8.png”}，
{35，{36，{cards/h10.png}，{37，{cards/hj.png}，{38，{cards/hq.png}，{39，{cards/hk.png}，
{40，“~/cards/s1.png”}，{41，“~/cards/s2.png”}，{42，“~/cards/s3.png”}，{43，“~/cards/s4.png”}，
{44，“~/cards/s5.png”}，{45，“~/cards/s6.png”}，{46，“~/cards/s7.png”}，{47，“~/cards/s8.png”}，
{48，“~/cards/s9.png”}，{49，“~/cards/s10.png”}，{50，“~/cards/sj.png”}，{51，“~/cards/sq.png”}，{52，“~/cards/sk.png”}，
};
返回新甲板；
}
}

这是我试图写的划分牌组的方法，你可能会看到，我是个新手：

class Dealer
{
    public Dictionary<int, string> DealPlayersDeck(Deck deck, Player human, Player computer)
    {
        Deck cards = new Deck();
        Player humanPlayer = new Player();
        Player computerPlayer = new Player();

        var fullDeck = cards.CreateNewDeck();
        var playerDeck = humanPlayer.PlayerCards;
        var computerDeck = computerPlayer.PlayerCards;

        int halfDeck = fullDeck.Count() / 2;

        foreach (object i in fullDeck)
        {
            List<int> keyList = new List<int>(fullDeck.Keys);
            Random rand = new Random();
            int randomKey = keyList[rand.Next(keyList.Count)];

            if (!playerDeck.ContainsKey(randomKey))
            {
                playerDeck.Add(randomKey, fullDeck[randomKey]);
                fullDeck.Remove(randomKey);
            }
        }
        return playerDeck;
    }
}

class经销商
{
公共字典DealPlayerDeck（牌组、玩家组、玩家计算机）
{
卡片组=新卡片组（）；
Player humanPlayer=新玩家（）；
Player computerPlayer=新玩家（）；
var fullDeck=cards.CreateNewDeck（）；
var playerDeck=humanPlayer.PlayerCards；
var computerDeck=computerPlayer.PlayerCards；
int halfDeck=fullDeck.Count（）/2；
foreach（全甲板上的一号物体）
{
List keyList=新列表（fullDeck.Keys）；
Random rand=新的Random（）；
int randomKey=keyList[rand.Next（keyList.Count）]；
如果（！playerDeck.ContainsKey（随机键））
{
playerDeck.Add（randomKey，fullDeck[randomKey]）；
全甲板。移除（随机键）；
}
}
返回playerDeck；
}
}

---

您不必每次都在循环中获取密钥列表。你不必在字典上循环。只需获取循环外的键列表。将其洗牌并在其上迭代

List<int> keyList = new List<int>(fullDeck.Keys);
Random rand = new Random();

// shuffle list and take first 26 items from it
var shuffled = keyList.OrderBy(item => rand.Next()).ToList();
var keyListfirst = shuffled.Take(26).ToList();

foreach (var randKey in keyListfirst) // loop on keylist
{
     playerDeck.Add(randKey, fullDeck[randKey]);
     fullDeck.Remove(randKey);
}

// take the rest of the list
var keyListrest = shuffled.Skip(26).ToList();

foreach (var randKey in keyListrest)
{
     computerDeck.Add(randKey, fullDeck[randKey]);
     fullDeck.Remove(randKey);
}

List keyList=新列表（fullDeck.Keys）；
Random rand=新的Random（）；
//洗牌列表并从中取出前26项
var shuffled=keyList.OrderBy（item=>rand.Next（））.ToList（）；
var keyListfirst=shuffled.Take（26.ToList（）；
foreach（keyListfirst中的var randKey）//在keylist上循环
{
playerDeck.Add（randKey，fullDeck[randKey]）；
全甲板。移除（randKey）；
}
//拿清单的其余部分来说
var keyListrest=shuffled.Skip（26.ToList（）；
foreach（keyListrest中的var randKey）
{
computerDeck.Add（randKey，fullDeck[randKey]）；
全甲板。移除（randKey）；
}

---

在这种情况下，如果（！playerDeck.ContainsKey（randKey）），您可以安全地删除此条件。因为现在列表被洗牌了，你们正在迭代它。所以你不会两次得到一件物品。

它应该符合你的要求

public void DealPlayersDeck()
    {
        Deck cards = new Deck();
        Player humanPlayer = new Player();
        Player computerPlayer = new Player();

        var fullDeck = cards.CreateNewDeck();
        //var playerDeck = humanPlayer.PlayerCards;
        //var computerDeck = computerPlayer.PlayerCards;

        Dictionary<int, string> playerDeck=new Dictionary<int,string>();
        Dictionary<int, string> computerDeck = new Dictionary<int, string>();

        int count=1;

        while (fullDeck.Keys.Count>0)
        {
            Random r = new Random();
            int randomKey = fullDeck.Keys.ToList().OrderBy(x => r.Next()).First();

            if (count % 2 == 0)
            {
                playerDeck.Add(randomKey, fullDeck[randomKey]);                
            }
            else
            {
                computerDeck.Add(randomKey, fullDeck[randomKey]);                
            }

            fullDeck.Remove(randomKey);
            count++;

        }

    }

public void DealPlayersDeck（）
{
卡片组=新卡片组（）；
Player humanPlayer=新玩家（）；
Player computerPlayer=新玩家（）；
var fullDeck=cards.CreateNewDeck（）；
//var playerDeck=humanPlayer.PlayerCards；
//var computerDeck=computerPlayer.PlayerCards；
Dictionary playerDeck=新字典（）；
Dictionary computerDeck=新字典（）；
整数计数=1；
while（fullDeck.Keys.Count>0）
{
随机r=新随机（）；
int randomKey=fullDeck.Keys.ToList（）.OrderBy（x=>r.Next（））.First（）；
如果（计数%2==0）
{
playerDeck.Add（randomKey，fullDeck[randomKey]）；
}
其他的
{
computerDeck.Add（randomKey，fullDeck[randomKey]）；
}
全甲板。移除（随机键）；
计数++；
}
}

您可以执行以下操作：

keyList

将为您提供26个唯一键的列表。循环键并将其添加到

playerDeck

中，同时将其从

fullDeck

中删除，以便在循环迭代后，fullDeck包含不在

playerDeck

中的键，以便您可以将其移动到

computerDeck

 List<int> keyList = new List<int>(fullDeck.Keys);
 Random rand = new Random();
 var keyList = keyList.OrderBy(item => rand.Next()).Take(26).ToList();//will take only 26 random keys
 foreach (var randKey in keyList) // loop on keylist
  {
       playerDeck.Add(randKey, fullDeck[randKey]);
       fullDeck.Remove(randKey);        
  }
 computerDeck =fullDeck;

List keyList=新列表（fullDeck.Keys）；
Random rand=新的Random（）；
var keyList=keyList.OrderBy（item=>rand.Next（））.Take（26.ToList（）//只需要26个随机键
foreach（键列表中的var randKey）//键列表上的循环
{
playerDeck.Add（randKey，fullDeck[randKey]）；
全甲板。移除（randKey）；
}
计算机甲板=全甲板；

您需要随机while循环，该循环将持续分配，直到所有卡都未分配。。获得下一张随机牌并分配给下一个玩家-for循环可能不起作用，因为在大多数情况下随机类不够随机cases@un-幸运的是，当我试着快速、友好、快速地回应时，就会发生这种情况。我支持