Best way to randomize an array with .NET

后端 未结 17 861
隐瞒了意图╮
隐瞒了意图╮ 2020-11-22 01:55

What is the best way to randomize an array of strings with .NET? My array contains about 500 strings and I\'d like to create a new Array with the same strings b

相关标签:
17条回答
  • 2020-11-22 02:24
            int[] numbers = {0,1,2,3,4,5,6,7,8,9};
            List<int> numList = new List<int>();
            numList.AddRange(numbers);
    
            Console.WriteLine("Original Order");
            for (int i = 0; i < numList.Count; i++)
            {
                Console.Write(String.Format("{0} ",numList[i]));
            }
    
            Random random = new Random();
            Console.WriteLine("\n\nRandom Order");
            for (int i = 0; i < numList.Capacity; i++)
            {
                int randomIndex = random.Next(numList.Count);
                Console.Write(String.Format("{0} ", numList[randomIndex]));
                numList.RemoveAt(randomIndex);
            }
            Console.ReadLine();
    
    0 讨论(0)
  • 2020-11-22 02:26

    If you're on .NET 3.5, you can use the following IEnumerable coolness:

    Random rnd=new Random();
    string[] MyRandomArray = MyArray.OrderBy(x => rnd.Next()).ToArray();    
    

    Edit: and here's the corresponding VB.NET code:

    Dim rnd As New System.Random
    Dim MyRandomArray = MyArray.OrderBy(Function() rnd.Next()).ToArray()
    

    Second edit, in response to remarks that System.Random "isn't threadsafe" and "only suitable for toy apps" due to returning a time-based sequence: as used in my example, Random() is perfectly thread-safe, unless you're allowing the routine in which you randomize the array to be re-entered, in which case you'll need something like lock (MyRandomArray) anyway in order not to corrupt your data, which will protect rnd as well.

    Also, it should be well-understood that System.Random as a source of entropy isn't very strong. As noted in the MSDN documentation, you should use something derived from System.Security.Cryptography.RandomNumberGenerator if you're doing anything security-related. For example:

    using System.Security.Cryptography;
    

    ...

    RNGCryptoServiceProvider rnd = new RNGCryptoServiceProvider();
    string[] MyRandomArray = MyArray.OrderBy(x => GetNextInt32(rnd)).ToArray();
    

    ...

    static int GetNextInt32(RNGCryptoServiceProvider rnd)
        {
            byte[] randomInt = new byte[4];
            rnd.GetBytes(randomInt);
            return Convert.ToInt32(randomInt[0]);
        }
    
    0 讨论(0)
  • 2020-11-22 02:27

    Jacco, your solution ising a custom IComparer isn't safe. The Sort routines require the comparer to conform to several requirements in order to function properly. First among them is consistency. If the comparer is called on the same pair of objects, it must always return the same result. (the comparison must also be transitive).

    Failure to meet these requirements can cause any number of problems in the sorting routine including the possibility of an infinite loop.

    Regarding the solutions that associate a random numeric value with each entry and then sort by that value, these are lead to an inherent bias in the output because any time two entries are assigned the same numeric value, the randomness of the output will be compromised. (In a "stable" sort routine, whichever is first in the input will be first in the output. Array.Sort doesn't happen to be stable, but there is still a bias based on the partitioning done by the Quicksort algorithm).

    You need to do some thinking about what level of randomness you require. If you are running a poker site where you need cryptographic levels of randomness to protect against a determined attacker you have very different requirements from someone who just wants to randomize a song playlist.

    For song-list shuffling, there's no problem using a seeded PRNG (like System.Random). For a poker site, it's not even an option and you need to think about the problem a lot harder than anyone is going to do for you on stackoverflow. (using a cryptographic RNG is only the beginning, you need to ensure that your algorithm doesn't introduce a bias, that you have sufficient sources of entropy, and that you don't expose any internal state that would compromise subsequent randomness).

    0 讨论(0)
  • 2020-11-22 02:28

    The following implementation uses the Fisher-Yates algorithm AKA the Knuth Shuffle. It runs in O(n) time and shuffles in place, so is better performing than the 'sort by random' technique, although it is more lines of code. See here for some comparative performance measurements. I have used System.Random, which is fine for non-cryptographic purposes.*

    static class RandomExtensions
    {
        public static void Shuffle<T> (this Random rng, T[] array)
        {
            int n = array.Length;
            while (n > 1) 
            {
                int k = rng.Next(n--);
                T temp = array[n];
                array[n] = array[k];
                array[k] = temp;
            }
        }
    }
    

    Usage:

    var array = new int[] {1, 2, 3, 4};
    var rng = new Random();
    rng.Shuffle(array);
    rng.Shuffle(array); // different order from first call to Shuffle
    

    * For longer arrays, in order to make the (extremely large) number of permutations equally probable it would be necessary to run a pseudo-random number generator (PRNG) through many iterations for each swap to produce enough entropy. For a 500-element array only a very small fraction of the possible 500! permutations will be possible to obtain using a PRNG. Nevertheless, the Fisher-Yates algorithm is unbiased and therefore the shuffle will be as good as the RNG you use.

    0 讨论(0)
  • 2020-11-22 02:30

    Ok, this is clearly a bump from my side (apologizes...), but I often use a quite general and cryptographically strong method.

    public static class EnumerableExtensions
    {
        static readonly RNGCryptoServiceProvider RngCryptoServiceProvider = new RNGCryptoServiceProvider();
        public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> enumerable)
        {
            var randomIntegerBuffer = new byte[4];
            Func<int> rand = () =>
                                 {
                                     RngCryptoServiceProvider.GetBytes(randomIntegerBuffer);
                                     return BitConverter.ToInt32(randomIntegerBuffer, 0);
                                 };
            return from item in enumerable
                   let rec = new {item, rnd = rand()}
                   orderby rec.rnd
                   select rec.item;
        }
    }
    

    Shuffle() is an extension on any IEnumerable so getting, say, numbers from 0 to 1000 in random order in a list can be done with

    Enumerable.Range(0,1000).Shuffle().ToList()
    

    This method also wont give any surprises when it comes to sorting, since the sort value is generated and remembered exactly once per element in the sequence.

    0 讨论(0)
  • 2020-11-22 02:31

    Randomizing the array is intensive as you have to shift around a bunch of strings. Why not just randomly read from the array? In the worst case you could even create a wrapper class with a getNextString(). If you really do need to create a random array then you could do something like

    for i = 0 -> i= array.length * 5
       swap two strings in random places
    

    The *5 is arbitrary.

    0 讨论(0)
提交回复
热议问题