Bonjour,
Je souhaite programmer un algorithme qui renvoie un carré magique selon l'ordre de la matrice donné.
La programmation avec la méthode Siamoise fonctionne parfaitement mais celle avec la méthode Bachet (glissement-rotation) ne fonctionne pas. Je ne trouve pas mes erreurs, Pourriez-vous m'aider?
J'ai copié-collé une partie de mon programme (ça ne fonctionnait pas en pièce jointe...), l'appel de la procédure ConsBachet se fait plus bas mais je sais que cette partie ne contient pas d'erreurs.
J'espère que vous pourrez m'aider à temps, je dois rendre ce travail mardi prochain (12/05/2015).
Merci beaucoup !
Code:/* ----------------------------------------------------- disposition : disposition en diagonale des entiers de 1 à n² ------------------------------------------------------*/ void disposition(int mat1[][MAX2],int n1){ //Decl. var. locales int ligSommet ; // ligne du sommet de la diagonale int colSommet; // colonne du sommet de la diagonale int ligCour ; //ligne courante int colCour ; //colonne courante int ligSuiv ; //ligne suivante int colSuiv ; //colonne suivante int cpt ; //compteur (entier à placer) int cptMax ; //n² int i,j,k; //compteurs boucles //Instr. //Init Carre à zéro n1=((2*n)-1); //taille du grand carré initMatZero(mat1,n1); //Init premier sommet ligSommet=0; colSommet=(n1-1)/2; //Init compteur max cptMax=n*n; cpt=0; //Boucle while(cpt<cptMax){ //indice case Sommet i=ligSommet; //on donne le sommet de la diagonale j=colSommet; for(k=1;k<=n;k++){ cpt++; //on incrémente le compteur mat[i][j]=cpt; //on affecte la valeur cpt à la case i=i++; //on descend dans la diagonale j=j++; } //Sommet suivant ligSommet=ligSommet+1; //on décale le sommet de la diagonale suivante en bas à gauche colSommet=colSommet-1; }//fin while }//fin procedure /* ----------------------------------------------------- permutation : permute deux cases d'un tableau ------------------------------------------------------*/ void permutation(int mat[][MAX2],int a, int b, int c, int d){ int tmp; tmp=mat[a][b]; //On met la première case dans une variable tampon mat[a][b]=mat[c][d]; //on change la première case par la seconde mat[c][d]=tmp; //on change la deuxième case par la première }//fin procedure /* ----------------------------------------------------- glissement : glissement du rectangle gris clair sur le rectangle gris foncé ------------------------------------------------------*/ void glissement(int mat1[][MAX2],int n1){ //Decl. var. locales int i,j; //compteurs boucles int nbGlisse; //variables tableau int ligCour, colCour, ligSuiv, colSuiv, ligSommet, colSommet; //variables lignes et colonnes //Init. n1=(2*n)-1; //taille du grand carré nbGlisse=(n-1)/2; //nb de valeurs à glisser par diagonale ligSommet=0; colSommet=n1/2; //Boucle for(i=0;i<((n-1)/2);i++){ ligCour=ligSommet; //On donne le sommet de la première diagonale colCour=colSommet; ligSuiv=ligSommet+n; colSuiv=colSommet; //On domme le sommet de la deuxième diagonale for(j=0;j<nbGlisse;j++){ permutation(mat2, ligCour,colCour,ligSuiv,colSuiv); ligSuiv=ligSuiv+1; //on descend dans la première diagonale colSuiv=colSuiv+1; ligCour=ligCour+1; //on descend dans la deuxième diagonale colCour=colCour+1; }//fin for nbGlisse=nbGlisse-1; ligSommet++; colSommet--; }//fin for }//fin procedure /* ----------------------------------------------------- rotation : rotation de 90° dans le sens rétrograde ------------------------------------------------------*/ void rotation(int mat1[][MAX2], int mat2[][MAX2],int n1){ //Decl var locales int i,j; //compteurs boucles int coteCarre; //variable tableau //Init. coteCarre=2*n-1; //On initialise la variable avec la taille du coté du carré for(i=0;i<coteCarre;i++){ for(j=0;j<coteCarre;j++){ mat3[i][j]=mat[j][(coteCarre-1)-i]; } } for(i=0;i<coteCarre;i++){ for(j=0;j<coteCarre;j++){ mat[i][j]=mat3[i][j]; } } }//fin procedure /* ----------------------------------------------------- reaffectation : réaffectation des matrices ------------------------------------------------------*/ void reaffectation(int mat1[][MAX2],int mat2[][MAX2],int n1){ //Decl var locales int i, j; //compteurs boucles int i1,j1; int coteCarre; //variable tableau //Init coteCarre=2*n-1; //on initialise la variable avec la taille du cote du grand carre i1=0; //on initialise les coordonnées à 0 j1=0; //Boucle for(i=0;i<coteCarre;i++){ for(j=0;j<coteCarre;j++){ if(mat[i][j]!=0){ //S'il y a une valeur mat3[i1][j1]=mat[i][j]; //on la met dans la matrice 3 if(j1==(n-1)){ //si debordement, on revient au debut de la ligne suivante j1=0; i1++; }else(j1++) ; //sinon on avance de 1 dans les colonnes } } } for(i=0;i<coteCarre;i++){ for(j=0;j<coteCarre;j++){ mat[i][j]=mat3[i][j]; //on met les valeurs dans la première matrice } } }//fin procedure /* ----------------------------------------------------- consBachet : carré magique méthode de Bachet ------------------------------------------------------ */ void consBachet(int mat1[][MAX2], int n){ int k; //compteur boucle int n1; //Disposition des entiers de 1 à n² disposition(mat1,n1); //Boucle: glissement + rotation for(k=1;k<=4;k++){ glissement(mat1,n1); rotation(mat1,mat2,n1); //Reaffectation matrice mat1 <- mat2 reaffectation(mat1,mat2,n1); } } /* ----------------------------------------------------- verifImp : verifie que le resultat obtenu est impair ------------------------------------------------------ */ int verifImp(int n1){ int res; if((n%2)==0){ res=0; }else{ res=1; } return res; }//fin procedure
-----