Salut tout le monde,
ravi d'être parmis vous. J'ai un sujet qui pourrais intréssé plusieurs, enfin je l'espère.

Voila on a des places où on stocke des Boites l'une sur l'autre.
En lancant le programme l'utilisateur peut choisir:
- le nombre de places et de boites qu'il posséde
- une position initiale pour chaque boite
- et aussi une position finale pour chaque boite.
Régles à respécter:
- on ne peut bouger qu'une seule Boite à la fois
- on ne peut bouger que la boite qui est en haut et la deposer ou bien sur têrre ou bien sur une autre boite

Comment utiliser le programme:
- entrer un nombre (entier) de de places
- entrer un nombre (entier) de de Blocs
- entrer les blocs avec un espaces (je viens de remarquer qu'on peut rien donner pour toutes les places et ca c'est faux! je vais rectifier mon code)

But du programme: calculer le nombre optimal de mouvements pour finir la tache entière.
Il ne va jamais pouvoir calculer les nombre de mouvements exact mais un nombre aproximatif qui doit sûrement être plus grand que le nombre minimal réel calculé par l'être humain. Donc un nombre plus petit sera tout à fait faux!
J'ai préparé le code et ce qui me manque c'est la logique pour calculer le nombre de mouvements possibles.
J'ai aussi mis une illustration avec un example concrêt pour mieux comprendre le sujet.

Nom : pour_forum_francais.png
Affichages : 183
Taille : 69,0 Ko

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
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;
}
Merci d'avance et bonne soirée