Javascript 字符串中的加扰字符，是否所有可能的排列都一样？

Question

I am currently working on a simple function that will scramble an inputted string where all possible permutations are equally likely . My code is below.

function scramble(s) {
    result = s.split("");
    for(var i = 0; i < s.length; i++) {
        var j = Math.floor(Math.random() * (i + 1));
        var scrambler = result[i];
        result[i] = result[j];
        result[j] = scrambler;
    }
    return result.join("");
}

So far, the code seems to be working fine... But will all possible permutations be equally likely? (I believe in Math.random and Math.floor, but I'm getting weird outputs when I look at i and j during runtime.)

Answer 1

Unless I have a horrible mistake here (please check that it makes sense), I believe this code will not create uniformly distributed permutations.

Check for eg the chance that the first char will stay in place - when i is 0, it can't be replaced with anyone, when i is 1, elements 0 and 1 would have 50% chance of swapping, and so on. So in total, result[0] will remain in its place at probability 1/2 * 2/3 * 3/4 ... n-1/n = 1/n

However, the last elements' probability to stay in place is simply (n-1)/n, since you only have one chance to swap it and you choose from the entire array.

You might have a better distribution if you replace the (i+1) with s.length , but the best bet is to take something known to work. You can start here - http://en.wikipedia.org/wiki/Random_permutation

Answer 2

Deep necro-posting because I had a similar question and this is the first result when searching. My gut reaction was the same as other replies, but after looking at it more closely OPs solution appears to be a valid variation of Fisher-Yates.

Let's walk through an example using OPs implementation.

Suppose that S = [1,2,3,4].

First iteration: i === 0, j must equal 0. No swaps are done. You can skip this loop.

Second iteration: i === 1, j can be either 0 or 1.

[1,2,3,4] (j === 1, no swap so same as original),
[2,1,3,4] (j === 0, swap),

Notice that [0-1] result in equal probability of all variations of 0,1

Third iteration: i === 2, j can either equal 0,1,2.

[1,2,3,4], [2,1,3,4] (j === 2, no swap so same as previous results),
[1,3,2,4], [2,3,1,4] (j === 1, swaps),
[3,2,1,4], [3,1,2,4] (j === 0, swaps),

Notice that [0-2] result in equal probability of all variations of 0,1,2

Fourth iteration: i === 3, j can either equal 0,1,2,3.

[1,2,3,4], [2,1,3,4], [1,3,2,4], [2,3,1,4], [3,2,1,4], [3,1,2,4] (j === 3, no swap so same as previous results),
[1,2,4,3], [2,1,4,3], [1,3,4,2], [2,3,4,1], [3,2,4,1], [3,1,4,2] (j === 2, swaps),
[1,4,3,2], [2,4,3,1], [1,4,2,3], [2,4,1,3], [3,4,1,2], [3,4,2,1] (j === 1, swaps),
[4,2,3,1], [4,1,3,2], [4,3,2,1], [4,3,1,2], [4,2,1,3], [4,1,2,3] (j === 0, swaps),

Notice here again that the result is all permutations of the string in equal probability!

Comparison to Fisher Yates shuffle

The reason this works follows very similar reasoning to "the modern algorithm" described in the linked wiki

for i from n−1 down to 1 do
     j ← random integer such that 0 ≤ j ≤ i
     exchange a[j] and a[i]

Op is performing the same operations on each element (j is set to between 0 and i), and looping in the opposite direction. Whether the swapping of each element is done first or last doesn't change the outcome.

Both OPs implementation and Fisher Yates share the reasoning pitfall that @leeor has posted. Even though there is the diminishing probability of an element being swapped, each element has an equal probability of being swapped into each position giving us the desired result.