Comment créer un nombre aléatoire à partir de la matrice de

Je fais du C# de codage. Dans mon codage, j'ai besoin de générer aléatoirement une liste de nombres. Normalement, si nous créons un hasard, nous avons besoin de sélectionner la gamme du numéro. Cependant, pour mon cas, j'ai besoin de créer un nombre aléatoire à partir d'un tableau. Une idée? Je suis en XAML et C#.

private void Submit_Click(object sender, RoutedEventArgs e)
    {         
        int[] numbers = new int[5] {32, 67, 88, 13, 50};
        Random rd = new Random();
        //int myNo = rd.Next(numbers[])?                    
    }

SUPPLÉMENTAIRE: Chaque fois que je clique sur le bouton submit, un nombre aléatoire de nombres[] sera sélectionné. Comment puis-je être sûr que le nombre n'est pas répété. Par exemple: 1er clic, myNo = 67; 2e cliquez sur, myNo = 50; 3e cliquez sur, myNo = 88; 4e cliquez sur, myNo = 32; 5e cliquez, myNo = 13. Merci!

Merci de lire stackoverflow.com/questions/767999/... et aussi de clarifier les résultats attendus de rd.Next(numbers)
Que signifie "un nombre aléatoire à partir d'un tableau"? Avez-vous besoin d'un tableau de nombres aléatoires? Un nombre aléatoire pour chaque élément d'un tableau? Comment est le nombre aléatoire lié à la matrice? Faut-il une certaine répétabilité? Pourquoi ne pas simplement créer un nombre aléatoire? ...

OriginalL'auteur 0070 | 2013-04-22

c#random

12

Vous pouvez créer un nombre aléatoire whihch représenterait l'index à partir de la matrice. Accéder à l'élément du tableau à partir de ce hasard de l'index et vous obtiendrez votre numéro, depuis tous vos numéros dans le tableau semble être distinctes.
```
int[] numbers = new int[5] { 32, 67, 88, 13, 50 };
Random rd = new Random();
int randomIndex = rd.Next(0, 5);
int randomNumber = numbers[randomIndex];
```
EDIT:
(Merci à @Corak)
Vous pouvez générer des Index en fonction de la longueur du tableau, qui permettrait de la rendre dynamique et de travailler pour n'importe quel tableau de la longueur.
```
int randomIndex = rd.Next(0, numbers.Length);
```
Edit 2: (Pour plus de partie de la question).

Vous avez besoin pour maintenir une liste des numéros d'index au niveau de la classe. Ainsi, votre code serait quelque chose comme:
```
Random rd = new Random(); //At class level
List<int> uniqueIndices = new List<int>(); //At class level
private void Submit_Click(object sender, RoutedEventArgs e)
{         
    int[] numbers = new int[5] {32, 67, 88, 13, 50};
    int randomIndex = rd.Next(0, numbers.Length);
    while(list.Contains(randomIndex)) //check if the item exists in the list or not. 
    {
        randomIndex = rd.Next(0, numbers.Length);
    }
    list.Add(randomInex);
    //...rest of your code. 


}
```
vous avez raison
Je te suggère de se débarrasser de la 5: int[] numbers = new int[] { 32, 67, 88, 13, 50 }; (peut-être même var numbers = new[] { 32, 67, 88, 13, 50 }) et int randomIndex = rd.Next(0, numbers.Length);
c'est une bonne idée et serait utile pour l'OP, pour toute longueur de tableau.
thx pour le tableau.longueur!! btw, je mets à jour ma question, n'hésitez pas à jeter un oeil. C=
J'ai édité la réponse, elle est généralement une bonne pratique si vous vous posez tous la question dans le premier rendez-vous, puisque ce n'est pas comme un forum.

OriginalL'auteur Habib
3
```
Random r = new Random();
int index = r.Next(0, 5);

int randomNum = numbers[index];
```
Cela vous donnera des nombres aléatoires entre 0 et 4, qui peut être utilisé pour indexer votre tableau et à son tour de tirer des valeurs aléatoires à partir de la matrice de

OriginalL'auteur TGH

Ici est une façon paramétrique:

randIndex = rd.Next(0, numbers.Length);
int myNo = numbers[randIndex];

OriginalL'auteur fatihk

Je voudrais créer une classe qui représenterait un hasard énumérable et d'utiliser ensuite l'extension de methond First pour générer le premier indice que vous devez utiliser dans le tableau. Il ressemblerait à quelque chose comme ceci:

class Program
{
    static void Main(string[] args)
    {
        int[] numbers = new int[5] { 32, 67, 88, 13, 50 };
        var randomEnumerable = new RandomEnumerable(0, numbers.Length);
        int i = 0;
        while (i < numbers.Length)
        {
            var nextIndex = randomEnumerable.First();
            var number = numbers[nextIndex];
            Console.WriteLine(number);
            i++;
        }
        Console.ReadLine();
    }
}

class RandomEnumerable : IEnumerable<int>
{
    private readonly int _max;
    private readonly int _min;
    private Random _random;

    public RandomEnumerable(int min, int max)
    {
        _max = max;
        _min = min;
        _random = new Random();
    }

    public IEnumerator<int> GetEnumerator()
    {
        while (true)
        {
            yield return _random.Next(_min, _max);
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

C'est une réponse complète - +1
J'essaie de mon mieux 🙂

OriginalL'auteur Tomas Jansson

0

Il suffit de créer un hasard index comme d'habitude, et index dans le tableau avec la valeur au lieu de retourner directement.

OriginalL'auteur Pieter Geerkens
0

Vous devez générer des index de tableau au hasard pour obtenir un nombre aléatoire à partir de votre tableau.

il suffit d'appliquer la fonction de lecture aléatoire pour générer des nombres entre la plage de l'index de tableau(0, array.length - 1)

OriginalL'auteur tausun
0

Vous pouvez créer un nombre Aléatoire, puis utilisez l'opérateur mod % par 5 et de l'utiliser comme index de votre tableau.

Par exemple.
modRd = rd % 5; randomNumber = numbers[modRd];

OriginalL'auteur Nashibukasan

Cela va créer un aléatoire et unique numéro de la matrice

 public class Shuffler
 {
    Random randomNumber;
    public Shuffler()
    {
        randomNumber = new Random();
    }

    ///<summary>
    ///Shuffling the elements of Array
    ///</summary>
    ///<typeparam name="T"></typeparam>
    ///<param name="array"></param>
    public void Shuffle<T>(IList<T> array)
    {
        for (int n = array.Count; n > 1; )
        {
            int k = randomNumber.Next(n); //returning random number less than the value of 'n'
            --n; //decrease radom number generation area by 1 
             //swap the last and selected values
            T temp = array[n];
            array[n] = array[k];
            array[k] = temp;
        }
    }
 }

OriginalL'auteur Mogli

Vous pouvez créer une chaîne avec toutes les valeurs combinées et ensuite obtenir le hashcode. Cette hashcode peut ensuite être utilisé pour amorcer le hasard.

À l'aide de la HashCode approche rend le de semences de plus en plus dépendante des données sur une de vous tableau.

    public static void Main()
    {
        int[] numbers = new int[5] { 32, 67, 88, 13, 50 };


        StringBuilder valuesToBeHashed = new StringBuilder();
        for (int i = 0; i < numbers.Length; i++)
        {
            valuesToBeHashed.Append(numbers[i] + ",");
        }

        Random rd = new Random(valuesToBeHashed.GetHashCode());
        Console.WriteLine("Hashcode of Array : {0} ",valuesToBeHashed.GetHashCode());
        Console.WriteLine("Random generated based on hashcode : {0}", rd.Next());
    }

OriginalL'auteur Patrick D'Souza

Vous devez vous connecter pour publier un commentaire.