Correction du TP n°3

Exercice 1

Initialisation d'un tableau avec ses valeurs d'indice.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
public class InitTableauIndice {
public static void initTableauIndice(int [] t) {
int i;
for ( i = 0 ; i < t.length ; i++ )
t[i] = i;
}
public static void afficheTableau(int [] t) {
int i;
for ( i = 0 ; i < t.length ; i++ )
System.out.print(t[i]+" ");
System.out.println();
}
/* Fonction principale */
public static void main(String [] args) {
int [] t1 = new int[5];
int [] t2 = new int[10];
initTableauIndice(t1);
initTableauIndice(t2);
afficheTableau(t1);
afficheTableau(t2);
}
}

InitTableauIndice.java

Exercice 2

Affichage du contenu d'un tableau d'entiers.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
public class AffichageTableau {
public static void initTableau(int [] t) {
int i;
for ( i = 0 ; i < t.length ; i++ )
t[i] =(int) (Math.random()*10);
}
public static void afficheTableau(int [] t) {
int i;
for ( i = 0 ; i < t.length ; i++ )
System.out.print(t[i]+" ");
System.out.println();
}
/* Fonction principale */
public static void main(String [] args) {
int [] t = new int[10];
initTableau(t);
afficheTableau(t);
}
}

AffichageTableau.java

Exercice 3

Test d'égalité entre les contenus de deux tableaux d'entiers.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
public class TestEgaliteTableaux {
/* Fonction d'initialisation d'un tableau */
/* avec des valeurs tirees au hasard entre 0 et 9 */
public static void initTableau(int [] t) {
int i;
for ( i = 0 ; i < t.length ; i++ )
t[i] =(int) (Math.random()*10);
}
/* Fonction d'affichage d'un tableau */
public static void afficheTableau(int [] t) {
int i;
for ( i = 0 ; i < t.length ; i++ )
System.out.print(t[i]+" ");
System.out.println();
}
/* Fonction de test d'egalite */
/* de deux tableaux d'entiers */
/* t1, t2 : tableaux d'entier a tester */
/* Resultat de la fonction : booleen */
public static boolean egaux(int [] t1,int [] t2) {
int i = 0; // variable incrementee pour tester
// successivement les entiers des tableaux
/* La boucle tant que programmee s'execute sur deux */
/* composees par et (1) les tableaux n'ont pas encore */
/* ete totalement parcourus (2) les cellules d'indice i */
/* des deux tableaux sont égales */
while ( ( i < t1.length ) && ( t1[i] == t2[i] ) )
/* Increment de i */
i = i+1;
/* Le booleen retourne est le resultat du test */
/* entre i = t1.length (i.e. si i atteint cette valeur, */
/* la boucle s'est executee pour l'integralite */
/* du tableau sans etablir que deux cellules de meme */
/* indice sont differentes */
return(i == t1.length);
}
/* Fonction principale */
public static void main(String [] args) {
int [] t1 = new int[10]; // Declaration et allocation du 1er tableau
int [] t2 = new int[10]; // Declaration et allocation du 2eme tableau
/* Remplissage des deux tableaux avec des valeurs */
/* tirees au hasard */
initTableau(t1);
initTableau(t2);
/* Affichage des deux tableaux */
afficheTableau(t1);
afficheTableau(t2);
/* Test d'agalite et affichage du resultat */
System.out.println("Tableaux egaux : "+egaux(t1,t2));
}
}

TestEgaliteTableaux.java

Exercice 4

Produit scalaire des vecteurs matérialisés par deux tableaux d'entiers.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
public class ProduitScalaire {
/* Fonction d'initialisation d'un tableau */
/* avec des valeurs tirees au hasard entre 0 et 9 */
public static void initTableau(int [] t) {
int i;
for ( i = 0 ; i < t.length ; i++ )
t[i] =(int) (Math.random()*10);
}
/* Fonction d'affichage d'un tableau */
public static void afficheTableau(int [] t) {
int i;
for ( i = 0 ; i < t.length ; i++ )
System.out.print(t[i]+" ");
System.out.println();
}
public static int produitScalaire(int [] t1,int [] t2) {
int i = 0;
int p = 0;
for ( i = 0 ; i < t1.length ; i++ )
p = p+t1[i]*t2[i];
return(p);
}
/* Fonction principale */
public static void main(String [] args) {
int [] t1 = new int[10];
int [] t2 = new int[10];
initTableau(t1);
initTableau(t2);
afficheTableau(t1);
afficheTableau(t2);
System.out.println("Produit scalaire : "+produitScalaire(t1,t2));
}
}

ProduitScalaire.java

Exercice 5

Recherches de minimum et maximum dans un tableau d'entiers.
Dans la solution proposée, des fonctions élémentaires ont été programmées pour rechercher les minimum, maximum, indice du minimum et indice du maximum. Ces fonctions sont utilisables individuellement.
Par ailleurs, une méthode plus élaborée est proposée pour calculer ces 4 informations en une fois et rendre un tableau de 4 valeurs entières comme résultat.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
public class RechercheMinMax {
/* Fonction d'initialisation d'un tableau */
/* avec des valeurs tirees au hasard entre 0 et 9 */
public static void initTableau(int [] t) {
int i;
for ( i = 0 ; i < t.length ; i++ )
t[i] =(int) (Math.random()*1000);
}
/* Fonction d'affichage d'un tableau */
public static void afficheTableau(int [] t) {
int i;
for ( i = 0 ; i < t.length ; i++ )
System.out.print(t[i]+" ");
System.out.println();
}
public static int min(int [] t) {
int i;
int mini = t[0];
for ( i = 1 ; i < t.length ; i++ )
if ( t[i] < mini )
mini = t[i];
return(mini);
}
public static int indiceMin(int [] t) {
int i;
int mini = t[0];
int imin = 0;
for ( i = 1 ; i < t.length ; i++ )
if ( t[i] < mini ) {
imin = i;
mini = t[i]; }
return(imin);
}
public static int indiceMax(int [] t) {
int i;
int maxi = t[0];
int imax = 0;
for ( i = 1 ; i < t.length ; i++ )
if ( t[i] > maxi ) {
imax = i;
maxi = t[i]; }
return(imax);
}
public static int max(int [] t) {
int i;
int maxi = t[0];
for ( i = 1 ; i < t.length ; i++ )
if ( t[i] > maxi )
maxi = t[i];
return(maxi);
}
public static int [] rechercheMinMax(int [] t) {
int i;
int maxi = t[0];
int imax = 0;
int mini = t[0];
int imin = 0;
int [] mm = new int[4];
for ( i = 1 ; i < t.length ; i++ )
if ( t[i] > maxi ) {
imax = i;
maxi = t[i]; }
else
if ( t[i] < mini ) {
imin = i;
mini = t[i]; }
mm[0] = maxi;
mm[1] = mini;
mm[2] = imax;
mm[3] = imin;
return(mm);
}
/* Fonction principale */
public static void main(String [] args) {
int [] t = new int[20];
initTableau(t);
System.out.println("Le tableau contient les entiers :");
afficheTableau(t);
System.out.println("Valeur minimale : "+min(t));
System.out.println("Indice valeur minimale : "+indiceMin(t));
System.out.println("Valeur maximale : "+max(t));
System.out.println("Indice valeur maximale : "+indiceMax(t));
initTableau(t);
System.out.println("Le tableau contient les entiers :");
afficheTableau(t);
int [] r = rechercheMinMax(t);
System.out.println("maximum, minimum, indice maximum, indice minimum :");
afficheTableau(r);
}
}

RechercheMinMax.java

Exercice 6

Recherche du nombre d'occurences d'une valeur entière dans un tableau d'entiers.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class NombreOccurrences {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
/* Fonction d'initialisation d'un tableau */
/* avec des valeurs tirees au hasard entre 0 et 9 */
public static void initTableau(int [] t) {
int i;
for ( i = 0 ; i < t.length ; i++ )
t[i] =(int) (Math.random()*10);
}
/* Fonction d'affichage d'un tableau */
public static void afficheTableau(int [] t) {
int i;
for ( i = 0 ; i < t.length ; i++ )
System.out.print(t[i]+" ");
System.out.println();
}
public static int nombreOccurence(int [] t,int v) {
int cpt = 0;
int i;
for ( i = 0 ; i < t.length ; i++ )
if ( t[i] == v )
cpt++;
return(cpt);
}
/* Fonction principale */
public static void main(String [] args) throws IOException {
int [] t = new int[20];
initTableau(t);
System.out.println("Contenu du tableau : ");
afficheTableau(t);
System.out.print("Valeur a rechercher : ");
int v = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Le nombre d'occurrences de "+v+" est : "+nombreOccurence(t,v));
}
}

NombreOccurrences.java

Exercice supplémentaire 1

Initialisation d'un tableau avec des valeurs aléatoires.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
public class InitTableauAleatoire {
public static void initTableau(int [] t) {
int i;
for ( i = 0 ; i < t.length ; i++ )
t[i] =(int) (Math.random()*10);
}
public static void afficheTableau(int [] t) {
int i;
for ( i = 0 ; i < t.length ; i++ )
System.out.print(t[i]+" ");
System.out.println();
}
/* Fonction principale */
public static void main(String [] args) {
int [] t1 = new int[10];
int [] t2 = new int[10];
initTableau(t1);
initTableau(t2);
afficheTableau(t1);
afficheTableau(t2);
}
}

InitTableauAleatoire.java

Exercice supplémentaire 2

Test de la qualité du générateur de nombres aléatoires de Java.

/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Fevrier 2005 */
import java.io.*;
public class TestGenerateurNombreAleatoire {
static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
public static void afficheTableau(int [] t) {
int i;
for ( i = 0 ; i < t.length ; i++ )
System.out.print(t[i]+" ");
System.out.println();
}
public static int nombreAleatoire(int max) {
return((int) (Math.random()*(max+1)));
}
public static int [] generationClasses(int nb,int cl) {
int [] effectifs = new int[cl];
int i;
for ( i = 0 ; i < nb ; i++ ) {
effectifs[nombreAleatoire(cl-1)]++; }
return(effectifs);
}
/* Fonction principale */
public static void main(String [] args) throws IOException {
System.out.print("Nombre de valeurs aleatoires a generer : ");
int nb = Integer.valueOf(flux.readLine()).intValue();
System.out.print("Nombre de classes a generer : ");
int cl = Integer.valueOf(flux.readLine()).intValue();
int [] effectifs = generationClasses(nb,cl);
System.out.println("Effectifs : ");
afficheTableau(effectifs);
}
}

TestGenerateurNombreAleatoire.java

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