Melanger n'importe quoi
Contenu du snippet
Le principe est simple : vous avez un tableau de n'importe quoi (chaine de caractères, classe quelconque, ...) et vous voulez mélanger ces éléments.
Fastoche!
C'et un petit prog en C qui mélange en fait un liste d'index (allant de 0 à N-1).
Il suffit alors d'utiliser les index mélangés pour mélanger votre liste. Vous me suivez ?
Bon un exemple ... un jeu de 32 cartes
Ce code est pour VC++ mais il devrait fonctionner avec n'importe quel compilo.
La ligne system("pause") peut poser problème avec certains compilo....enlevez là !
####################################################
Bon maintenant des explications sur l'algo :
Souvent je trouve des mélanges de type "swap". C'est-à-dire qu'on echange deux elements pris au hasard, et on recommence un grand nombre de fois. Le problèmes de ces mélange c'est que un "grand" nombre de fois ne veut pas dire grand chose et qu'en plus ça implique un temps de calcul lui aussi "grand".
Donc cette méthode ne me plait pas trop.
Il y a un autre type de mélange qui consiste à prendre un par un tous les index. Pour chaque index on choisit une place au hasard, et si cette place est deja prise on en cherche une autre au hasard jusqu'à tomber sur une case vide. Le problème de cet algo c'est que les derniers index vont avoir du mal à trouver une place. Puisque par exemple pour le jeu de cartes, la derniere carte n'a qu'une place dispo parmi 32 et celle d'avant n'avait que 2 places sur 32... Donc beaucoup d'itérations en perspective !
Ma méthode est simple : on prend les index un par un et on essaie de les placer au hasard dans une liste d'index. Si la place est libre tant mieux : on la prend, sinon on essaie la case juste après jusqu'à tomber sur une case vide.
Fastoche!
C'et un petit prog en C qui mélange en fait un liste d'index (allant de 0 à N-1).
Il suffit alors d'utiliser les index mélangés pour mélanger votre liste. Vous me suivez ?
Bon un exemple ... un jeu de 32 cartes
Source / Exemple :
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
inline void melange(int* tableau, int nTaille)
{
int i;
for (i = 0; i<nTaille; i++)
tableau[i] = -1;
for (i = 0; i<nTaille; i++)
{
int nPos = rand() % nTaille;
while (tableau[nPos%nTaille] != -1)
nPos++;
tableau[nPos%nTaille] = i;
}
}
#define TAILLE 32
int main(int argc, char* argv[])
{
srand( (unsigned)time( NULL ) );
int nIndex[TAILLE];
melange(nIndex, TAILLE);
char* cartes[TAILLE] = {
"Sept de pique",
"Sept de coeur",
"Sept de carreau",
"Sept de trefle",
"Huit de pique",
"Huit de coeur",
"Huit de carreau",
"Huit de trefle",
"Neuf de pique",
"Neuf de coeur",
"Neuf de carreau",
"Neuf de trefle",
"Dix de pique",
"Dix de coeur",
"Dix de carreau",
"Dix de trefle",
"Valet de pique",
"Valet de coeur",
"Valet de carreau",
"Valet de trefle",
"Dame de pique",
"Dame de coeur",
"Dame de carreau",
"Dame de trefle",
"Roi de pique",
"Roi de coeur",
"Roi de carreau",
"Roi de trefle",
"As de pique",
"As de coeur",
"As de carreau",
"As de trefle"
};
for (int i=0; i<TAILLE; i++)
printf("%s\n", cartes[nIndex[i]]);
system("pause");
return 0;
}
Conclusion :
Ce code est pour VC++ mais il devrait fonctionner avec n'importe quel compilo.
La ligne system("pause") peut poser problème avec certains compilo....enlevez là !
####################################################
Bon maintenant des explications sur l'algo :
Souvent je trouve des mélanges de type "swap". C'est-à-dire qu'on echange deux elements pris au hasard, et on recommence un grand nombre de fois. Le problèmes de ces mélange c'est que un "grand" nombre de fois ne veut pas dire grand chose et qu'en plus ça implique un temps de calcul lui aussi "grand".
Donc cette méthode ne me plait pas trop.
Il y a un autre type de mélange qui consiste à prendre un par un tous les index. Pour chaque index on choisit une place au hasard, et si cette place est deja prise on en cherche une autre au hasard jusqu'à tomber sur une case vide. Le problème de cet algo c'est que les derniers index vont avoir du mal à trouver une place. Puisque par exemple pour le jeu de cartes, la derniere carte n'a qu'une place dispo parmi 32 et celle d'avant n'avait que 2 places sur 32... Donc beaucoup d'itérations en perspective !
Ma méthode est simple : on prend les index un par un et on essaie de les placer au hasard dans une liste d'index. Si la place est libre tant mieux : on la prend, sinon on essaie la case juste après jusqu'à tomber sur une case vide.
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.