Question

我目前的爱好项目为法国套牌（52张卡，从2张到Ace牌）的纸牌游戏提供蒙特卡罗模拟。

为了尽可能快地进行模拟，我在一些地方用来表示多张卡作为位掩码。这是一些（简化的）代码：

public struct Card
{
    public enum CardColor : byte { Diamonds = 0, Hearts = 1, Spades = 2, Clubs = 3 }
    public enum CardValue : byte { Two = 0, Three = 1, Four = 2, Five = 3, Six = 4, Seven = 5, Eight = 6, Nine = 7, Ten = 8, Jack = 9, Queen = 10, King = 11, Ace = 12 }

    public CardColor Color { get; private set; }
    public CardValue Value { get; private set; }

    // ID provides a unique value for each card, ranging from 0 to 51, from 2Diamonds to AceClubs
    public byte ID { get { return (byte)(((byte)this.Value * 4) + (byte)this.Color); } }

    // --- Constructors ---
    public Card(CardColor color, CardValue value)
    {
        this.Color = color;
        this.Value = value;
    }
    public Card(byte id)
    {
        this.Color = (CardColor)(id % 4);
        this.Value = (CardValue)((id - (byte)this.Color) / 4);
    }
}

将多张卡片保存为位掩码的结构：

 public struct CardPool
 {
    private const ulong FULL_POOL = 4503599627370495;

    internal ulong Pool { get; private set; } // Holds all cards as set bit at Card.ID position

    public int Count()
    {
        ulong i = this.Pool;
        i = i - ((i >> 1) & 0x5555555555555555);
        i = (i & 0x3333333333333333) + ((i >> 2) & 0x3333333333333333);
        return (int)((((i + (i >> 4)) & 0xF0F0F0F0F0F0F0F) * 0x101010101010101) >> 56);
    }

    public CardPool Clone()
    {
        return new CardPool() { Pool = this.Pool };
    }

    public void Add(Card card)
    {
        Add(card.ID);
    }
    public void Add(byte cardID)
    {
        this.Pool = this.Pool | ((ulong)1 << cardID);
    }

    public void Remove(Card card)
    {
        Remove(card.ID);
    }
    public void Remove(byte cardID)
    {
        this.Pool = this.Pool & ~((ulong)1 << cardID);
    }

    public bool Contains(Card card)
    {
        ulong mask = ((ulong)1 << card.ID);
        return (this.Pool & mask) == mask;
    }

    // --- Constructor ---
    public CardPool(bool filled)
    {
        if (filled)
            this.Pool = FULL_POOL;
        else
            this.Pool = 0;
    }

}

我想从第二个struct CardPool 中随机抽取一张或多张卡片，但我无法想象如何在不迭代池中的单个位的情况下执行此操作。是否有任何已知的算法来执行此操作？如果没有，你有任何想法快速做到这一点吗？

更新：该结构不是为了从中抽取所有卡片。它经常被克隆，克隆数组是没有选择的。我真的想到用于绘制一张或多张牌的比特操作。

UPDATE2 ：我写了一个类，把卡片作为List进行比较。

public class CardPoolClass
{
    private List<Card> Cards;
    public void Add(Card card)
    {
        this.Cards.Add(card);
    }

    public CardPoolClass Clone()
    {
        return new CardPoolClass(this.Cards);
    }

    public CardPoolClass()
    {
        this.Cards = new List<Card> { };
    }
    public CardPoolClass(List<Card> cards)
    {
        this.Cards = cards.ToList();
    }
}

比较完整套牌的1.000.000克隆操作： - struct：17 ms - 等级：73毫秒

承认：差异并不像我想象的那么多。但考虑到我还放弃了对预先计算值的简单查找，这会产生很大的不同。当然，用这个类绘制随机卡会更快，但我必须计算一个查找索引，然后将问题转移到另一个地方。

我重复我的初步问题：是否有一种已知的算法可以从整数值中选择一个随机设置位，或者有人想要更快地完成这项操作而不是迭代所有位？

关于使用带有List或数组的类的讨论使我们无处可去，这不是我的问题，如果我最好使用类，我可以自己详细说明。

Update3 ，查找代码：

CODE DELETED：这可能会产生误导，因为它没有引用性能受到主题影响的段落。

Answer 1

由于同一张卡不能连续两次绘制，你可以将每张卡（在你的情况下，Pool的设置位的索引）放在一个数组中，随机播放，并弹出一张卡片从这个数组的任何一端开始。

这是一个伪代码（因为我不知道C＃）。

declare cards as an array of indices

for each bit in Pool
    push its index into cards

shuffle cards

when a card needs to be drawn
    pop an index from cards
    look up the card with Card(byte id)

修改

这是一种在64位整数中获取一次随机设置位的算法，使用来自Bit Twiddling Hacks的代码来获取具有给定等级的位的位置（更多有效设置位的数量）。

ulong v = this.Pool; // ulong a = (v & ~0UL/3) + ((v >> 1) & ~0UL/3); ulong a = v - ((v >> 1) & ~0UL/3); // ulong b = (a & ~0UL/5) + ((a >> 2) & ~0UL/5); ulong b = (a & ~0UL/5) + ((a >> 2) & ~0UL/5); // ulong c = (b & ~0UL/0x11) + ((b >> 4) & ~0UL/0x11); ulong c = (b + (b >> 4)) & ~0UL/0x11; // ulong d = (c & ~0UL/0x101) + ((c >> 8) & ~0UL/0x101); ulong d = (c + (c >> 8)) & ~0UL/0x101; ulong t = (d >> 32) + (d >> 48); int bitCount = ((c * (~0UL / 0xff)) >> 56); ulong r = Randomizer.Next(1, bitCount+1); ulong s = 64; // if (r > t) {s -= 32; r -= t;} s -= ((t - r) & 256) >> 3; r -= (t & ((t - r) >> 8)); t = (d >> (s - 16)) & 0xff; // if (r > t) {s -= 16; r -= t;} s -= ((t - r) & 256) >> 4; r -= (t & ((t - r) >> 8)); t = (c >> (s - 8)) & 0xf; // if (r > t) {s -= 8; r -= t;} s -= ((t - r) & 256) >> 5; r -= (t & ((t - r) >> 8)); t = (b >> (s - 4)) & 0x7; // if (r > t) {s -= 4; r -= t;} s -= ((t - r) & 256) >> 6; r -= (t & ((t - r) >> 8)); t = (a >> (s - 2)) & 0x3; // if (r > t) {s -= 2; r -= t;} s -= ((t - r) & 256) >> 7; r -= (t & ((t - r) >> 8)); t = (v >> (s - 1)) & 0x1; // if (r > t) s--; s -= ((t - r) & 256) >> 8; s--; // s is now the position of a random set bit in v

注释行创建另一个版本，带有分支。如果要比较两个版本，请取消注释这些行并注释它们后面的行。

在原始代码中，最后一行是s = 65 - s，但由于您使用1 << cardID进行卡片组操作，r无论如何都是随机的，s--给出了正确的价值。

唯一需要注意的是v的零值。但是，无论如何，在空池上执行此代码将毫无意义。

有效的方法来随机选择设置位

1 个答案: