Correction du TP n°7

Exercice 1

Remplissage d'une matrice.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class RemplissageMatrice {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
/* Fonction de remplissage d'une matrice d'entier */
/* par lecture au clavier */
/* m : tableau d'entier a remplir */
public static void remplissageMatrice(int [][] m) throws IOException {
/* Pour toute les lignes de la matrice a remplir */
for ( int i = 0 ; i < m.length ; i++ )
/* Pour toute les entiers de la ligne i */
/* de la matrice a remplir */
for ( int j = 0 ; j < m[0].length ; j++ ) {
/* Lecture au clavier de la valeur a stocker */
/* a l'indice (i,j) de m */
System.out.print("Valeur d'indice "+i+" "+j+" : ");
m[i][j] = Integer.valueOf(flux.readLine()).intValue(); }
}
/* 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("Combien de lignes : ");
int l = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Combien de colones : ");
int c = Integer.valueOf(flux.readLine()).intValue();
/* Creation d'une matrice de l sur c entiers */
int [][] m = new int[l][c];
/* Remplissage */
remplissageMatrice(m);
}
}

RemplissageMatrice.java

Exercice 2

Affichage d'une matrice.
Les colonnes sont alignées en affichant les valeurs justifiées à droite sur le même nombre de caractères.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class AffichageMatrice {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
/* Fonction d'affichage d'une matrice d'entiers */
/* m : tableau d'entiers a afficher */
public static void affichageMatrice(int [][] m) {
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(m[i][j]+" "); }
/* On va a la ligne quand tous les entiers d'une ligne */
/* ont ete affiches */
System.out.println(); }
}
/* 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 de remplissage d'une matrice d'entiers */
/* par lecture au clavier */
/* m : tableau d'entiers a remplir */
public static void remplissageMatrice(int [][] m) throws IOException {
for ( int i = 0 ; i < m.length ; i++ )
for ( int j = 0 ; j < m[0].length ; j++ ) {
System.out.print("Valeur d'indice "+i+" "+j+" : ");
m[i][j] = Integer.valueOf(flux.readLine()).intValue(); }
}
/* 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("Combien de lignes : ");
int l = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Combien de colones : ");
int c = Integer.valueOf(flux.readLine()).intValue();
/* Creation d'une matrice de l sur c entiers */
int [][] m = new int[l][c];
/* Remplissage */
remplissageMatrice(m);
/* Affichage du resultat du remplissage */
System.out.print("La matrice est");
affichageMatrice(m);
/* Affichage du resultat du remplissage */
System.out.print("La matrice avec affichage formate est");
affichageMatrice(m,5);
}
}

AffichageMatrice.java

Exercice 3

Recherche de la valeur minimale et des indices de la valeur minimale d'une matrice.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class RechercheMinimumMatrice {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
/* Fonction de recherche de la valeur minimale */
/* d'une matrice */
/* m : tableau d'entiers ou effectuer la recherche */
/* Resultat fonction : entier */
public static int minimumMatrice(int [][] m) {
/* Definition et initialisation du minimum courant */
int min = m[0][0];
for ( int i = 0 ; i < m.length ; i++ ) {
/* Pour toute les lignes de la matrice ou rechercher */
for ( int j = 0 ; j < m[0].length ; j++ ) {
/* Pour toute les colones de la matrice ou rechercher */
if ( m[i][j] < min )
min = m[i][j]; } }
return(min);
}
/* Fonction de recherche des indices de la valeur */
/* minimale d'une matrice */
/* m : tableau d'entiers ou effectuer la recherche */
/* Resultat fonction : Tableau de deux entiers */
public static int [] indicesMinimumMatrice(int [][] m) {
/* Definition et initialisation d'un tableau */
/* de deux entiers */
/* Indice 0 : abscice du minimum */
/* Indice 1 : ordonnee du minimum */
int [] min = new int[2];
min[0] = 0;
min[1] = 0;
for ( int i = 0 ; i < m.length ; i++ ) {
/* Pour toute les lignes de la matrice ou rechercher */
for ( int j = 0 ; j < m[0].length ; j++ ) {
/* Pour toute les colones de la matrice ou rechercher */
if ( m[i][j] < m[min[0]][min[1]] ) {
min[0] = i;
min[1] = j; } } }
return(min);
}
/* Fonction de creation d'une matrice d'entiers */
/* initialisee avec des nombres aleatoires */
/* l,c : 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 l,int c,int max) {
/* 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++ ) {
/* Initialisation avec un nombre aleatoire compris */
/* entre 0 et max */
m[i][j] =(int) (Math.random()*(max+1)); }
/* Resultat de la fonction */
return(m);
}
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("Combien de lignes : ");
int l = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Combien de colones : ");
int c = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Valeur maximale : ");
int max = Integer.valueOf(flux.readLine()).intValue();
/* Creation d'une matrice de l sur c entiers */
int [][] m = creationMatriceAleatoire(l,c,max);
/* Affichage de la matrice */
affichageMatrice(m,(""+max).length());
/* Affichages */
System.out.println("Valeur minimale : "+minimumMatrice(m));
int [] imin = indicesMinimumMatrice(m);
System.out.println("Abscice : "+imin[0]);
System.out.println("Ordonnee : "+imin[1]);
}
}

RechercheMinimumMatrice.java

Exercice 4

Recherche de la somme des valeurs de la diagonale principale d'une matrice carrée.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class SommeDiagonaleMatrice {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
/* Fonction de calcul de la somme des valeurs */
/* de la diagonale d'une matrice carree */
/* m : tableau d'entiers a traiter */
/* Resultat fonction : entier */
public static int sommeDiagonaleMatrice(int [][] m) {
/* Definition et initialisation a 0 d'un entier */
/* d'accumulation des valeurs de la diagonale */
int s = 0;
/* Pour toutes les lignes de la matrice */
for ( int i = 0 ; i < m.length ; i++ )
/* Accumulation dans s de la valeur d'indice (i,i) */
s += m[i][i];
/* Resultat de la fonction */
return(s);
}
/* Fonction de creation d'une matrice d'entiers */
/* initialisee avec des nombres aleatoires */
/* l,c : 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 l,int c,int max) {
/* 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++ ) {
/* Initialisation avec un nombre aleatoire compris */
/* entre 0 et max */
m[i][j] =(int) (Math.random()*(max+1)); }
/* Resultat de la fonction */
return(m);
}
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("Taille de la matrice : ");
int n = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Valeur maximale : ");
int max = Integer.valueOf(flux.readLine()).intValue();
/* Creation d'une matrice de n sur n entiers */
int [][] m = creationMatriceAleatoire(n,n,max);
/* Affichage de la matrice */
affichageMatrice(m,(""+max).length());
/* Affichage de somme de la diagonale de la matrice */
System.out.println("Somme diagonale : "+sommeDiagonaleMatrice(m));
}
}

SommeDiagonaleMatrice.java

Exercice 5

Recherche du produit de deux matrices carrées.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class ProduitMatriceMatrice {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
/* Fonction de calcul de la matrice produit */
/* de deux matrices carrees */
/* m1,m2 : Tableau d'entier */
/* 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 creation d'une matrice d'entiers */
/* initialisee avec des nombres aleatoires */
/* l,c : 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 l,int c,int max) {
/* 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++ ) {
/* Initialisation avec un nombre aleatoire compris */
/* entre 0 et max */
m[i][j] =(int) (Math.random()*(max+1)); }
/* Resultat de la fonction */
return(m);
}
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("Taille des matrices : ");
int n = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Valeur maximale : ");
int max = Integer.valueOf(flux.readLine()).intValue();
/* Creation de deux matrices de n sur n entiers */
int [][] m1 = creationMatriceAleatoire(n,n,max);
int [][] m2 = creationMatriceAleatoire(n,n,max);
/* Affichage des deux matrices */
System.out.println("1ere matrice : ");
affichageMatrice(m1,(""+max).length());
System.out.println("2eme matrice : ");
affichageMatrice(m2,(""+max).length());
/* Calcul et affichage du produit des deux matrices */
int [][] m = produitMatriceMatrice(m1,m2);
System.out.println("Produit : ");
affichageMatrice(m,(""+max).length()*2);
}
}

ProduitMatriceMatrice.java

Exercice 5 bis

Recherche du produit de deux matrices quelconques.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class ProduitMatriceMatrice2 {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
/* Fonction de calcul de la matrice produit */
/* de deux matrices de tailles quelconques */
/* m1,m2 : Tableau d'entier */
/* Resultat fonction : Tableau d'entiers */
public static int [][] produitMatriceMatrice(int [][] m1,int [][] m2) {
/* Allocation de la matrice */
int n = m1.length;
int m = m1[0].length;
int p = m2[0].length;
int [][] mt = new int[n][p];
/* 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 < p ; j++ ) {
/* Produit ligne par colonne */
mt[i][j] = 0;
for ( int k = 0 ; k < m ; k++ )
mt[i][j] += m1[i][k]*m2[k][j]; }
/* Resultat de la fonction */
return(mt);
}
/* Fonction de creation d'une matrice d'entiers */
/* initialisee avec des nombres aleatoires */
/* l,c : 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 l,int c,int max) {
/* 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++ ) {
/* Initialisation avec un nombre aleatoire compris */
/* entre 0 et max */
m[i][j] =(int) (Math.random()*(max+1)); }
/* Resultat de la fonction */
return(m);
}
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 des deux matrices */
System.out.println("Tailles des matrices");
System.out.print("N : ");
int n = Integer.valueOf(flux.readLine()).intValue();
System.out.print("M : ");
int m = Integer.valueOf(flux.readLine()).intValue();
System.out.print("P : ");
int p = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Valeur maximale : ");
int max = Integer.valueOf(flux.readLine()).intValue();
/* Creation des deux matrices */
int [][] m1 = creationMatriceAleatoire(n,m,max);
int [][] m2 = creationMatriceAleatoire(m,p,max);
/* Affichage des deux matrices */
System.out.println("1ere matrice : ");
affichageMatrice(m1,(""+max).length());
System.out.println("2eme matrice : ");
affichageMatrice(m2,(""+max).length());
/* Calcul et affichage du produit des deux matrices */
int [][] pr = produitMatriceMatrice(m1,m2);
System.out.println("Produit : ");
affichageMatrice(pr,(""+max).length()*2);
}
}

ProduitMatriceMatrice2.java

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