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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
| #include <iostream>
#include <vector>
#include <limits>
#include <sstream>
#include <cctype>
#include <unordered_set>
using namespace std;
// Variables Globales
int nbrOfBlocks = 0;
int nbrOfPlaces = 0;
unordered_set<int> usedBlocks; // Set pour les blocs déjà attribués
int totalBlocksAssigned = 0; // Compte combien de blocs ont été alloués
// Fonction pour saisir un entier positif
int getPositiveIntegerInput(const std::string& prompt) {
int input;
std::string line;
do {
std::cout << prompt;
std::getline(std::cin, line);
std::stringstream ss(line);
if (line.empty()) {
std::cout << "Veuillez saisir un chiffre non nul!" << std::endl;
continue;
}
if (ss >> input && ss.eof()) {
if (input > 3) {
return input;
} else {
std::cout << "Veuillez saisir un chiffre plus grand que 3!" << std::endl;
}
} else {
std::cout << "Erreur: Les lettres et les caracteres speciaux ne sont pas autorises, veuillez saisir uniquement des nombres entiers!" << std::endl;
}
} while (true);
}
// Fonction pour vérifier l'unicité des nombres
bool isUnique(const vector<int>& configuration) {
unordered_set<int> uniqueSet;
for (int num : configuration) {
if (uniqueSet.find(num) != uniqueSet.end()) {
return false; // Le nombre a déjà été saisi
}
uniqueSet.insert(num);
}
return true; // Tous les nombres sont uniques
}
// Fonction pour vérifier si les nombres sont dans la plage valide
bool isValidRange(const vector<int>& configuration, int nbrOfBlocks) {
for (int num : configuration) {
if (num < 1 || num > nbrOfBlocks) {
return false; // Le nombre n'est pas valide
}
}
return true; // Tous les nombres sont dans la plage valide
}
// Fonction pour saisir la constellation pour une place avec les chèques souhaités
std::vector<int> getConfigurationForPlace(int place, int blockCount, std::string Constellation) {
std::vector<int> configuration;
std::string line;
while (true) {
std::cout << "Entrez les blocs dans l'ordre pour la " << Constellation << " " << place << " ein: ";
std::getline(std::cin, line);
std::stringstream ss(line), ssCheck(line);
int block;
bool inputError = false, invalidInput = false;
// Verifiez s'il y a des caracteres invalides (lettres, caracteres speciaux) dans la saisie
for (char c : line) {
if (!isdigit(c) && !isspace(c)) {
std::cout << "Erreur:*Entree invalide. Veuillez saisir uniquement des nombres entiers." << std::endl;
invalidInput = true;
break;
}
}
if (invalidInput) continue;
while (ssCheck >> block) {
if (block < 1 || block > blockCount || usedBlocks.count(block) > 0) {
std::cout << "Erreur: numero de bloc invalide ou bloc deja attribue. Veuillez entrer a nouveau." << std::endl;
inputError = true;
break;
}
}
if (inputError) continue;
// Ajouter les blocs a la configuration
while (ss >> block) {
usedBlocks.insert(block);
configuration.push_back(block);
totalBlocksAssigned++;
}
// Überprüfen, ob am letzten Platz alle Bloecke zugewiesen wurden
if (place == nbrOfPlaces && totalBlocksAssigned < blockCount) {
std::cout << "Veuillez entrer tous les blocs restants pour la derniere place." << std::endl;
continue;
}
return configuration;
}
}
void printConstellation(const vector<vector<int>>& Constellation, const string& title) {
cout << "\n######******###### " << title << " ######******######" << endl;
for (int i = nbrOfBlocks - 1; i >= 0; --i) {
for (int j = 0; j < nbrOfPlaces; ++j) {
if (Constellation[i][j] == 0) {
cout << "| - ";
} else {
cout << "|BL" << Constellation[i][j];
}
}
cout << "|\n";
}
for (int i = 1; i <= nbrOfPlaces; ++i) {
cout << "|PL" << i;
}
cout << "|\n";
}
void buildConstellation(vector<vector<int>>& Constellation, const vector<int>& configuration, int platz) {
int currentHeight = 0; // Commencer par le niveau le plus bas
for (int block : configuration) {
Constellation[currentHeight][platz] = block;
currentHeight++;
}
}
int main() {
nbrOfPlaces = getPositiveIntegerInput("Combien de places avez-vous? ");
nbrOfBlocks = getPositiveIntegerInput("Combien de blocs avez-vous? ");
vector<vector<int>> startConstellations(nbrOfBlocks, vector<int>(nbrOfPlaces, 0));
vector<vector<int>> endConstellations(nbrOfBlocks, vector<int>(nbrOfPlaces, 0));
cout << "\n######******###### Entree pour la constellation de depart ######******######" << endl;
for (int i = 0; i < nbrOfPlaces; ++i) {
if (totalBlocksAssigned < nbrOfBlocks) {
vector<int> configuration = getConfigurationForPlace(i + 1, nbrOfBlocks, "place depart");
buildConstellation(startConstellations, configuration, i);
}
}
usedBlocks.clear(); // Réinitialisation définie pour la constellation finale
totalBlocksAssigned = 0; // réinitialiser le compteur
cout << "\n######******###### Entree pour la constellation de fin ######******######" << endl;
for (int i = 0; i < nbrOfPlaces; ++i) {
if (totalBlocksAssigned < nbrOfBlocks) {
vector<int> configuration = getConfigurationForPlace(i + 1, nbrOfBlocks, "place finale");
buildConstellation(endConstellations, configuration, i);
}
}
printConstellation(startConstellations, "ConstellationDepart");
if (startConstellations == endConstellations) {
cout << "\n######******###### Constellation de Depart = Constellation de Fin, pas de mouvement ######******######" << endl;
} else {
cout << "\n######******###### Constellation de Depart <> Constellation de Fin, il y a des mouvements ######******######" << endl;
}
printConstellation(endConstellations, "ConstellationFin");
return 0;
} |
Réorganisation de Stock
Répondre avec citation
Partager