Correction du TP n°8

Exercice 1

Test si une matrice carrée est pandiagonale magique.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class TestMatriceMagique {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
/* Fonction de calcul de la somme des valeurs */
/* d'une colonne d'une matrice carree */
/* m : Tableau d'entiers */
/* c : entier */
/* Resultat fonction : entier */
public static int sommeColonneMatrice(int [][] m,int c) {
/* Declaration et initialisation a 0 de la variable */
/* d'accumulation pour le calcul de la somme */
int s = 0;
/* Declaration d'une variable et affectation */
/* avec la taille de la matrice */
int n = m.length;
/* Pour toutes les lignes i de la matrice */
for ( int i = 0 ; i < n ; i++ )
/* s est incremente de l'entier d'indice (i,c) */
s += m[i][c];
/* Resultat de la fonction */
return(s);
}
/* Fonction de calcul de la somme des valeurs */
/* d'une ligne d'une matrice carree */
/* m : Tableau d'entiers */
/* c : entier */
/* Resultat fonction : entier */
public static int sommeLigneMatrice(int [][] m,int l) {
/* Declaration et initialisation a 0 de la variable */
/* d'accumulation pour le calcul de la somme */
int s = 0;
/* Declaration d'une variable et affectation */
/* avec la taille de la matrice */
int n = m.length;
/* Pour toutes les colones i de la matrice */
for ( int i = 0 ; i < n ; i++ )
/* s est incremente de l'entier d'indice (l,i) */
s += m[l][i];
/* Resultat de la fonction */
return(s);
}
/* Fonction de calcul de la somme des valeurs */
/* d'une colonne d'une diagonale descendante */
/* m : Tableau d'entiers */
/* d : entier */
/* Resultat fonction : entier */
public static int sommeDiagonale1Matrice(int [][] m,int d) {
/* Declaration et initialisation a 0 de la variable */
/* d'accumulation pour le calcul de la somme */
int s = 0;
/* Declaration d'une variable et affectation */
/* avec la taille de la matrice */
int n = m.length;
/* Pour toutes les lignes i de la matrice */
for ( int i = 0 ; i < n ; i++ )
/* s est incremente de l'entier d'indice (i,(d+i)%n) */
/* le d+i permet de descendre la diagonale d */
/* le %n permet de parcourir cycliquement les colonnes */
s += m[i][(d+i)%n];
/* Resultat de la fonction */
return(s);
}
/* Fonction de calcul de la somme des valeurs */
/* d'une colonne d'une diagonale montante */
/* m : Tableau d'entiers */
/* d : entier */
/* Resultat fonction : entier */
public static int sommeDiagonale2Matrice(int [][] m,int d) {
/* Declaration et initialisation a 0 de la variable */
/* d'accumulation pour le calcul de la somme */
int s = 0;
/* Declaration d'une variable et affectation */
/* avec la taille de la matrice */
int n = m.length;
/* Pour toutes les lignes i de la matrice */
for ( int i = 0 ; i < n ; i++ )
/* s est incremente de l'entier d'indice (i,(d-i+n)%n) */
/* le d-i permet de monter la diagonale d */
/* le (...+n)%n permet de parcourir cycliquement */
/* les colonnes en gerant correctement le probleme */
/* du calcul de modulo sur les nombres negatifs */
/* (pas de nombre negatif) */
s += m[i][(d-i+n)%n];
/* Resultat de la fonction */
return(s);
}
/* Fonction de test si une matrice d'entiers est */
/* pandiagonale magique */
/* m : Tableau d'entiers */
/* Resultat fonction : booleen */
public static boolean testMatriceMagique(int [][] m) {
/* Declaration d'une variable et affectation */
/* avec la taille de la matrice */
int n = m.length;
/* Declaration d'une variable v et affectation */
/* avec la somme de la colonne 0 */
int v = sommeColonneMatrice(m,0);
/* Toute somme differente de v trouvee entrainera */
/* la sortie de la fonction avec faux pour resultat */
/* Test des n-1 colonnes restantes */
for ( int i = 1 ; i < n ; i++ )
/* Si une valeur differente de v est trouvee */
if ( v != sommeColonneMatrice(m,i) )
/* Resultat de la fonction : faux */
return(false);
/* Test des n lignes */
for ( int i = 0 ; i < n ; i++ )
/* Si une valeur differente de v est trouvee */
if ( v != sommeLigneMatrice(m,i) )
/* Resultat de la fonction : faux */
return(false);
/* Test des n diagonales descendantes */
for ( int i = 0 ; i < n ; i++ )
/* Si une valeur differente de v est trouvee */
if ( v != sommeDiagonale1Matrice(m,i) )
/* Resultat de la fonction : faux */
return(false);
/* Test des n diagonales montantes */
for ( int i = 0 ; i < n ; i++ )
/* Si une valeur differente de v est trouvee */
if ( v != sommeDiagonale2Matrice(m,i) )
/* Resultat de la fonction : faux */
return(false);
/* Plus aucune valeur n'est a tester et */
/* aucune de celles testees n'a entraine de sortie */
/* a faux */
/* Resultat de la fonction : vrai */
return(true);
}
/* Fonction de creation d'une matrice carree d'entiers */
/* initialisee avec des nombres aleatoires */
/* n : nombres de lignes et de colonnes de la matrice */
/* max : valeur maximale des nombres aleatoires */
/* Resultat fonction : Matrice d'entiers */
public static int [][] creationMatriceAleatoire(int n,int max) {
/* Allocation de la matrice */
int [][] m = new int[n][n];
/* Pour toutes les lignes de la matrice a initialiser */
for ( int i = 0 ; i < n ; i++ )
/* Pour toutes les colonnes de la matrice a initialiser */
for ( int j = 0 ; j < n ; j++ ) {
/* Initialisation avec un nombre aleatoire compris */
/* entre 0 et max */
m[i][j] =(int) (Math.random()*(max+1)); }
/* Resultat de la fonction */
return(m);
}
/* Fonction de creation d'une matrice carree d'entiers */
/* pandiagonale magique */
/* ATTENTION: Cette fonction ne marche que pour */
/* les matrices de taille 4 et 5 et rend toujours */
/* la meme matrice */
/* Une autre taille a pour consequence la creation */
/* d'une matrice ne contenant que des 0 */
/* n : nombres de lignes et de colonnes de la matrice */
/* Resultat fonction : Matrice d'entiers */
public static int [][] matriceMagique(int n) {
if ( n == 4 ) {
int [][] m = { { 7,12, 1,14 },
{ 2,13, 8,11 },
{ 16, 3,10, 5 },
{ 9, 6,15, 4 } };
return(m); }
if ( n == 5 ) {
int [][] m = { { 1,15,24, 8,17 },
{ 23, 7,16, 5,14 },
{ 20, 4,13,22, 6 },
{ 12,21,10,19, 3 },
{ 9,18, 2,11,25 } };
return(m); }
int [][] m = new int[n][n];
return(m);
}
/* Fonction de creation d'une chaine de caracteres */
/* representant un nombre justifie a droite complemente */
/* par des espaces */
/* v : entier a formater */
/* larg : nombre de caracteres de la chaine resultat */
/* Resultat fonction : Chaine de caracteres */
public static String justifieADroite(int v,int larg) {
/* Definition et initialisation de la chaine */
/* avec l'entier a formater */
String s = ""+v;
/* Ajout a gauche a la chaine d'autant de caracteres */
/* espace qu'il le faut pour que sa longueur devienne */
/* superieure ou egale a la largeur recherchee */
while ( s.length() < larg )
s = " "+s;
/* Resultat de la fonction */
return(s);
}
/* Fonction d'affichage d'une matrice d'entiers */
/* m : tableau d'entiers a afficher */
/* larg : largeur de chaque colonne */
public static void affichageMatrice(int [][] m,int larg) {
for ( int i = 0 ; i < m.length ; i++ ) {
/* Pour toute les lignes de la matrice a afficher */
for ( int j = 0 ; j < m[0].length ; j++ ) {
/* Affichage d'un entier de la ligne i */
/* (sans aller a la ligne */
System.out.print(justifieADroite(m[i][j],larg+1)); }
/* On va a la ligne quand tous les entiers d'une ligne */
/* ont ete affiches */
System.out.println(); }
}
/* Fonction principale */
public static void main(String [] args) throws IOException {
/* Lecture au clavier du nombre de lignes */
/* et du nombre de colonnes de la matrice */
System.out.print("Quelle taille : ");
int n = Integer.valueOf(flux.readLine()).intValue();
/* Creation d'une matrice aleatoire de taille n */
int [][] m1 = creationMatriceAleatoire(n,100);
/* Affichage du resultat du remplissage */
System.out.println("La matrice est :");
affichageMatrice(m1,6);
/* Affichage du resultat du test */
System.out.println("Matrice magique ? : "+testMatriceMagique(m1));
/* Creation d'une matrice magique de taille n */
int [][] m2 = matriceMagique(n);
/* Affichage du resultat du remplissage */
System.out.println("La matrice est :");
affichageMatrice(m2,6);
/* Affichage du resultat du test */
System.out.println("Matrice magique ? : "+testMatriceMagique(m2));
}
}

TestMatriceMagique.java

Exercice 2

Calcul de la transposée d'une matrice carrée.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class TransposeeMatrice {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
/* Fonction de recherche de la valeur */
/* de absolue maximale d'une matrice */
/* m : tableau d'entiers ou effectuer la recherche */
/* Resultat fonction : entier */
public static int valAbsMax(int [][] m) {
int ii = 0;
int jj = 0;
for ( int i = 0 ; i < m.length ; i++ ) {
for ( int j = 0 ; j < m[0].length ; j++ ) {
if ( Math.abs(m[i][j]) > Math.abs(m[ii][jj]) ) {
ii = i;
jj = j; } } }
return(m[ii][jj]);
}
/* Fonction de creation d'une chaine de caracteres */
/* representant un nombre justifie a droite complemente */
/* par des espaces */
/* v : entier a formater */
/* larg : nombre de caracteres de la chaine resultat */
/* Resultat fonction : Chaine de caracteres */
public static String justifieADroite(int v,int larg) {
/* Definition et initialisation de la chaine */
/* avec l'entier a formater */
String s = ""+v;
/* Ajout a gauche a la chaine d'autant de caracteres */
/* espace qu'il le faut pour que sa longueur devienne */
/* superieure ou egale a la largeur recherchee */
while ( s.length() < larg )
s = " "+s;
/* Resultat de la fonction */
return(s);
}
/* Fonction d'affichage d'une matrice d'entiers */
/* m : tableau d'entiers a afficher */
/* larg : largeur de chaque colonne */
public static void affichageMatrice(int [][] m) {
int max = valAbsMax(m);
int larg = 1+((""+max).length());
for ( int i = 0 ; i < m.length ; i++ ) {
/* Pour toute les lignes de la matrice a afficher */
for ( int j = 0 ; j < m[0].length ; j++ ) {
/* Affichage d'un entier de la ligne i */
/* (sans aller a la ligne */
System.out.print(justifieADroite(m[i][j],larg+1)); }
/* On va a la ligne quand tous les entiers d'une ligne */
/* ont ete affiches */
System.out.println(); }
}
/* Fonction de creation d'une matrice carree d'entiers */
/* initialisee avec des nombres aleatoires */
/* n : nombres de lignes et de colonnes de la matrice */
/* max : valeur maximale des nombres aleatoires */
/* Resultat fonction : Matrice d'entiers */
public static int [][] creationMatriceAleatoire(int n,int max) {
/* Allocation de la matrice */
int [][] m = new int[n][n];
/* Pour toutes les lignes de la matrice a initialiser */
for ( int i = 0 ; i < n ; i++ )
/* Pour toutes les colonnes de la matrice a initialiser */
for ( int j = 0 ; j < n ; j++ ) {
/* Initialisation avec un nombre aleatoire compris */
/* entre 0 et max */
m[i][j] =(int) (Math.random()*(max+1)); }
/* Resultat de la fonction */
return(m);
}
/* Fonction de calcul de la matrice matrice transposee */
/* d'une matrice carree */
/* m : Tableau d'entiers */
/* Resultat fonction : Tableau d'entiers */
public static int [][] transposeeMatrice(int [][] m) {
/* Calcul et staockage dans la variable n de la taille */
/* de la matrice m */
int n = m.length;
/* Declaration et allocation d'une matrice carree */
/* de taille n */
int [][] t = new int[n][n];
/* Pour tous les entiers d'indice (j,i) de la matrice m */
for ( int i = 0 ; i < n ; i++ )
for ( int j = 0 ; j < n ; j++ )
/* L'entier d'indice (i,j) de t est affecte avec */
/* l'entier d'indice (j,i) de m */
t[i][j] = m[j][i];
/* Resultat de la fonction */
return(t);
}
/* Fonction principale */
public static void main(String [] args) throws IOException {
/* Lecture au clavier de la taille de la matrice */
System.out.print("Taille de la matrice : ");
int n = Integer.valueOf(flux.readLine()).intValue();
/* Creation d'une matrice de n sur n entiers aleatoires */
int [][] m = creationMatriceAleatoire(n,100);
/* Affichage de ma matice m */
System.out.println("La matrice est");
affichageMatrice(m);
/* Creation de la matrice transposee de m */
int [][] mt = transposeeMatrice(m);
/* Affichage du resultat du remplissage */
System.out.println("La matrice transposee est");
affichageMatrice(mt);
}
}

TransposeeMatrice.java

Exercice 3

Mise à la puissance p entière d'une matrice carrée.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class PuissanceMatrice {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
/* Fonction de recherche de la valeur */
/* de absolue maximale d'une matrice */
/* m : tableau d'entiers ou effectuer la recherche */
/* Resultat fonction : entier */
public static int valAbsMax(int [][] m) {
int ii = 0;
int jj = 0;
for ( int i = 0 ; i < m.length ; i++ ) {
for ( int j = 0 ; j < m[0].length ; j++ ) {
if ( Math.abs(m[i][j]) > Math.abs(m[ii][jj]) ) {
ii = i;
jj = j; } } }
return(m[ii][jj]);
}
/* Fonction de creation d'une chaine de caracteres */
/* representant un nombre justifie a droite complemente */
/* par des espaces */
/* v : entier a formater */
/* larg : nombre de caracteres de la chaine resultat */
/* Resultat fonction : Chaine de caracteres */
public static String justifieADroite(int v,int larg) {
/* Definition et initialisation de la chaine */
/* avec l'entier a formater */
String s = ""+v;
/* Ajout a gauche a la chaine d'autant de caracteres */
/* espace qu'il le faut pour que sa longueur devienne */
/* superieure ou egale a la largeur recherchee */
while ( s.length() < larg )
s = " "+s;
/* Resultat de la fonction */
return(s);
}
/* Fonction d'affichage d'une matrice d'entiers */
/* m : tableau d'entiers a afficher */
/* larg : largeur de chaque colonne */
public static void affichageMatrice(int [][] m) {
int max = valAbsMax(m);
int larg = 1+((""+max).length());
for ( int i = 0 ; i < m.length ; i++ ) {
/* Pour toute les lignes de la matrice a afficher */
for ( int j = 0 ; j < m[0].length ; j++ ) {
/* Affichage d'un entier de la ligne i */
/* (sans aller a la ligne */
System.out.print(justifieADroite(m[i][j],larg+1)); }
/* On va a la ligne quand tous les entiers d'une ligne */
/* ont ete affiches */
System.out.println(); }
}
/* Fonction de creation d'une matrice carree d'entiers */
/* initialisee avec des nombres aleatoires */
/* n : nombres de lignes et de colonnes de la matrice */
/* max : valeur maximale des nombres aleatoires */
/* Resultat fonction : Matrice d'entiers */
public static int [][] creationMatriceAleatoire(int n,int max) {
/* Allocation de la matrice */
int [][] m = new int[n][n];
/* Pour toutes les lignes de la matrice a initialiser */
for ( int i = 0 ; i < n ; i++ )
/* Pour toutes les colonnes de la matrice a initialiser */
for ( int j = 0 ; j < n ; j++ ) {
/* Initialisation avec un nombre aleatoire compris */
/* entre 0 et max */
m[i][j] =(int) (Math.random()*(max+1))-max/2; }
/* Resultat de la fonction */
return(m);
}
/* Fonction de creation de la copie d'une matrice */
/* d'entiers */
/* m : Matrice d'entiers a copier */
/* Resultat fonction : Matrice d'entiers */
public static int [][] copieMatrice(int [][] src) {
int l = src.length;
int c = src[0].length;
/* Allocation de la matrice */
int [][] m = new int[l][c];
/* Pour toutes les lignes de la matrice a initialiser */
for ( int i = 0 ; i < l ; i++ )
/* Pour toutes les colonnes de la matrice a initialiser */
for ( int j = 0 ; j < c ; j++ ) {
/* Copie de src dans m pour les valeurs d'indice (i,j) */
m[i][j] = src[i][j]; }
/* Resultat de la fonction */
return(m);
}
/* Fonction de calcul de la matrice produit */
/* de deux matrices carrees */
/* m1,m2 : Tableau d'entiers */
/* Resultat fonction : Tableau d'entiers */
public static int [][] produitMatriceMatrice(int [][] m1,int [][] m2) {
/* Allocation de la matrice */
int n = m1.length;
int [][] m = new int[n][n];
/* Pour toutes les lignes de la matrice a calculer */
for ( int i = 0 ; i < n ; i++ )
/* Pour toutes les colonnes de la matrice a calculer */
for ( int j = 0 ; j < n ; j++ ) {
/* Produit ligne par colonne */
m[i][j] = 0;
for ( int k = 0 ; k < n ; k++ )
m[i][j] += m1[i][k]*m2[k][j]; }
/* Resultat de la fonction */
return(m);
}
/* Fonction de calcul de la matrice a la puissance p */
/* d'une matrice carree */
/* m : Tableau d'entiers */
/* p : entier */
/* Resultat fonction : Tableau d'entiers */
public static int [][] matricePuissance(int [][] m,int p) {
/* Si p est egal a 1, une copie de m est creee */
/* et retournee */
if ( p == 1 )
return(copieMatrice(m));
/* Si p n'est egal a 1 (superieur), un tableau t */
/* est declare pour accueillir le produit de m par m */
int [][] t = produitMatriceMatrice(m,m);
/* Une boucle pour permet d'accumuler dans t */
/* tous les produits t par m necessaires au calcul */
/* final de m a la puissance p */
for ( int i = 2 ; i < p ; i++ )
t = produitMatriceMatrice(t,m);
/* Resultat de la fonction */
return(t);
}
/* Fonction principale */
public static void main(String [] args) throws IOException {
/* Lecture au clavier de la taille de la matrice */
System.out.print("Taille de la matrice : ");
int n = Integer.valueOf(flux.readLine()).intValue();
/* Lecture au clavier de la puissance desiree */
System.out.print("A quelle puissance : ");
int p = Integer.valueOf(flux.readLine()).intValue();
/* Creation d'une matrice de n sur n entiers aleatoires */
int [][] m = creationMatriceAleatoire(n,10);
/* Affichage de ma matice m */
System.out.println("La matrice est :");
affichageMatrice(m);
/* Creation de la matrice m a la puissance p */
int [][] mp = matricePuissance(m,p);
/* Affichage du resultat du remplissage */
System.out.println("m^p :");
affichageMatrice(mp);
}
}

PuissanceMatrice.java

Auteur: Nicolas JANEY
UFR Sciences et Techniques
Université de Besançon
16 Route de Gray, 25030 Besançon
nicolas.janey@univ-fcomte.fr