Générer N nombres aléatoires et uniques dans une plage

Pour les 6-à partir de-50, je ne suis pas trop sûr que je serais s'inquiéter de l'efficacité puisque la probabilité d'un duplicata est relativement faible (30% sur l'ensemble de mon dos-de-la-enveloppe de calculs). Vous pourriez très facilement se rappeler les précédents numéros, vous auriez générés et de les jeter, quelque chose comme (pseudo-code):

n[0] = rnd(50)
for each i in 1..5:
    n[i] = n[0]
while n[1] == n[0]:
    n[1] = rnd(50)
while n[2] == any of (n[0], n[1]):
    n[2] = rnd(50)
while n[3] == any of (n[0], n[1], n[2]):
    n[3] = rnd(50)
while n[4] == any of (n[0], n[1], n[2], n[3]):
    n[4] = rnd(50)
while n[5] == any of (n[0], n[1], n[2], n[3], n[4]):
    n[5] = rnd(50)

Toutefois, cela ne se décomposent comme vous vous déplacez à partir de 6-de-50-48-de-50, ou de 6 de 6, depuis les doublons commencer à obtenir loin plus probable. C'est parce que le pool de numéros disponibles est plus petit et vous vous retrouvez jeter de plus en plus.

Pour une solution efficace qui vous donne un sous-ensemble de vos valeurs avec zéro possibilité de doublons (et pas inutile, avant de tri), Fisher-Yates est le chemin à parcourir.

dim n[50]                 //gives n[0] through n[9]
for each i in 0..49:
    n[i] = i              //initialise them to their indexes
nsize = 50                //starting pool size
do 6 times:
    i = rnd(nsize)        //give a number between 0 and nsize-1
    print n[i]
    nsize = nsize - 1     //these two lines effectively remove the used number
    n[i] = n[nsize]

Il suffit de sélectionner un nombre aléatoire à partir de la piscine, pour le remplacer par le nombre supérieur de la piscine, puis la réduction de la taille de la piscine, vous obtenez un shuffle sans avoir à se soucier d'un grand nombre de swaps de front.

C'est important si le nombre est élevé en qui il n'a pas d'introduire une inutiles au démarrage de retard.

Par exemple, examiner les éléments suivants banc de vérifier, en choisissant 10-à partir de-10:

<------ n[] ------>
0 1 2 3 4 5 6 7 8 9  nsize  rnd(nsize)  output
-------------------  -----  ----------  ------
0 1 2 3 4 5 6 7 8 9     10           4       4
0 1 2 3 9 5 6 7 8        9           7       7
0 1 2 3 9 5 6 8          8           2       2
0 1 8 3 9 5 6            7           6       6
0 1 8 3 9 5              6           0       0
5 1 8 3 9                5           2       8
5 1 9 3                  4           1       1
5 3 9                    3           0       5
9 3                      2           1       3
9                        1           0       9

Vous pouvez voir la piscine réduire comme vous allez, et, parce que vous êtes toujours en remplacement de l'utilisé avec un inutilisés, vous n'aurez jamais de le répéter.

En utilisant les résultats obtenus à partir de ce que les index dans votre collection de garantir qu'aucun des articles en double seront sélectionnés.

var random = new Random();
var intArray = Enumerable.Range(0, 4).OrderBy(t => random.Next()).ToArray();

Ce tableau contient les 5 nombres aléatoires de 0 à 4.

ou

  var intArray = Enumerable.Range(0, 10).OrderBy(t => random.Next()).Take(5).ToArray();

Ce tableau contient les 5 nombres aléatoires entre 0 à 10.

int firstNumber = intArray[0];
int secondNumber = intArray[1];
int thirdNumber = intArray[2];
int fourthNumber = intArray[3];
int fifthNumber = intArray[4];

Dans le cas où il aide à quelqu'un d'autre, je préfère allouer le nombre minimum d'éléments nécessaires. Ci-dessous, j'utilise un HashSet, ce qui garantit que les nouveaux objets sont uniques. Cela devrait fonctionner avec de très grandes collections ainsi, jusqu'à la limite de ce HashSet joue de nice avec de.

    public static IEnumerable<int> GetRandomNumbers(int numValues, int maxVal)
    {
        var rand = new Random();
        var yieldedValues = new HashSet<int>();

        int counter = 0;
        while (counter < numValues)
        {
            var r = rand.Next(maxVal);
            if (yieldedValues.Add(r))
            {
                counter++;
                yield return r;
            }
        }
    }