Random number generator, pick 3 in a range, returns group of 2 in some iterations

Question

i put a random number generator together using Linq. the range of those random numbers needs to be in this case 1-6 inclusive. i want groups of 3 distinct numbers chosen.

i don't understand why this code returns groups that contain only 2 numbers.

        do
        {
            Random rnd = new Random();
            int[] myRndNos = Enumerable
                .Range(1, 6)
                .Select(i => rnd.Next(1, 7))
                .Distinct()
                .Take(3)
                .ToArray();                    

            string test = string.Join(",", myRndNos);

            System.Console.WriteLine(test);
            Console.ReadKey(true);
        } while (true); 

it returns a sample like:

4,6,1
5,2,3
2,4,5
3,2
3,5,1
etc...

why in some cases is it taking only 2 numbers? doesn't make sense to me. tx

Answer 1

You are generating 6 random numbers but if those numbers happen to be duplicates the distinct will eliminate them leaving you with only the list on unique values, if there are only 2 unique items then that's all you will get.

Because you want 3 distinct numbers, I think what you are after is a shuffle.

private static Random rnd = new Random(); 

int[] myRndNos = Enumerable.Range(1, 6).OrderBy(i => rnd.Next()).Take(3).ToArray();

or

private static Random rng = new Random(); 

int[] myRndNos = Enumerable.Range(1, 6).Shuffle();

public static void Shuffle<T>(this IList<T> list)  
{  
    int n = list.Count;  
    while (n > 1) {  
        n--;  
        int k = rng.Next(n + 1);  
        T value = list[k];  
        list[k] = list[n];  
        list[n] = value;  
    }  
}

Source of algorithm: Randomize a List<T>

Answer 2

This is because the range that you are generating is not unique numbers

if the range is 2,2,2,6,6,6 the distinct will result as 2 and 6 as you can see in this example

Hope this helps you

Answer 3

Try something like this

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Take3Distinct take3Distinct = new Take3Distinct();
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(string.Join(",", take3Distinct.Take3().ToArray()));
            }
            Console.ReadLine();

        }
    }
    public class Take3Distinct
    {

        const int SIZE = 6;
        Random rand = new Random();
        public List<List<int>> pairs = new List<List<int>>();
        public Take3Distinct()
        {
            for(int i = 1; i <= SIZE; i++)
            {
                List<int> newPair = new List<int>{i, 0};
                pairs.Add(newPair);
            }
        }
        public List<int> Take3()
        {
            foreach (List<int> pair in pairs)
            {
                pair[1] = rand.Next();
            }
            pairs = pairs.OrderBy(x => x[1]).ToList();
            return pairs.Select(x => x[0]).Take(3).ToList();
        }
    }
}

Answer 4

Another option without shuffle is with HashSet

var rnd = new Random();
var myRndNos = new HashSet<int>();
while (myRndNos.Count < 3)
    myRndNos.Add(rnd.Next(1, 7));

Debug.Print(string.Join(",", myRndNos));

Answer 5

This is my shuffle extension. It's basically identical in concept to @Daniel's shuffle algorithm, but it has some additional features:

1. It will yield return an enumerable, which means you actually only need to randomize as many elements as you actually use (e.g. if you do Enumerable.Range(0,100).ToList().Shuffle().Take(5) it actually only randomizes the 5 elements you need, without shuffling the whole array.
2. Minor optimization to ignore the element swap if the source and target elements are the same.
3. Option to do either a destructive (i.e. a shuffle modifying the source list) or non-destructive shuffle. The non-destructive shuffle basically generates a list of indices and destructively shuffles that.
4. Returns IEnumerable<T> so it can be used in a longer expression, such as with .Take() as mentioned.

My extension class for shuffling:

public static class ListShuffle
{
    private static Random _random = new Random();

    public static IEnumerable<T> ShuffleInPlace<T>(this IList<T> list)
    {
        for (int n = list.Count - 1; n >= 0; n--)
        {
            int randIx = _random.Next(n + 1); // Random int from 0 to n inclusive
            if (randIx != n)
            {
                T temp = list[randIx];
                list[randIx] = list[n];
                list[n] = temp;
            }
            yield return list[n];
        }
    }

    public static IEnumerable<T> Shuffle<T>(this IList<T> list)
    {
        List<int> indices = Enumerable.Range(0, list.Count).ToList();
        foreach (int index in indices.ShuffleInPlace())
        {
            yield return list[index];
        }
    }
}

Answer 6

You are literarily doing rnd.Next(1, 7) 6 times and then DISTINCT and TOP(3); however, it could be "3,3,3,2,2,2" and it will return "3,2" based your codes.

You could use an array (rnd.Next(1, 7).ToArray()) and do random on indexes. When 1 number got hit then replace it with an un-hit number.

for example,

[1,2,3,4,5,6]

Run random and get 3

update array to [1,2,2,4,5,6]

Run random again... ...

you will get 3 distinct numbers with only 3 hits.