Génération de nombres au hasard sans répétition dans tableau en C#

Version imprimable

j'aimerais bien remplir un tableau avec la fonction random mais sans avoir de répétition
j'ai fais ce code mais il fonctionne pas

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
static void Main(string[] args)
        {
            int[] generer = new int[5];
            Random r = new Random();
            for (int i = 0; i < generer.Length; i++)
            {
                generer[i] = r.Next(0, 35);
 
                while (generer[i] == generer[i+1])
                {
                    for(int j = 0; j < generer.Length; j++)
                    {
 
                        generer[j] = r.Next(0, 35);
                        Console.WriteLine(generer[i]);
 
                    }
                }
 
            }

Si l'utilisation de l'objet random n'est pas imposé, alors avec Linq tu peux t'en sortir avec grâce et sans efforts :
Code:

1 2 3 4 5 6 static void Main(string[] args) { var array = Enumerable.Range(0, 10) // la plage de nombres dans ta collection, .OrderBy(x => Guid.NewGuid()) // ordonné par rapport à un guid, .ToArray(); // retour sous la forme d'un tableau. }
Sans link, il faut s'accomoder d'un code qui sera un poil plus rapide à l’exécution (et encore, tout dépend de l’algorithme), mais aussi plus long à écrire et moins lisible.
Dans le cas de ton code, tu sors des limites du tableaux durant ce while :
while (generer[i] == generer[i + 1])

L'index maximal de ton tableau est 4. Si i = 4, alors i + 1 te fera sortir du tableau et générera une erreur de type IndexOutOfRangeExpression.

Tu sembles essayer de faire ton tableau random en pur calcul, sans passer par au moins une variable intermédiaire pour faire du swap. Je ne pense pas que ce soit possible.Un mathématicien serait le bienvenu pour confirmer ou invalider mon propos.

oui en effet j'ai essayé de le faire avec une variable intermédiaire y pas plus d’erreur ,ça me génère des nombres aléatoires ,mais il y a quand même des répétition.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 static void Main(string[] args)
        {
            Random r = new Random();
            int[] generer = new int[5];
 
 
            for (int i = 0; i < generer.Length; i++)
            {
                int lNumber ;
 
 
                do
                {
 
                    lNumber = r.Next(1, 10);
                }
                while (genererr[i]==(lNumber));
                genererr[i] = lNumber;
 
                Console.Write("{0} ",generer[i]);
            }
            Console.ReadLine();

14/03/2018, 03h46
nouanda

C'est normal car tu ne vérifies pas si le nombre existe déjà dans ton tableau.
Au passage, tu as une erreur de logique dans ta boucle while. Je t'invite a faire une exécution pas a pas pour essayer de la trouver! (indice: que contient ton tableau par défaut?).

Pour créer un tableau sans doublon, il y a pleins de solutions:
Utiliser une méthode pour vérifier si les nombre est déjà dans le tableau
Utiliser un tableau externe pour stocker les nombres non déjà utilises et aller piocher dedans
Remplir le tableau avec doublons et utiliser un tableau externe pour remplacer les doublons
Utiliser purement Linq

Les solutions ne manquent pas, a toi de voir celle qui te conviendra le mieux, chacune venant avec ses pour et ses contre.

A mon avis, la première solution (méthode qui vérifie l’unicité) est la plus simple a mettre en oeuvre (si il te faut utiliser des arrays et random bien sur). Elle a cependant un gros caveat que je t'invite a trouver!

Bonjour,

Une solution très simple pour parvenir à tes fins. L'idée est de stocker tes nombres dans un HashSet. Dans une boucle while, tant que la taille de la collection n'atteint pas une limite, tu génères un nombre et tu l'ajoutes.

Ainsi, si le nombre n'est pas dans la collection, il est ajouté, et la taille de la collection augmente de 1. S'il est déjà présent, rien ne se passe (propriété de la collection HashSet) et on passe à l'itération suivante.

A la fin, il reste éventuellement à convertir la collection en tableau, List ou tout autre collection de ton choix.

Et le code pour le faire tient en quelques lignes :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 static void Main(string[] args) { int[] generer = new int[5]; HashSet<int> hashSet = new HashSet(); Random r = new Random(); while(hashSet.Count < generer.Length) { hashSet.Add(r.Next(0, 35); } generer = hashSet.ToArray(); }

merci pour votre réponse.On peut le faire avec deux méthodes aussi

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
static bool nombreunique(int[] tableau, int a)
        {
            foreach (int b in tableau)
                if (a== b)
                    return true;
            return false;
        }
 
        static void generer(int[] tableau)
        {
            int a;
            Random r = new Random();
            for (int d = 0; d < tableau.Length; d++)
            {
                do
                    a = r.Next(0, 53);
                while (nombreunique(tableau, a));
                tableau[i] = a;
            }
        }

Citation:
Envoyé par vitaly24
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 static bool nombreunique(int[] tableau, int a) { foreach (int b in tableau) if (a== b) return true; return false; } static void generer(int[] tableau) { int a; Random r = new Random(); for (int d = 0; d < tableau.Length; d++) { do a = r.Next(0, 53); while (nombreunique(tableau, a)); tableau[i] = a; } }
Méthode fonctionnelle, mais affreusement moche à cause de certains détails.

Le plus gros, est le nom de la méthode nombreunique qui retourne true si le nombre n'est pas unique et false sinon. Bref, cela fait le contraire de ce que son nom suggère. Donc soit il faut changer le nom en un truc style NombrePasUnique, ou alors il faut inverser les conditions.

Le second plus gros, serait d'avoir une convention de nommage. nombreunique est illisible. Il faut avoir une convention permettant de séparer les mots. En C#, classiquement, c'est l'usage d'une majuscule pour la première lettre de chaque mot. Ainsi NombreUnique est déjà beaucoup plus lisible.

Enfin, concernant l'usage des accolades pour les expressions contenant une seule expression, il y a des débats. Mais en général, on accepte qu'il n'y ait pas d'accolades lorsque tout est sur une seule ligne. Dès lorsqu'il y en a plusieurs, il vaut mieux les utiliser, pour des questions de lisibilité et de maintenance du code. La boucle foreach est particulièrement difficile à lire. Et cela évite des erreurs bêtes en cas de modification de code.