Alors voilà, je suis bloqué sur un programme depuis plusieurs jours, non seulement il est long mais en plus il est compliqué x)
Je mets l'intitulé, mon code, ainsi que ce qu'il sort dans le cmd.
Intitulé :
Le but est de créer un programme qui permet de saisir un nombre entier naturel et qui affiche le ou les poid(s) de chaque chiffre dans ce nombre. À partir de ces informations (les poids de chaque chiffre), le nombre doit pouvoir être reconstitué.
Le poids représente la position du chiffre dans le nombre, en partant de la droite (le premier chiffre de droite est à la position 0, il a donc un poids 0).
Exemple :
Si le nombre saisi est :
7377683
L’affichage doit donner :
3 : 0 5
6 : 2
7 : 3 4 6
8 : 1
7377683Explication : le 3 a pour poids 0 et 5 (car on le retrouve à la position 0 et à la position 5 du nombre, en partant de la droite), le 6 a pour poids 2, le 7 à pour poids 3, 4 et 6, et le 8 a pour poids 1. Vous ne devez pas afficher les chiffres qui n’apparaissent pas. Verticalement, les premiers chiffres doivent être dans l'ordre croissant. Horizontalement, les positions doivent aussi être dans l'ordre croissant. Pour mémoriser les poids de chaque chiffre, vous devez utiliser un tableau à 2 dimensions. L’affichage final (7377683) provient de la reconstitution du nombre à partir des poids de chaque chiffre.
On prendra pour hypothèse que le nombre saisi ne dépasse pas 9 chiffres (inutile de faire un contrôle de saisie). En C++, vous déclarerez ce nombre en "unsigned long int". Attention, le nombre reconstitué doit être aussi en 'unsigned long int". Vous n’avez pas l’autorisation d’utiliser des variables autres que numériques pour gérer ce programme.
Le programme doit fonctionner pour plusieurs nombres : l’arrêt du programme se fera lorsque le nombre saisi sera égal à 0.
Code :
#include <iostream>
#include <cmath>
#include <stdio.h>
using namespace std;
int main()
{
unsigned long int nb ;
unsigned long int nbFinal = 0;
int longueur;
cout << "Entrez le nombre que vous voulez décomposer :";
cin >> nb ;
while(nb!=0)
{
longueur = log10(nb) + 1;
int j = 0;
int i = 0;
int matrice[longueur-1][longueur-1];
for(i = 0; i < longueur; i++)
{
int meme;
debutBoucle:
for(meme = 0; meme <= i; meme++)
{
if(nb%10 != unsigned(matrice[meme][j]));
else if(unsigned(matrice[meme][j]) == nb%10)
{
goto debutBoucle;
}
if(matrice[meme][j] == '\0')
{
matrice[i][j] = nb%10;
nb /= 10;
}
}
for(int k = 0; k <= matrice[i][j]; ++k)
{
if(k == matrice[i][j])
{
while(matrice[i][j] != '\0')
{
j++;
}
matrice[i][j] = i;
j = 0;
}
}
}
int nbInter = 0;
int tableau[longueur-1];
for(i = 0; i < longueur; i++)
{
cout << matrice[i][j] << " : ";
for(j = 1; j < longueur; j++)
{
cout << matrice[i][j] << " " ;
for(int m = 0; m < longueur; m++)
{
tableau[m] = matrice[i][0];
}
}
cout << endl ;
}
for(int l = 0; l < longueur; l++)
{
nbInter *= 10;
nbInter += tableau[l];
}
int reste;
while(nbInter != 0)
{
reste = nbInter % 10;
nbFinal = nbFinal * 10 + reste;
nbInter /= 10;
}
cout << "Reconstitution du nombre : " << nbFinal << endl;
cout << "Entrez le nombre que vous voulez : ";
cin >> nb;
}
return 0;
}
Run du code :
Je vous avoue que je sais pas trop pourquoi ça sort ces nombres x) Si quelqu'un a juste une explication, pas besoin de la correction, le but étant de la trouver moi-même !
Je n'ai pas regardé le programme, mais le compilateur me remonte 2 erreurs (option -Wall -Wextra -pedantic -fsanitize=address de gcc):
L'utilisation de VLA pour matrice qui est interdit en C++. Puisque tu connais la taille max, matrice pourrait être un tableau de 10*9 éléments.
un buffer overflow à la ligne 49. Je ne suis pas sûr de savoir ce que tu testes avec '\0' pour un entier, ni comment cela peut fonctionner avec un tableau non initialisé (= qui contient des valeurs aléatoires).
Mais j'ai l'impression que tu te prends la tête pour rien. Il suffit d'une boucle sur le rang + une boucle imbriquée pour insérer le rang à la fin de la liste. Quelque chose comme for (int rang = 0; rang < longueur; ++rang, nb /= 10) ajouter_rang(matrice[nb % 10], rang)
Pour ce qui est du buffer overflow, j'ai juste mis le '\0' pour faire un test sur la valeur pour savoir si elle est nulle.
Pour ta dernière remarque, tu parles à la place de quelle partie du code ?
Rednote t'indiquait des erreurs à corriger, dont le \0 en est une. Un tableau est aléatoire à la création (donc contient des nombres tels que -1, 0, 12345 ou autre, la preuve c'est ce que tu affiches), le caractère '\0' permet d'indiquer la fin d'une chaîne de caractères, il n'a aucun sens pour un tableau d'entier. Mais tu peux utiliser cette technique ici; Par exemple dans le tableaux, il y des indices donc des nombres de 0 à 9. Tu peux le remplir au départ avec une valeur différente (par exemple -1) et une case "vide" sera reconnue car elle contient un -1.
La ligne de pseudo-code indiquée correspondait à presque tout ton code! Le plus gros problème ici, je pense que c'est surtout ton prof! Il t'impose d'utiliser un à tableau à 2 dimensions qui est le pire des objets du C++ qui a dû garder les tableaux du C (mais même en C, il faut éviter les doubles tableaux.) IL NE FAUT JAMAIS UTILISER LES TABLEAUX BRUTS DU C EN C++.Et euh, c'est aussi lui qui t'as appris goto et using namespace std;?
Je te donne une solution en C++ (à ne pas recopier telle quelle car ton prof risque de ne pas la comprendre.) Peux-être la comprendras-tu pour la mettre au format "prof imbécile".
#include <iostream> // pour std::cin, std::cout et std::endl
#include <vector> // pour std::vector
#include <array> // pour std::array
#include <cmath> // pour std::pow
int main() {
for (;;) {
unsigned long leNombre;
std::array<std::vector<unsigned>,10> lesPosDesChiffres; // à chaque chiffre (0 a 10) on associe des positions
std::cout << "Entrez le nombre que vous voulez décomposer : ";
std::cout.flush();
std::cin >> leNombre;
// c'est fini ?
if ( leNombre == 0 )
break;
// décomposition du nombre
for ( unsigned index{} ; leNombre != 0 ; ++index ) {
unsigned chiffre = leNombre % 10; // chiffre à la position index
leNombre /= 10;
lesPosDesChiffres[chiffre].push_back( index ); // ajouter cet index à la liste des index pour le chiffre
} // on a donc ici tout décomposé et tout stocké dans un tableau, très facile à utiliser!
// affichage de la décomposition
for ( unsigned chiffre = 0 ; chiffre < 10u ; ++chiffre ) {
if ( !lesPosDesChiffres[chiffre].empty() ) {
std::cout << chiffre << " : ";
for ( unsigned position : lesPosDesChiffres[chiffre] )
std::cout << position << ' ';
std::cout << '\n';
}
}
// reconstruction du nombre
unsigned long nbFinal{};
for ( unsigned chiffre{} ; chiffre < 10u ; ++chiffre ) {
for ( unsigned position : lesPosDesChiffres[chiffre] ) {
unsigned long puissance = std::pow( 10, position );
nbFinal += chiffre * puissance;
}
}
std::cout << "Reconstitution du nombre : " << nbFinal << std::endl;
}
}
On peut faire un peu plus compact, mais j'ai essayé de plus décomposer.
Par exemple dans le tableaux, il y des indices donc des nombres de 0 à 9. Tu peux le remplir au départ avec une valeur différente (par exemple -1) et une case "vide" sera reconnue car elle contient un -1.
Oui, ça je compte le corriger ! J'ai pas implémenté les valeurs de la matrice à 1 encore x)
Et euh, c'est aussi lui qui t'as appris goto et using namespace std;?
Non, les goto je l'ai trouvé tout seul, même si je sais que son utilisation est pas ouf... Par contre le using spacename std, ça y est de base.
Merci pour la proposition mais le truc c'est que j'en suis pas encore arrivé à ce stade dans le cours, et on nous demande quand même de faire ce programme !
Est-ce que tu penses que sans les vector, array, std et tout ça, ça serait beaucoup plus long ?
Edit : J'ai run ton programme et malheureusement, ça n'affiche pas le bon résultat
Et euh, c'est aussi lui qui t'as appris goto et using namespace std;?
Non, les goto je l'ai trouvé tout seul, même si je sais que son utilisation est pas ouf... Par contre le using spacename std, ça y est de base.
Ça fait plus de trente ans que je fais du C++, après plusieurs millions de lignes de code, j'ai pu me passer de goto, tu peux l'oublier vite. Pour using namespace std; ça servait dans les années 90. Aujourd'hui cela ne peut qu'amener des problèmes, donc aussi à oublier.
Rednote a écrit:
Merci pour la proposition mais le truc c'est que j'en suis pas encore arrivé à ce stade dans le cours, et on nous demande quand même de faire ce programme !
Est-ce que tu penses que sans les vector, array, std et tout ça, ça serait beaucoup plus long ?
Non, tu peux remplacer les 3 lignes de la décomposition en quelques lignes de plus. Dans le cas du double tableau, c'est à toi de gérer l'ajout en fin de tableau ainsi la ligne lesPosDesChiffres[chiffre].push_back( index ); devient :
int j = 0;
while ( matrice[chiffre][j] != -1 )
++j; // chercher la première case libre qui vaut -1
matrice[chiffre][j] = index; // et écrire dedans l'index
Rednote a écrit:
Edit : J'ai run ton programme et malheureusement, ça n'affiche pas le bon résultat
Bizarre, du coup je viens de l'essayer et chez moi et il fonctionne. Il y a chez toi un biais de -13 difficile à expliquer.
Bizarre, du coup je viens de l'essayer et chez moi et il fonctionne. Il y a chez toi un biais de -13 difficile à expliquer.
C'est vrai que c'est bizarre x) Mais c'est pas grave, parce qu'en même temps de demander via le forum une solution, j'ai aussi essayé d'améliorer mon code et je crois que je tiens le bon bout !
int main()
{
unsigned long int nb;
unsigned long int nbFinal = 0;
cout << "Entrez le nombre que vous voulez décomposer : ";
cin >> nb ;
while(nb!=0)
{
int j = 0;
int i;
unsigned long int matrice[10][10] = {{0},{0}};
for(i = 0; i < 10; i++)
{
if(nb%10 != matrice[i][j])
{
matrice[i][j] = nb%10;
nb /= 10;
}
else if(nb%10 == matrice[i][j])
{
continue;
}
for(int k = 0; k < 10; k++)
{
if(unsigned(k) == matrice[i][j])
{
while(matrice[i][j] != 0)
{
j++;
}
matrice[i][j] = i;
j = 0;
}
}
}
int nbInter = 0;
int tableau[9] = {0};
for(i = 0; i < 10; i++)
{
cout << matrice[i][j] << " : ";
for(j = 1; j < 10; j++)
{
cout << matrice[i][j] << " " ;
tableau[i] = matrice[i][0];
}
cout << endl;
}
cout << tableau[0] << tableau[1] << tableau[2] << tableau[3] << tableau[4] << tableau[5] << tableau[6];
for(int l = 0; l < 10; l++)
{
nbInter *= 10;
nbInter += tableau[l];
}
int reste;
while(nbInter != 0)
{
reste = nbInter % 10;
nbFinal = nbFinal * 10 + reste;
nbInter /= 10;
}
cout << "Reconstitution du nombre : " << nbFinal << endl;
cout << "Entrez le nombre que vous voulez décomposer : ";
cin >> nb;
}
return 0;
}
Le 8 et son poids ne s'affiche pas dans la reconstitution de la matrice, et du coup ça décale de 1 le poids des chiffres après le 8. Pourtant, quand j'affiche le tableau qui contient le nombre de départ à l'envers (juste avant "Reconstitution du nombre") et bien le 8 y est !
Il y a aussi les 7 qui s'affichent chacun sur une ligne différente et le nombre final qui n'est pas bon, mais j'y travaille...
PS : Désolé de te retenir avec mon code, mais je préfère faire avec ce que j'ai appris, plutôt que rendre quelque chose que je comprends à moitié. J'ai pas envie de rendre aussi quelque chose que je n'ai pas encore vu dans le cours, sous peine d'avoir une mauvaise note x) On est jamais trop prudents !
Tu as raison de revenir sur ton code. Mais il te faut bien le relire. Et bien nommer ce que tu cherches. Première ligne de travail, ta ligne 15. Tu commences par une boucle de 0 à 9, que cherches tu? (Juste pour comparer, mon code effectuais une boucle qui extrayait les chiffres en partant des unités.) Ton 'i' semble être la position des chiffres extraits (pourquoi s'appelle-t-il 'i', et pourquoi aller jusqu'à 9 qui n'a pas sens car le plus grand des nombres n'arriverait qu'à l'indice 8) Deuxième ligne de travail, ta ligne 17. Que cherches tu en comparant le chiffre des unités avec une case de ton tableau? La colonne 0 de ton tableau contiendrait les chiffres extraits, et les autres colonnes autre chose? Pourquoi pas, mais ça commence à devenir très compliqué. D'autant qu'ici rien ne dit que j vaudra toujours 0. Ligne 28 apparaît un indice k, je commence à décrocher. On a i, j, k, nb%10 à suivre, et l'utilisation de matrice[][]. Il faut trouver un nom explicite aux variables, faire un dessin... Tu devrais peut-être faire un dessin, et bien nommer ce que tu utilises. Si j'ai pu écrire la décomposition en 3 lignes, c'est que ça n'est pas si compliqué. Les type std::array et std::vector ne sont que des tableaux qui correspondent aux 2 dimensions de ta matrice, il n'y a aucun code magique. Mon objectif était de te donner un pseudo-code en même temps qu'une syntaxe un peu plus C++.
Et attention, tu initialises ta matrice avec des zéros, sauf qu'à un moment tu y mets un zéro. Comment distinguer le zéro case vide, du zéro valeur écrite. C'est pourquoi je t'avais proposé un remplissage avec des -1.
Il est vrai que mon code n'est pas très clair. Voici une version (encore) améliorée de mon code, ou je m'approche encore un peu du but ! Et ou j'ai renommé toutes les variables pour que ça soit un peu plus clair.
int main()
{
int longueur;
unsigned long int nb;
unsigned long int nbFinal = 0;
cout << "Entrez le nombre que vous voulez décomposer : ";
cin >> nb ;
while(nb!=0)
{
longueur = log10(nb) + 1;
int ligne;
int colonne = 0;
unsigned long int matrice[longueur+1][longueur+1] = {};
for(ligne = 0; ligne < longueur; ligne++)
{
for(int doublon = 0; doublon < ligne; doublon++)
{
if (matrice[doublon][colonne] == matrice[ligne][colonne])
break;
}
if(nb%10 != matrice[ligne][colonne])
{
matrice[ligne][colonne] = nb%10;
nb /= 10;
}
else if(nb%10 == matrice[ligne][colonne])
{
continue;
}
}
for(ligne = 0; ligne < longueur; ligne++)
{
while(matrice[ligne][colonne] != 0)
{
colonne++;
}
matrice[ligne][colonne] = ligne;
colonne = 0;
}
int nbInter = 0;
int tableau[longueur] = {};
for(ligne = 0; ligne < longueur; ligne++)
{
cout << matrice[ligne][colonne] << " : ";
for(colonne = 1; colonne < longueur+1; colonne++)
{
cout << matrice[ligne][colonne] << " " ;
tableau[ligne] = matrice[ligne][0];
}
cout << endl;
}
for(int l = 0; l < longueur; l++)
{
nbInter *= 10;
nbInter += tableau[l];
}
int reste;
while(nbInter != 0)
{
reste = nbInter % 10;
nbFinal = nbFinal * 10 + reste;
nbInter /= 10;
}
cout << "Reconstitution du nombre : " << nbFinal << endl;
cout << "Entrez le nombre que vous voulez décomposer : ";
cin >> nb;
}
return 0;
}
Les bémols que j'ai sont la gestion des chiffres doublons, les poids de chaque chiffre et le 8 qui ne s'affiche pas dans la matrice alors qu'il est dans la reconstitution du nombre.
Je préfère faire avec ce que j'ai appris, plutôt que rendre quelque chose que je comprends à moitié. J'ai pas envie de rendre aussi quelque chose que je n'ai pas encore vu dans le cours, sous peine d'avoir une mauvaise note x) On est jamais trop prudents !
J'ai pas envie de rendre aussi quelque chose que je n'ai pas encore vu dans le cours, sous peine d'avoir une mauvaise note x) On est jamais trop prudents !
Et voila tout le drâme des profs irrémédiablement coincés dans leurs univers étroit: - Nutilisez que ce que JE vous ai appris.
A croire que se documenter / faire ses propres recherches est proscrit. Pauvre France, ton éducation nationale n'engendre que des moutons.
l'exercice n'est pas là pour faire chier le monde, ni pour faire quelque chose d'utile, il est là pour donner l'occasion d'ACQUERIR un point du cours, il faut donc le mettre en oeuvre
il est là pour que vous le FASSIEZ. Pomper des solutions ailleurs, ce n'est pas éthique.
Si vous me rendez une solution avec des trucs qui ne font pas partie du cours, je veux bien, mais pensez bien :
si après vous êtes incapable d'expliquer votre solution, ça va se voir que vous avez pompé
si vous êtes capable d'expliquer votre truc, mais pas de montrer que vous comprenez celui du cours, ça va se voir que vous n'avez pas fait le boulot demandé
Parce que bon, "mes propres recherches", faut pas prendre tous les profs pour des truffes, non plus.
Par exemple, un débutant qui me sort des trucs avec v.push_back( { x, y } ) alors qu'on est dans des exercices sur les tableaux de base, il va falloir qu'il me raconte un peu ce que font les accolades là dedans. "j'ai trouvé sur Internet", ça va pas être suffisant.
- Edité par michelbillaud 21 janvier 2020 à 17:27:33
Certains enseignants sont tolérants quand l'utilisation de techniques avancées, tant que l'élève montre qu'il comprend ce qu'il fait. D'autres (majoritaires ?) sont complètement intolérants. Cas typique: Tapper sur les doigts des redoublants: "Tu sais faire, mais ce n'est pas dans le cours, tu n'as que la moitié des points."
Dans tous les cas, merci pour vos propositions de code mais malheureusement je ne peux pas m'appuyer sur ça ni rendre un code similaire à ce que vous avez fait.
Justement, il ne dit rien, il ne met aucune trace d'erreur. Je sais juste que le poids 0 qui ne s'affiche pas pour le 3, c'est parce que je fais une comparaison à 0, mais je ne peux pas faire de comparaison à -1 à la place parce que je ne peux pas comparer un signed et un unsigned.
Il doit être assez facile de tracer à la main ce qui se passe, vu que ça merdoie pour de petits exemples
Entrez le nombre que vous voulez décomposer : 1
1 0
Reconstitution du nombre : 1
Entrez le nombre que vous voulez décomposer : 1
1 0
Reconstitution du nombre : 11
Entrez le nombre que vous voulez décomposer : 1
1 0
Reconstitution du nombre : 111
Entrez le nombre que vous voulez décomposer :
On s'expose à moins de problème si on réduit la portée des variables à ce qui est strictement nécessaire. La boucle principale traite un nombre nb, il n'y a AUCUNE raison que les variables longueur et nbFinal soient déclarées à l'extérieur de la boucle.
Au passage, ça ramènera l'initialisation de nbFinal dans la boucle, pour chaque nombre. C'est peut être pas du luxe.
Voila une version un peu arrangée, qui ne présente pas le bug ci-dessus (mais elle bugge quand même quand le nombre se termine par des zeros).
Améliorations
déclaration des variable là où on en a besoin
suppressions des branches inutiles des if
renommage de quelques variables
commentaires pour structurer le code
J'ai supposé que tu ne sais pas encore écrire une fonction, sinon j'aurais fait un main qui s'occupe de lire un nombre, et d'appeler tester_decomposition(nb).
#include <iostream>
#include <cmath>
using namespace std;
int main(int argc, char** argv) {
unsigned long int nb;
cout << "Entrez le nombre que vous voulez décomposer : ";
cin >> nb;
while (nb != 0) {
int longueur = log10(nb) + 1;
//
// construction de la matrice chiffres -> positions
//
// ça cause de chiffres, une dimension devrait être 10
unsigned long int matrice[longueur + 1][longueur + 1] = {};
int colonne = 0;
int nbChiffresDiff = 0;
bool doublonExiste = false;
for (int ligne = 0; ligne < longueur; ligne++) {
for (int doublon = 0; doublon < ligne; doublon++) {
if (nb % 10 == matrice[doublon][colonne]) {
while (matrice[doublon][colonne] != 0) {
colonne++;
}
matrice[doublon][colonne] = ligne;
colonne = 0;
nb /= 10;
doublonExiste = true;
}
}
if ( ! doublonExiste) {
nbChiffresDiff++;
matrice[ligne][colonne] = nb % 10;
while (matrice[ligne][colonne] != 0) {
colonne++;
}
matrice[ligne][colonne] = ligne;
colonne = 0;
nb /= 10;
}
}
//
// affichage et reconstruction du nombre
//
int tableau[longueur] = {};
for (int ligne = 0; ligne <= nbChiffresDiff - 1; ligne++) {
for (colonne = 0; colonne < longueur + 1; colonne++) {
cout << matrice[ligne][colonne] << " ";
tableau[ligne] = matrice[ligne][0];
}
cout << endl;
}
int nbInter = 0;
for (int l = 0; l < longueur; l++) {
nbInter *= 10;
nbInter += tableau[l];
}
unsigned int nbFinal = 0;
while (nbInter != 0) {
int reste = nbInter % 10;
nbFinal = nbFinal * 10 + reste;
nbInter /= 10;
}
cout << "Reconstitution du nombre : " << nbFinal << endl;
cout << "Entrez le nombre que vous voulez décomposer : ";
cin >> nb;
}
return 0;
}
Je te rassure, ça bugge toujours
Entrez le nombre que vous voulez décomposer : 1
1 0
Reconstitution du nombre : 1
Entrez le nombre que vous voulez décomposer : 1
1 0
Reconstitution du nombre : 1 <- ça va mieux
Entrez le nombre que vous voulez décomposer : 10 <- on change
0 0 0
1 1 0
Reconstitution du nombre : 1 <- ah hem
C'est du à la reconstruction "à l'endroit/à l'envers", qui te fait perdre les 0 finaux, qui disparaissent quand le nombre est construit "à l'envers".
PS : je crois que tu t'emmerdes pour rien avec des unsigned long, quand des int font largement le job. Ton programme est destiné à un microcontroleur avec des entiers de 16 bits ? Tu ne veux as mettre des unsigned shorts pour les nombres de 0 à 9, non plus ? :-)
- Edité par michelbillaud 22 janvier 2020 à 11:53:29
Merci beaucoup pour la reconstruction du code, ça fait plaisir !
Juste une chose, à quoi sert int argc, char** argv ?
Et le problème, c'est que je suis obligé d'avoir un unsigned long int pour le nombre de départ ainsi que le nombre final !
Et oui, les fonctions ne sont pas encore de mon ressort, malheureusement... Mais j'ai de plus en plus l'impression que ce qu'on me demande est bizarre... Le coup du unsigned me fait foirer le poids 0 du chiffre 3 et je pense aussi le poids 6 du chiffre 7 qui me met 5 à la place. J'ai beau initialiser avec une autre valeur que 0 la matrice, quand je run le programme et que j'entre la valeur, ça ne sort rien du tout.
Non, on n'est absolument pas obligé d'avoir des unsigned long. Long ok, si la contrainte est des traiter des nombres trop grands pour rentrer dans des int.
Pour trouver tes erreurs, il te faut un peu de méthodologie :
1. Trouver un exemple qui ne marche pas
2. Essayer de trouver le plus petit exemple qui ne marche pas, à partir de variantes du premier (en enlevant un chiffre, pour voir)
3. A partir de là, si tu as un exemple à deux chiffres (10 par exemple), tu peux suivre ton algorithme à la main, instruction par instruction. Et là, tu peux confronter
- ce que tu voulais que ça fasse
- ce qui se passe réellement.
Ok, c'est chiant à faire. C'est pour ça qu'il faut chercher un exemple minimal.
Conseil : imprimer, et prendre un crayon. Au besion, suivre en parallèle avec un debugger. Le debugger, ça fait bêtement les pas à pas, mais c'est pas lui qui va se rendre compte à quel moment ça ne fait plus ce qu'on voulait. Pour ça, faut demander au cerveau qui a écrit le code.
- Edité par michelbillaud 22 janvier 2020 à 18:36:49
Dans mon programme (ligne 44), je compare matrice[ligne][colonne] à la valeur 0 alors que j'ai initialisé tous les valeurs de la matrice à 0.
Quand ligne est égal à 5 et donc arrive au deuxième trois de nb (à l'envers), le premier
while (matrice[doublon][colonne] != 0) {
colonne++;
}
teste matrice[doublon][colonne] à la valeur 0 et vu que le poids du premier 3 était 0, et bien ça enregistre le poids 5 par dessus le poids 0.
Tout ça pour dire que je ne peux pas initialiser la matrice avec une autre valeur que 0, j'ai essayé avec -1, et du coup ça me fait une erreur de comparaison entre signed et unsigned, et j'ai aussi essayé avec une valeur aléatoire genre 42, mais le programme n'affiche rien dans ce cas là.
Ok, ton problème c'est de distinguer des cases occupées par des valeurs qui veulent dire quelque chose, et des cases non utilisées
1. une stratégie possible, c'est effectivement de mettre une valeur spéciale dans celles qui ne sont pas utilisées. Une valeur spéciale qu'on ne peut pas confondre avec les vraies valeurs. Ce qu'on appelle "out of band value".
1.a et effectivement, si tu choisis des unsigned, -1 ça va pas le faire. Mais 0 ça ne le le fait pas non plus, parce que la position 0 existe.
1.b il y a d'autres solutions, traditionnellement prendre le plus grand nombre possible . ULONG_MAX, ~0 doit faire l'affaire, pour les unsigned (c'est l'entier qui ne contient que des 1 en binaire.
Ceci dit on peut voir les choses autrement. C'est pour ça qu'il y a un 1., le 2. va arriver, héhé.
2. Dans chaque ligne de la "matrice", il y a - si j'ai bien compris-, les positions des différents chiffres. Par exemple, si je ne fais pas figurer les trucs qui servent à rien
Merci pour l'alternative, encore une fois merci pour ton aide, mais malheureusement, je dois faire en sorte que l'affichage soit comme dans l'intitulé... Je sais, c'est très chiant.
Et j'ai essayé de mettre ULONG_MAX à la place de 0 mais c'est le même problème que pour toute autre valeur que 0, ça me retourne ça
Ca ne veut pas dire qu'il faut ranger tes données dans 4 lignes dont la premiere contient 0 et 5. Ca veut dire que tu feras en sorte d'afficher ça à partir de ta structure de données.
Suffit de tester si nb[i] est 0, et de ne pas afficher la ligne i dans ce cas.
On revient à la méthodologie
- quel est le plus petit exemple qui ne marche pas correctement ?
- qu'est-ce que ça donne quand tu le fais tourner à la main ?
- A partir de quelle instruction ne fait il pas ce qu'il devrait ?
- Edité par michelbillaud 23 janvier 2020 à 15:46:10
En recherche d'emploi.
En recherche d'emploi.
En recherche d'emploi.