Discussion :

[am9511]

Bonsoir ,

je souhaite réaliser un carrée magique :

Voici mon code :

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
 public static boolean isSquare(int [] [] t) {  // Fonction qui vérifie qu'il s'agit d'un carrée ou pas :
 
       for (int i=0;i<t.length;i++){
	    	if (t.length!=t[i].length){
			return false;
	    	}
       }
		return true;
    }
 
 public static boolean isMagic(int [] [] t) {
        int sum=0;
 
         if (!isSquare(t)){ // on verifie qu'il s'agit s'un carrée
             return false;
         }
 
        for (int i=0;i<t.length;i++){
        	for (int j=0;j<t[i].length;j++){
                sum=sum+t[i][j];
                // comment tester la somme des lignes,des colonnes, et des deux diagonales ?             
            }
        }
          return true;     
 
    }

Merci pour votre aide

[autran]

Bon je vois que tu es proche pour les lignes

Je te donnes le code pour sommer des lignes et des colonnes

Code java :

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
public class Principal 
{
	public static void main(String[] args) 
	{
		int tab[][] = { {0,2},{1,3} };
		System.out.println("somme de la colonne 1 = " + sommeColonne(tab, 1));    
	}
	public static int sommeLigne(int [][] tab, int li)
	{
		int sumLi = 0;
    	for (int j=0; j<tab[li].length; j++)
    	{
            sumLi=sumLi+tab[li][j];
    	}
    	return sumLi;
	}
	public static int sommeColonne(int [][] tab, int col)
	{
		int sumCol = 0;
    	for (int j=0; j<tab[0].length; j++)
    	{
            sumCol=sumCol+tab[j][col];
    	}
    	return sumCol;
	}
}

essaie de trouver pour les diagonales d'ici ce soir

[joel.drigo]

Salut,

Pour tester si un carré est magique, il faut comparer la somme des éléments de ses lignes, colonnes et diagonales, et si toutes sont égales, le carré est magique, n'est-ce pas ? Premièrement, "si toutes sont égales, le carré est magique" peut se traduire par "si l'une au moins n'est pas égale à n'importe quelle autre, le carré n'est pas magique" (algèbre de Boole), ou plus simple à traiter "si l'une n'est pas égale à celle qu'on vient de calculer, le carré n'est pas magique".

Donc, on peut résumer l'algorithme, à :

Code pseudocode :

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

1
2
3
4
5
6
7
8
9
10
11
 
estcarremagique=vrai
calculprecedent = non encore calculé
pour toutes les lignes, colonnes et diagonales
   calcul = calculer somme des éléments
   si calculprecedent n'est pas "non encore calculé" et si calcul est différent de calculprecedent 
      estcarremagique = faux
      // optimisation : arrêter la boucle
   fin si
   calculprecedent = calcul
fin pour

Il ne te reste plus qu'à écrire une fonction qui calcule la somme des éléments d'une ligne, colonne ou diagonal. Le fait d'avoir un tableau à 2 dimensions va te simplifier la tâche. Pour parcourir une ligne, une colonne ou une diagonal, on fait une boucle : il te suffit d'avoir un indice de ligne et un indice de colonne, et de faire varier ces indices dans la boucle pour parcourir les éléments. Il te suffit de faire varier uniquement un des indices pour parcourir une ligne ou une colonne, et les deux à la fois pour une diagonale.

Par exemple, la fonction peut avoir ce prototype, qui te permet de contrôler entièrement le parcourt :

Code prototype :

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

1
2
3
 
somme(int[][] tab, int departx, int departy, int deplacementx, int deplacementy, int nb) {
}

departx et departy sont les valeurs de départs des indices, deplacementx et deplacementy sont les incréments utilisés à chaque itération et nb le nombre d'itération. Je te laisse maintenant réfléchir à l'implémentation de la fonction et de la boucle principal d'appel.

[am9511]

Salut autran,

Le problème c'est que je dois faire la somme des colonnes et des lignes sans utiliser d'autre fonctions, je dois directement faire la somme et ensuite comparer.

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
 public static boolean isMagic(int [] [] t) {
 
        int sumli=0;
        int sumCol=0;
        int sumDiag1=0;
        int sumDiag2=0;
 
         if (!isSquare(t)){
             return false;
         }
 
        for (int i=0;i<t.length;i++){
			for (int j=0;j<t[i].length;j++){
               sumLi=sumLi+tab[i][j];
               sumCol=sumCol+tab[j][0]; // je suis pas sûr pour la somme des colonnes
               sumDiag1=sumDiag1+t[i][i];
               sumDiag2=sumDiag2+t[i][t.length-i-1];
 
// je dois ensuite comparer chaque somme ?
 
            }
        }
          return true;

[joel.drigo]

Si tu ne dois pas utiliser de méthode, tu peux quand même utiliser la manière que je décris, ce sera simplement moins lisible. En revanche, essayer de tout faire en une seule boucle est possible, mais sera beaucoup moins lisible et plus difficile à mettre au point. Bien plus simple est de décomposer un problème en sous-problèmes que de tout résoudre à la fois ! Dans tous les cas, il te faut pouvoir mémoriser la somme (d'une ligne, d'une colonne, d'une diagonale) pour la comparer avec une autre.