快速生成唯一整数

背景

我正在写一个Cribbage统计计算器。起初，我让它计算每一只可能的5张牌手的点值，并将其与维基百科进行核对，直到我的数字与他们的数字相同。

现在我正在计算每一对可能的双手(你的手和婴儿床(，大约2.3万亿的组合，所以优化是关键。

代码

所有卡片的编号都在0到51之间。Hand构造函数采用长度为5的int[]，并假定最后一张卡是起始卡。现在所有的点数计算代码都处理好了，我想优化手牌号码的生成过程。

现在我有：

private static IEnumerable<Tuple<int[], int[]>> GetTwoHands()
{
    bool[] avail = new bool[52];
    for (int i = 0; i < 52; i++)
    {
        avail[i] = true;
    }
    // hand 1 cards
    for (int i = 0; i < 52; i++)
    {
        avail[i] = false;
        for (int j = i + 1; j < 52; j++)
        {
            avail[j] = false;
            for (int k = j + 1; k < 52; k++)
            {
                avail[k] = false;
                for (int l = k + 1; l < 52; l++)
                {
                    avail[l] = false;
                    // hand 2 (crib) cards
                    for (int i2 = 0; i2 < 52; i2++)
                    {
                        if (!avail[i2])
                        {
                            continue;
                        }
                        avail[i2] = false;
                        for (int j2 = i2 + 1; j2 < 52; j2++)
                        {
                            if (!avail[j2])
                            {
                                continue;
                            }
                            avail[j2] = false;
                            for (int k2 = j2 + 1; k2 < 52; k2++)
                            {
                                if (!avail[k2])
                                {
                                    continue;
                                }
                                avail[k2] = false;
                                for (int l2 = k2 + 1; l2 < 52; l2++)
                                {
                                    if (!avail[l2])
                                    {
                                        continue;
                                    }
                                    avail[l2] = false;
                                    // shared starter card
                                    for (int m = 0; m < 52; m++)
                                    {
                                        if (!avail[m])
                                        {
                                            continue;
                                        }
                                        yield return Tuple.Create(new int[] { i, j, k, l, m }, new int[] { i2, j2, k2, l2, m });
                                    }
                                    avail[l2] = true;
                                }
                                avail[k2] = true;
                            }
                            avail[j2] = true;
                        }
                        avail[i2] = true;
                    }
                    avail[l] = true;
                }
                avail[k] = true;
            }
            avail[j] = true;
        }
        avail[i] = true;
    }
}

其中i到l是第一手的卡号，i2到l2是第二手的卡号并且m是起始卡的卡号。显然，手上不可能有重复的牌，所以对于第二手牌，我确保每个卡号都不在手1中。

我使用C#的IEnumerable<T>.AsParallel().ForAll(action)来利用我所有的处理器核心，所以Hand(int[])发生在操作中，而不是同步的GetTwoHands()。

问题

• 有没有一种方法可以在不牺牲性能的情况下清理所有这些循环？我怀疑，尽管还没有测试，递归会因为所有的函数调用而减慢速度
• 有没有更快的算法来生成这些数字