Bonjour les amis 😀😀,
Je viens au près de vous car je suis encore débutant en java donc je suis bloqué sur un exercice, On a une matrice.   

1 2 3

4 5 6

7 8 9

Je dois écrire une fonction permettant de produire la nouvelle matrice comme ceci:

9 6 3

8 5 2

7 4 1

n.b: seule la diagonale 3 5 7 qui ne change pas 
Merci d'avance pour votre aide

int [][] tab = new int [3][]
                     For (int i=0;i<tab.length;i++){
                     For (int j=0;j<tab[i].length;j++){
                      tab[i][j]=tab[j][i]}}

-
Edité par cocogouba 26 mai 2016 à 23:46:56

Salut,

Tu peux commencer par t'interroger mathématiquement.

Si tu prends l'élément (i,j) de la matrice de départ, où doit il se retrouver dans la matrice d'arrivé ?

Énumère cela pour toutes les combinaisons (i,j) de la matrice, puis vois si tu peux en déduire une règle plus simple qui pourrait être valable pour une matrice de taille quelconque.

Attention au code que tu donnes à la fin de ton message. Si les valeurs de ta matrice de départ et d'arrivée sont dans la même structure, tu va écrasé les valeurs de départ.
Le plus simple est de créer une nouvelle matrice que tu remplies à partir des données de la première.

-
Edité par macaque 27 mai 2016 à 13:14:36

Bonjour merci pour ta réponse, désolé mais j'ai pas bien compris ton explication ça te dérange pas de me poster un exemple 

Merci d'avance 😉😉

Si ton problème est juste qu'il y a des valeurs qui sont écrasées, tu as ta matrice de départ m1 que tu reçois en paramètre de ta fonction, et ta matrice m2 que tu renvoie comme résultat de ta fonction.

En pseudo code :

fonction symetrique(int[][] m1) {
    int[][] m2 = creerM2aLaTailleDeM1(m1);
    remplirM2aPartirDeM1(m1,m2);
    return m2;
}

-
Edité par macaque 28 mai 2016 à 8:56:09

Merci mais voilà d'où cette partie que je ne vois pas comment faire: remplirM2aPartirDeM1(m1,m2); 

J'avoue que c'est pas trop mon truc les matrices😰😰😰

Si tu ne vois pas comment remplirM2aPartirDeM1, essaie d'abord de compléter le texte suivant :

La valeur à la position [0][0] de la matrice de départ doit se retrouver à la position [...][...] de la matrice d'arrivée.

La valeur à la position [0][1] de la matrice de départ doit se retrouver à la position [...][...] de la matrice d'arrivée.

La valeur à la position [0][2] de la matrice de départ doit se retrouver à la position [...][...] de la matrice d'arrivée.

La valeur à la position [1][0] de la matrice de départ doit se retrouver à la position [...][...] de la matrice d'arrivée.

La valeur à la position [1][1] de la matrice de départ doit se retrouver à la position [...][...] de la matrice d'arrivée.

La valeur à la position [1][2] de la matrice de départ doit se retrouver à la position [...][...] de la matrice d'arrivée.

La valeur à la position [2][0] de la matrice de départ doit se retrouver à la position [...][...] de la matrice d'arrivée.

La valeur à la position [2][1] de la matrice de départ doit se retrouver à la position [...][...] de la matrice d'arrivée.

La valeur à la position [2][2] de la matrice de départ doit se retrouver à la position [...][...] de la matrice d'arrivée.

Tu pourras ensuite essayer de trouver une règle qui a partir des coordonnées dans la matrice de départ donne les coordonnées dans la matrice d'arrivée.

-
Edité par macaque 28 mai 2016 à 11:59:50

merci Macaque pour ta réponse d'après ton aide j'ai essayé d'appliquer ci-dessous après je ne sais pas si j'ai bien compris, mon soucci c'est que ça compile bien mais ça me donne pas le résultat attendu merci d'avance pour votre aide

voici la class:

package hjli;

public class ML {

int lignes, colonnes;

ML(int lignes, int colonnes)

{

this.lignes=lignes;

this.colonnes=colonnes;

}

public static int[][] creerMatrice(int lignes, int colonnes) {

int[][] ret = new int[lignes][];

for (int lig = 0; lig < lignes; lig++)

ret[lig] = new int[colonnes];

return ret;

}

// On crée la matrice de sortie avec les dimensions inversées

public static int[][] sym(int [][] tab) {

int sourceNbLignes = tab.length;

int sourceNbColonnes = tab[0].length;

int destNbLignes = sourceNbColonnes;

int destNbColonnes = sourceNbLignes;

int[][] nouvelleMatrice = creerMatrice(destNbLignes, destNbColonnes);

// On parcours le tableau en affectant les nouvelles valeurs :

for (int destLig = 0; destLig < destNbLignes; destLig++) {

for (int destCol = 0; destCol < destNbColonnes; destCol++) {

nouvelleMatrice[destLig][destCol] = tab[sourceNbLignes - 1

- destCol][sourceNbColonnes - 1 - destLig];

}

}

return nouvelleMatrice;

}

}

et voici le main:

public class Test {

public static void main(String[] args) { 

int[][] tab = {{1,2,3},{4,5,6},{7,8,9}};

for (int i = 0; i < tab.length; i++) {

for (int j = 0; j < tab[i].length; j++)

{

System.out.print(tab[i][j] + " ");

}

System.out.println("");

}

ML.sym(tab);

System.out.println(ML.sym(tab));

}

        }

et le résultat qu'il me donne est ceci: [[I@a200d0c alors que moi je voudrais qu'il me retourne le tableau sym(tab);

-
Edité par cocogouba 6 juin 2016 à 14:19:40

Le problème quand tu fais "System.out.println(ML.sym(tab));" c'est juste que tu appelle la méthode toString sur un objet "int[]" et que cela affiche la référence de l'objet et non son contenu.

Tu peux donc faire comme tu fait pour afficher le contenu de tab :

int[][] tabSym = ML.sym(tab);
for (int i = 0; i < tabSym.length; i++) {
  for (int j = 0; j < tabSym[i].length; j++) {
    System.out.print(tabSym[i][j] + " ");
  }
  System.out.println("");
}

Sinon avec java8, en une ligne tu peux l'afficher avec par exemple :

Arrays.stream(ML.sym(tab)).forEach(ligne -> System.out.println(Arrays.toString(ligne)));

-
Edité par macaque 6 juin 2016 à 18:22:41