Carré Magique

Version imprimable

Carré Magique

Bonsoir ,

je souhaite réaliser un carrée magique :

Voici mon code :

Code:

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

Bon je vois que tu es proche pour les lignes

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

Code:

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

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:

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:

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.

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:

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;

12/11/2015, 12h19
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.