Discussion :

[Student_Master]

Bonsoir,

Pourriez-vous m'aider svp !

J'ai un nombre de ressources (nr = 10)
Un nombre de classes (nc = 3)
R[maxC] = tableau contenant la liste des ressources.
Je souhaiterai répartir les 10 ressources dans les trois classes d'une façon aléatoire de telle sorte que chaque classe doit contenir au mois une ressource.

Exp de résultat attendu pour les trois classes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 R[0] = {0, 5, 4, 9}
 R[1] = {1, 2, 8}
 R[2] = {3, 6, 7}

Mon essai :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
int nbr_alea;
  for(c=0; c<nc; c++) // nombre de classes 
 {
     nbr_alea = rand ()% nr;
     R[c] = nbr_alea ;
     nr--;
     cerr << " " << R[c] << endl;
}

Merci.

[bacelar]

Tu vas avoir des doublons et tu n'auras pas de garantie d'avoir au moins une ressource par catégorie (en POO, les classes c'est pas la même chose).

Donc, plutôt que de tirer au hasard la ressource, tu les mélanges :
http://en.cppreference.com/w/cpp/alg...random_shuffle

Mais pour cela, le plus simple c'est d'utiliser des st::vector, aussi bien pour mélanger la liste des ressources que stocker les ressources par catégorie.
http://www.cplusplus.com/reference/vector/vector/

En gros, tu construis un vector avec toutes les ressources, tu le mélange avec random_shuffle.
Tu construis un vector "ListeDeCategorie" contenant autant de catégorie que nécessaire. les éléments de ce vector étant eux-mêmes des vector mais de ressources (int?).

Tu prends les "nc" premiers éléments du vector des ressources après leur mélange et tu les ajoutes à chacun des "nc" premiers éléments de "ListeDeCategorie", la ressource correspondante.

Il ne restera dans le vector des ressources que nr-nc ressources non encore assignées à une catégorie.
Il suffit de faire une boucle sur "nr-nc", et à chaque tour de boucle, tirer un nombre entre 0 et nc pour désigner à quel élément de "ListeDeCategorie" sera affectée la ressource.

Donc, on laisse tomber les tableaux C et on utilise correctement la STL C++.

[Student_Master]

Re,

Je vous expose le problème d'une autre manière.
Supposant que j'ai la matrice de présence du personnel (10 ressources et 10 périodes) suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
1	0	1	0	1	1	0	1	1	1	
1	0	0	1	1	1	1	0	1	0	
0	1	1	0	0	0	0	0	0	1	
1	0	0	0	1	1	0	1	0	1	
1	1	1	1	0	0	0	0	1	1	
1	1	0	0	0	1	0	1	1	0	
1	1	0	0	0	0	0	0	1	1	
0	1	1	0	0	0	0	0	0	1	
1	1	0	0	0	0	0	0	1	1	
1	0	1	0	1	1	0	1	1	1

Chaque ressource a par conséquent un vecteur sur 10 périodes. Une classe contient la liste des ressources qui ont des vecteurs identiques. Afin de créer les classes, on passe par la vérification des vecteurs de toutes les ressources.
Dans un premier cas, on stocke la ressource 0 dans la classe 0. Après, on vérifie si le vecteur de la ressource 0 est identique a celui de la ressource 1. Si c'est identique on stocke la ressource 1 dans la classe 0 sinon on la stocke dans la classe 1. Ainsi de suite jusqu'à la fin.
Le tableau qui contient la liste des classes est donné par R[maxC].
Si on applique cette logique sur cet exemple nous aurons le résultat suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
R[0] = {0,9}
R[1] = {1}
R[2] = {2,7}
R[3] = {3}
R[4] = {4}
R[5] = {5}
R[6] = {6,8}

Merci pour vos propositions.

[bacelar]

Ce problème n'a strictement rien à voir avec le précédant.

Mais la conclusion est strictement la même :

Donc, on laisse tomber les tableaux C et on utilise correctement la STL C++. .

Vous construisez une clé avec le vecteur de chaque ressource.
10 booléens, pour faire une clé, c'est pas trop dur => un bitsfield de 10 qu'on peut facilement simplifier par un int16 et quelque left shift logique (<<).

Chaque catégorie (pas classe SVP, en POO c'est un terme bien loin de celui des maths) a donc une clé unique.

Vous utilisez une multimap (http://www.cplusplus.com/reference/map/multimap/) ou une unordered_multimap (http://www.cplusplus.com/reference/u...ered_multimap/) pour stocker les différentes ressources avec la clé associée à celle-ci.

A la fin, vous aurez les ressources regroupées par catégorie dans la multimap.

Il n'y qu'un calcul de clé et un add dans une map à faire dans une boucle sur les ressources.

C'est donc un exercice faisable en 5 lignes, déclarations comprises.

[Student_Master]

Je vous remercie pour votre réponse. En effet, je n'ai pas trop de connaissances pour coder à votre manière.
Par conséquent, je veux utiliser les tableaux pour deux raisons :
1) Je suis entrain de résoudre un modèle mathématique à l'aide de Cplex. En revanche, j'ai déjà codé 500 lignes de code en utilisant les tableaux et je veux que ça soit cohérents entre eux.
2) Pour suivre votre démarche, ça va me perdre beaucoup de temps pour changer le reste de mon code avec les nouvelles variables.
Si, vous permettez de m'aider à faire ce bout de code avec les tableaux.
En vous remerciant par avance.

[bacelar]

VIREZ VOS TABLEAUX DE MERDE.

Version TABLEAUX DE MERDE

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#include <windows.h>
#include <map>
#include <vector>
#include <algorithm>
...
	int tableauDeMerdeEnEntre[10][10]={
		{1,0,1,0,1,1,0,1,1,1},
		{1,0,0,1,1,1,1,0,1,0},
		{0,1,1,0,0,0,0,0,0,1},
		{1,0,0,0,1,1,0,1,0,1},	
		{1,1,1,1,0,0,0,0,1,1},	
		{1,1,0,0,0,1,0,1,1,0},	
		{1,1,0,0,0,0,0,0,1,1},
		{0,1,1,0,0,0,0,0,0,1},	
		{1,1,0,0,0,0,0,0,1,1},	
		{1,0,1,0,1,1,0,1,1,1}
	};
 
	std::multimap<int,int> mymap;
 
	for(int i = 0 ; i<10 ;i++)
	{
		int key = 0;
 
		for(int j = 0 ; j<10 ;j++)
		{
			key += tableauDeMerdeEnEntre[i][j] << j;
		}
		mymap.insert(std::pair<int,int>(key,i));
	}
 
	std::vector<std::vector<int>> myvector;
 
	int maxCardinalite = 0;
	int nbCategorie = 0;
 
	for( auto iter = mymap.begin() ; iter != mymap.end() ; iter = mymap.upper_bound(iter->first) )
	{
		std::vector<int> mylist;
		for(auto iter2 = iter ; iter2 != mymap.upper_bound(iter->first) ; ++iter2)
		{
			mylist.push_back(iter2->second);
			maxCardinalite = (maxCardinalite > mylist.size()) ? maxCardinalite : mylist.size();
		}
		myvector.push_back(mylist);
		nbCategorie++;
	}
 
	int* tableauDeMerdeEnSortie = (int*)malloc(maxCardinalite*nbCategorie*sizeof(int));
	ZeroMemory(tableauDeMerdeEnSortie,maxCardinalite*nbCategorie*sizeof(int));
 
	std::sort(begin(myvector),end(myvector),[](std::vector<int> a, std::vector<int> b){return a[0]<b[0];});
 
 
	int ligne = 0;
	for( auto& const i : myvector )
	{
		int colone = 0;
		for( auto j : i)
		{
			tableauDeMerdeEnSortie[ligne*maxCardinalite+colone] = j;
			colone++;
		}
		ligne++;
	}

Version "normale" même en voulant trié les catégories :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <map>
#include <vector>
#include <algorithm>
...
	int tableauDeMerdeEnEntre[10][10]={
		{1,0,1,0,1,1,0,1,1,1},
		{1,0,0,1,1,1,1,0,1,0},
		{0,1,1,0,0,0,0,0,0,1},
		{1,0,0,0,1,1,0,1,0,1},	
		{1,1,1,1,0,0,0,0,1,1},	
		{1,1,0,0,0,1,0,1,1,0},	
		{1,1,0,0,0,0,0,0,1,1},
		{0,1,1,0,0,0,0,0,0,1},	
		{1,1,0,0,0,0,0,0,1,1},	
		{1,0,1,0,1,1,0,1,1,1}
	};
 
	std::multimap<int,int> mymap;
 
	for(int i = 0 ; i<10 ;i++)
	{
		int key = 0;
 
		for(int j = 0 ; j<10 ;j++)
		{
			key += tableauDeMerdeEnEntre[i][j] << j;
		}
		mymap.insert(std::pair<int,int>(key,i));
	}
 
	std::vector<std::vector<int>> myvector;
 
	for( auto iter = mymap.begin() ; iter != mymap.end() ; iter = mymap.upper_bound(iter->first) )
	{
		std::vector<int> mylist;
		for(auto iter2 = iter ; iter2 != mymap.upper_bound(iter->first) ; ++iter2)
		{
			mylist.push_back(iter2->second);
		}
		myvector.push_back(mylist);
	}
 
	std::sort(begin(myvector),end(myvector),[](std::vector<int> a, std::vector<int> b){return a[0]<b[0];});