Is this shuffle algorithm right? - ruby

Question

The following is the shuffle algorithm I implemented in ruby:
def shuffle03!(arr)
len = arr.length
for i in 0..len-1
index1 = Random.rand(0..len-1)
index2 = Random.rand(0..len-1)
arr[index1], arr[index2] = arr[index2], arr[index1]
end
end
I tested this algorithm by reckoning:
class ShuffleTest
def initialize(seed)
len = seed.length
#count = {}
for i in 0..len-1
#count[seed[i]] = Array.new(len, 0)
end
end
def test(arr)
for i in 0...arr.length
#count[arr[i]][i] += 1
end
end
def show_count
return #count
end
end
def shuffle03!(arr)
len = arr.length
for i in 0..len-1
index1 = Random.rand(0..len-1)
index2 = Random.rand(0..len-1)
arr[index1], arr[index2] = arr[index2], arr[index1]
end
end
arr = ['a', 'b', 'c', 'd']
st = ShuffleTest.new(arr)
for x in 0..100_0000
shuffle03!(arr)
st.test(arr)
end
st.show_count.each do |k, v|
puts k
p v
end
the result was :
a
[250418, 249105, 249553, 250925]
b
[249372, 250373, 250785, 249471]
c
[250519, 250097, 249369, 250016]
d
[249692, 250426, 250294, 249589]
It semms to be correct. However, I donnot know how to prove it with mathematical statistics. So I'm not sure it is correct.

Answer 1

No, it is not right.
Imagine that you have a four-element list, [A,B,C,D]. Observe that:
There are 4! = 24 possible permutations. For this to be a correct shuffling algorithm, each of these permutations needs to be equally likely.
You are generating 4×2 = 8 random integers, each in the range 0–3, for a total of 48 = 65,536 possible sequences of random numbers. Each of these sequences is equally likely.
65,536 is not divisible by 24, so there is no way that your algorithm can map the 65,536 possible random-number sequences to permutations in a way that assigns an equal number of random-number sequences (and hence an equal probability) to each permutation.
To see this in a test, you can create a variant of your shuffle03! that, instead of using a random-generator, takes a list of eight indices, and uses those. (shuffle03! could then be implemented by generating eight random indices and then calling this variant as a helper-function.) Your test would then iterate over all 4096 possible sequences, and for each one, create a four-element list [A,B,C,D] and then call the variant method to see the resulting permutation. The test can keep count of how often each permutation appears, and use this to find which permutations appear more times than others. What you'll find is:
Permutation # of Occurrences
------------- ------------------
A B C D 4480
A B D C 3072
A C B D 3072
A C D B 2880
A D B C 2880
A D C B 3072
B A C D 3072
B A D C 2432
B C A D 2880
B C D A 2048
B D A C 2048
B D C A 2880
C A B D 2880
C A D B 2048
C B A D 3072
C B D A 2880
C D A B 2432
C D B A 2048
D A B C 2048
D A C B 2880
D B A C 2880
D B C A 3072
D C A B 2048
D C B A 2432
As you can see, elements tend to end up in the same order they started; for example, A B C D is the most common permutation. We can pull out one aspect of this by seeing, for each pair of elements, how often they end up in the same order vs. the opposite order. We find:
Elements Same Order Opposite Order
---------- ------------ ----------------
A and B 33792 31744
A and C 34816 30720
A and D 35840 29696
B and C 33792 31744
B and D 34816 30720
C and D 33792 31744
So some pairs are more likely than others to end up in the opposite order, but each pair is more likely to end up in the same order than to end up in the opposite order.
You can reduce the imbalance by performing more passes, but since no power of 8 is divisible by 24, it will never be possible to make all permutations equally likely.
By the way, if your actual goal here is a good shuffle algorithm (rather than just the learning experience of figuring one out for yourself), then you should use a Fisher–Yates shuffle.
Of course, since you're using Ruby, you can bypass the whole issue by just using Array.shuffle!, which performs the Fisher–Yates shuffle for you.

Answer 2

I would like to suggest a Ruby-way of achieving your objective.
Evidently, you cannot use Array#shuffle but (thankfully!) can use Kernel#rand. (I assume you can't use Array#sample either, as: arr.sample(arr.size) has the same effect as arr.shuffle.)
There are many ways to implement shuffle that are statistically valid (on the assumption that rand(n) produces truly random numbers between 0 and n-1, which of course is not possible, but that's a reasonable assumption). Here's one way:
class Array
def shuffle
arr = self.dup
map { arr.delete_at(rand(arr.size)) }
end
end
Let's try it with:
arr = [4,:a,5,6,'b',7,8]
arr.shuffle #=> [6, 8, "b", 5, 4, :a, 7]
arr.shuffle #=> [5, :a, 8, 4, "b", 7, 6]
arr.shuffle #=> [6, 8, 5, 7, "b", :a, 4]
arr.shuffle #=> [6, 4, 7, 8, 5, :a, "b"]
arr.shuffle #=> [:a, 4, "b", 5, 7, 8, 6]
arr.shuffle #=> ["b", 4, 7, 8, :a, 6, 5]