Question

扑克牌有52张牌，因此52!或大约2^226可能排列。

现在我想完美地洗牌这样一副牌，真正随机的结果和均匀的分布，这样你就可以达到每一个可能的排列，每个都可能出现。

为什么这实际上是必要的？

对于游戏，也许你并不需要完美的随机性，除非有钱可以获胜。除此之外，人类可能甚至不会察觉到随机性的“差异”。

但是如果我没弄错的话，如果你使用通常内置于流行编程语言中的混洗函数和RNG组件，你通常会获得不超过32位的熵和2^32状态。因此，当你洗牌时，你永远无法达到所有52!可能的牌组排列，但仅限于......

0.000000000000000000000000000000000000000000000000000000005324900157％

...可能的排列。这意味着在理论上可以可以播放或模拟的所有可能游戏中的许多游戏在实践中永远不会被看到。

顺便说一句，如果您在每次洗牌之前没有重置为默认顺序，而是从最后一次随机播放的顺序开始，或者在游戏播放后保持“乱七八糟”，则可以进一步改善结果从那里洗牌。

要求：

因此，为了做上述内容，根据我的理解，人们需要以下三个组成部分：

一种良好的混洗算法，可确保均匀分布。
具有至少226位内部状态的适当RNG。由于我们在确定性机器上，PRNG将是我们所能获得的，也许这应该是CSPRNG。
具有至少226位熵的随机种子。

解决方案：

现在这可以实现吗？我们有什么？

Fisher-Yates shuffle会很好，据我所见。
xorshift7 RNG具有超过所需的226位内部状态，应该足够了。
使用window.crypto.getRandomValues我们可以生成所需的226位熵作为我们的种子。如果仍然不够，我们可以添加更多熵from other sources。

问题：

上述解决方案（以及要求）是否正确？那么如何在实践中使用JavaScript中的这些解决方案实现改组呢？如何将这三个组件组合成一个可行的解决方案？

我想我必须通过调用xorshift7来替换Fisher-Yates shuffle示例中Math.random的用法。但是RNG输出[0, 1)浮点范围内的值，而我需要[1, n]整数范围。缩放该范围时，我不想失去均匀分布。而且，我想要大约226位的随机性。如果我的RNG仅输出一个Number，那么随机性是否有效地减少到2 ^ 53（或2 ^ 64）位，因为输出没有更多的可能性？

为了生成RNG的种子，我想做这样的事情：

var randomBytes = generateRandomBytes(226);

function generateRandomBytes(n) {
    var data = new Uint8Array(
        Math.ceil(n / 8)
    );
    window.crypto.getRandomValues(data);

    return data;
}

这是对的吗？我不知道如何以任何方式将randomBytes作为种子传递给RNG，我不知道如何修改它以接受它。

Answer 1

这是我编写的一个函数，它使用基于window.crypto的随机字节的Fisher-Yates混洗。由于Fisher-Yates要求在不同的范围内生成随机数，因此它以6位掩码（mask=0x3f）开始，但随着所需范围变小，逐渐减少此掩码中的位数（即，每当i是2的幂时。

function shuffledeck() {
    var cards = Array("A♣️","2♣️","3♣️","4♣️","5♣️","6♣️","7♣️","8♣️","9♣️","10♣️","J♣️","Q♣️","K♣️",
                      "A♦️","2♦️","3♦️","4♦️","5♦️","6♦️","7♦️","8♦️","9♦️","10♦️","J♦️","Q♦️","K♦️",
                      "A♥️","2♥️","3♥️","4♥️","5♥️","6♥️","7♥️","8♥️","9♥️","10♥️","J♥️","Q♥️","K♥️",
                      "A♠️","2♠️","3♠️","4♠️","5♠️","6♠️","7♠️","8♠️","9♠️","10♠️","J♠️","Q♠️","K♠️");
    var rndbytes = new Uint8Array(100);
    var i, j, r=100, tmp, mask=0x3f;

    /* Fisher-Yates shuffle, using uniform random values from window.crypto */
    for (i=51; i>0; i--) {
        if ((i & (i+1)) == 0) mask >>= 1;
        do {
            /* Fetch random values in 100-byte blocks. (We probably only need to do */
            /* this once.) The `mask` variable extracts the required number of bits */
            /* for efficient discarding of random numbers that are too large. */
            if (r == 100) {
                window.crypto.getRandomValues(rndbytes);
                r = 0;
            }
            j = rndbytes[r++] & mask;
        } while (j > i);

        /* Swap cards[i] and cards[j] */
        tmp = cards[i];
        cards[i] = cards[j];
        cards[j] = tmp;
    }
    return cards;
}

对window.crypto图书馆的评估确实值得提出自己的问题，但无论如何......

由window.crypto.getRandomValues()提供的伪随机流应该足够随机用于任何目的，但是由不同浏览器中的不同机制生成。根据{{3}}：

Firefox （v.21 +）使用2013 survey和440位种子。注意：此标准于2015年更新，以删除（可能是后向的）Dual_EC_DRBG椭圆曲线PRNG算法。
Internet Explorer （v。11+）使用NIST SP 800-90支持的算法之一（种子长度=？）
Safari，Chrome和Opera 使用带有1024位种子的BCryptGenRandom流密码。

编辑：

更清洁的解决方案是在Javascript的数组原型中添加通用shuffle()方法：

// Add Fisher-Yates shuffle method to Javascript's Array type, using
// window.crypto.getRandomValues as a source of randomness.

if (Uint8Array && window.crypto && window.crypto.getRandomValues) {
    Array.prototype.shuffle = function() {
        var n = this.length;

        // If array has <2 items, there is nothing to do
        if (n < 2) return this;
        // Reject arrays with >= 2**31 items
        if (n > 0x7fffffff) throw "ArrayTooLong";

        var i, j, r=n*2, tmp, mask;
        // Fetch (2*length) random values
        var rnd_words = new Uint32Array(r);
        // Create a mask to filter these values
        for (i=n, mask=0; i; i>>=1) mask = (mask << 1) | 1;

        // Perform Fisher-Yates shuffle
        for (i=n-1; i>0; i--) {
            if ((i & (i+1)) == 0) mask >>= 1;
            do {
                if (r == n*2) {
                    // Refresh random values if all used up
                    window.crypto.getRandomValues(rnd_words);
                    r = 0;
                }
                j = rnd_words[r++] & mask;
            } while (j > i);
            tmp = this[i];
            this[i] = this[j];
            this[j] = tmp;
        }
        return this;
    }
} else throw "Unsupported";

// Example:
deck = [ "A♣️","2♣️","3♣️","4♣️","5♣️","6♣️","7♣️","8♣️","9♣️","10♣️","J♣️","Q♣️","K♣️",
         "A♦️","2♦️","3♦️","4♦️","5♦️","6♦️","7♦️","8♦️","9♦️","10♦️","J♦️","Q♦️","K♦️",
         "A♥️","2♥️","3♥️","4♥️","5♥️","6♥️","7♥️","8♥️","9♥️","10♥️","J♥️","Q♥️","K♥️",
         "A♠️","2♠️","3♠️","4♠️","5♠️","6♠️","7♠️","8♠️","9♠️","10♠️","J♠️","Q♠️","K♠️"];

deck.shuffle();

Answer 2

将此处的this answer与this answer中的another question结合起来，以下似乎可能是更通用和模块化（虽然不太优化）的版本：

// Fisher-Yates
function shuffle(array) {
    var i, j;

    for (i = array.length - 1; i > 0; i--) {
        j = randomInt(0, i + 1);
        swap(array, i, j);
    }
}

// replacement for:
//     Math.floor(Math.random() * (max - min)) + min
function randomInt(min, max) {
    var range = max - min;
    var bytesNeeded = Math.ceil(Math.log2(range) / 8);
    var randomBytes = new Uint8Array(bytesNeeded);
    var maximumRange = Math.pow(Math.pow(2, 8), bytesNeeded);
    var extendedRange = Math.floor(maximumRange / range) * range;
    var i, randomInteger;

    while (true) {
        window.crypto.getRandomValues(randomBytes);
        randomInteger = 0;

        for (i = 0; i < bytesNeeded; i++) {
            randomInteger <<= 8;
            randomInteger += randomBytes[i];
        }

        if (randomInteger < extendedRange) {
            randomInteger %= range;

            return min + randomInteger;
        }
    }
}

function swap(array, first, second) {
    var temp;

    temp = array[first];
    array[first] = array[second];
    array[second] = temp;
}

Answer 3

我个人认为你可以稍微移出方框。如果您担心随机性问题，可以从random.org（https://api.random.org/json-rpc/1/）查看API密钥，或者通过以下链接解析它：https://www.random.org/integer-sets/?sets=1&num=52&min=1&max=52&seqnos=on&commas=on&order=index&format=html&rnd=new。

当然，您的数据集可能会被拦截，但如果您获得了数十万套数据集，那么随机播放这些数据集就可以了。

使用window.crypto.getRandomValues

3 个答案:

编辑：