Vous êtes sur la page 1sur 12

Algorithmique et Programmation 2 Université de La Réunion

Tableaux et chaînes de caractères

Exercice 1
class Exo1
{
public static void main (String args[])
{
System.out.print("Donnez un entier: ");
int n = Clavier.lireInt();

int t[] = new int[n];


for (int i = 0; i < n; i++)
{
System.out.print("Valeur d'indice " + i + ": ");
t[i] = Clavier.lireInt();
}

int somme, min, max;


somme = min = max = t[0];
for (int i = 1; i < n; i++)
{
if (t[i] < min) min = t[i];
if (t[i] > max) max = t[i];
somme += t[i];
}
double moy = ((double) somme) / n;

System.out.println("moyenne = " + moy);


System.out.println("min = " + min);
System.out.println("max = " + max);
}
}

Exercice 2
class Vecteur
{
private double coordonnees[];

Vecteur (int n)
{
coordonnees = new double[n];
for (int i = 0; i < n; i++) coordonnees[i] = 0.0;
}

1
Algorithmique et Programmation 2 Université de La Réunion

void saisir ()
{
for (int i = 0; i < coordonnees.length; i++)
{
System.out.print("coordonnee " + i + ": ");
coordonnees[i] = Clavier.lireDouble();
}
}

public String toString ()


{
String result = new String("(");
for (int i = 0; i < coordonnees.length; i++)
{
result += coordonnees[i];
if (i < coordonnees.length-1) result += "; ";
}
result += ")";
return result;
}

Vecteur somme (Vecteur v)


{
Vecteur result = new Vecteur(coordonnees.length);
if (coordonnees.length != v.coordonnees.length)
System.out.println("Erreur: somme de vecteurs incompatibles!");
else
for (int i = 0; i < coordonnees.length; i++)
result.coordonnees[i] = coordonnees[i] + v.coordonnees[i];
return result;
}

double prodScal (Vecteur v)


{
double result = 0;
if (coordonnees.length != v.coordonnees.length)
System.out.println("Erreur: produit de vecteurs incompatibles!");
else
for (int i = 0; i < coordonnees.length; i++)
result += coordonnees[i] * v.coordonnees[i];
return result;
}
}

class TestVecteur
{
public static void main (String args[])
{
Vecteur v1, v2, somme;

System.out.print("dimension de v1: ");


int n1 = Clavier.lireInt();
v1 = new Vecteur(n1);
System.out.println("donnez les coordonnees de v1:");

2
Algorithmique et Programmation 2 Université de La Réunion

v1.saisir();

System.out.print("dimension de v2: ");


int n2 = Clavier.lireInt();
v2 = new Vecteur(n2);
System.out.println("donnez les coordonnees de v2:");
v2.saisir();

somme = v1.somme(v2);
System.out.println("v1 + v2 = " + somme);

double prod = v1.prodScal(v2);


System.out.println("v1 * v2 = " + prod);
}
}

Exercice 3
class Matrice
{
private double composantes[][];

Matrice (int n)
{
composantes = new double [n] [];
for (int i = 0; i < n; i++)
{
composantes[i] = new double[n];
for (int j = 0; j < n; j++) composantes[i][j] = 0.0;
}
}

void saisir ()
{
for (int i = 0; i < composantes.length; i++)
for (int j = 0; j < composantes.length; j++)
{
System.out.print("[" + i + "][" + j + "]: ");
composantes[i][j] = Clavier.lireDouble();
}
}

public String toString ()


{
String result = new String("[");
for (int i = 0; i < composantes.length; i++)
{
if (i != 0) result += " ";
result += "[";
for (int j = 0; j < composantes.length; j++)
{
result += composantes[i][j];
if (j < composantes.length-1) result += "; ";

3
Algorithmique et Programmation 2 Université de La Réunion

}
result += "]";
if (i < composantes.length-1) result += "\n";
}
result += "]";
return result;
}

Matrice somme (Matrice m)


{
Matrice result = new Matrice(composantes.length);
if (composantes.length != m.composantes.length)
System.out.println("Erreur: somme de matrices incompatibles!");
else
for (int i = 0; i < composantes.length; i++)
for (int j = 0; j < composantes.length; j++)
result.composantes[i][j] =
composantes[i][j] + m.composantes[i][j];
return result;
}

Matrice produit (Matrice m)


{
Matrice result = new Matrice(composantes.length);
if (composantes.length != m.composantes.length)
System.out.println("Erreur: produit de matrices incompatibles!");
else
for (int i = 0; i < composantes.length; i++)
for (int j = 0; j < composantes.length; j++)
{
result.composantes[i][j] = 0.0;
for (int k = 0; k < composantes.length; k++)
result.composantes[i][j] +=
composantes[i][k] * m.composantes[k][j];
}
return result;
}
}

class TestMatrice
{
public static void main (String args[])
{
Matrice m1, m2, somme, produit;

System.out.print("dimension de m1: ");


int n1 = Clavier.lireInt();
m1 = new Matrice(n1);
System.out.println("donnez les composantes de m1: ");
m1.saisir();

System.out.print("dimension de m2: ");


int n2 = Clavier.lireInt();
m2 = new Matrice(n2);

4
Algorithmique et Programmation 2 Université de La Réunion

System.out.println("donnez les composantes de m2: ");


m2.saisir();

somme = m1.somme(m2);
System.out.println("m1 + m2 = \n" + somme);

produit = m1.produit(m2);
System.out.println("m1 * m2 = \n" + produit);
}
}

Exercice 4
class Systeme
{
/**
* Une classe implémentant un système Ax = b
* de n équations linéaires à n inconnues.
*/

// -----------------------------------------------
// LES CHAMPS:
private double A[][];
private double b[];
private int n;

// -----------------------------------------------
// LES METHODES:

/**
* Le constructeur fixe le nombre n à partir de
* son argument puis crée la matrice A, le vecteur b
* et initialise leurs cases à 0.0 .
*/
Systeme (int dimension)
{
n = dimension;
// Création de la matrice A et du vecteur b:
A = new double[n][];
b = new double[n];
for (int lig = 0; lig < n; lig++)
{
A[lig] = new double [n];
for (int col = 0; col < n; col++) A[lig][col] = 0.0;
b[lig] = 0.0;
}
}

/**
* Saisie des coefficients du système.
*/
void saisir ()
{

5
Algorithmique et Programmation 2 Université de La Réunion

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


{
System.out.println("Ligne " + lig + " :");
for (int col = 0; col < n; col++)
{
System.out.print(" A[" + lig + "][" + col + "] = ");
A[lig][col] = Clavier.lireDouble();
}
System.out.print(" b[" + lig + "] = ");
b[lig] = Clavier.lireDouble();
System.out.println();
}
}

/**
* Résolution du système par la méthode du pivot de Gauss.
*/
void resoudre ()
{
if (diagonaliser())
{
System.out.print("une seule solution = ");
System.out.print("(");
for (int lig = 0; lig < n; lig++)
{
System.out.print(b[lig]);
if (lig < n-1) System.out.print("; ");
}
System.out.println(").");
}
else System.out.println("zero ou une infinite de solutions.");
}

/**
* Cherche le numéro de la ligne pivot à partir
* de la colonne col; si aucun pivot n'est trouvé,
* renvoie le nombre n.
*/
int chercherPivot (int col)
{
for (int lig = col; lig < n; lig++)
if (A[lig][col] != 0) return lig;
return n;
}

/**
* Permute les lignes lig1 et lig2 du système.
*/
void permuter (int lig1, int lig2)
{
double temp;
// permutation des lignes de A:
for (int col = lig1; col < n; col++)
{

6
Algorithmique et Programmation 2 Université de La Réunion

temp = A[lig1][col];
A[lig1][col] = A[lig2][col];
A[lig2][col] = temp;
}
// permutation des lignes de b:
temp = b[lig1];
b[lig1] = b[lig2];
b[lig2] = temp;
}

/**
* Divise la ligne lig du système par pivot.
*/
void diviser (int lig, double pivot)
{
for (int col = lig; col < n; col++) A[lig][col] /= pivot;
b[lig] /= pivot;
}

/**
* Remplace Lj (la ligne j) par
* Lj - A[j][i] * Li.
*/
void soustraire (int i, int j)
{
// on mémorise A[j][i] (sinon problème, voir boucle for)
double A_ji = A[j][i];
// on traite A:
for (int col = i; col < n; col++)
A[j][col] -= A_ji * A[i][col];
// on traite b:
b[j] -= A_ji * b[i];
}

boolean diagonaliser ()
{
int lignePivot;
double pivot;

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


{
lignePivot = chercherPivot(lig);
if (lignePivot == n) return false;
pivot = A[lignePivot][lig];
permuter(lig, lignePivot);
diviser(lig, pivot);
for (int l = 0; l < n; l++)
if (l != lig) soustraire(lig, l);
}
return true;
}
}

7
Algorithmique et Programmation 2 Université de La Réunion

class Gauss
{
public static void main (String args[])
{
System.out.println("\nResolution d'un systeme de la forme Ax = b");

// Nombre d'équations et d'inconnues:


System.out.print("\n** nombre d'equations et d'inconnues: ");
int n = Clavier.lireInt();

// Création du système:
Systeme S = new Systeme(n);

// Saisie du système:
System.out.println("\n** saisie du systeme:");
S.saisir();

// Résolution du système:
System.out.print("** resultat: ");
S.resoudre();
System.out.println();
}
}

Exercice 5
class Sudoku
{
// ---------------------------------------
// Champs:
// une grille de Sudoku est un tableau d'entiers
// où la valeur 0 représente une case vide
private int grille[][];

/**
* Constructeur.
*/
Sudoku (int uneGrille[][])
{
grille = new int[9][];
for (int i = 0; i < 9; i++)
{
grille[i] = new int[9];
for (int j = 0; j < 9; j++)
grille[i][j] = uneGrille[i][j];
}
}

/**
* Convertion en chaîne de caractères.
*/
public String toString ()

8
Algorithmique et Programmation 2 Université de La Réunion

{
String ch = "+---------+---------+---------+\n";
for (int i = 0; i < 9; i++)
{
ch += "|";
for (int j = 0; j < 9; j++)
{
if (grille[i][j] == 0) ch += " ";
else ch += " " + grille[i][j] + " ";
if (j % 3 == 2) ch += "|";
}
ch += "\n";
if (i % 3 == 2)
ch += "+---------+---------+---------+\n";
}
ch += "\n";
return ch;
}

/**
* Pour résoudre une grille de Sudoku.
*/
boolean resoudre ()
{
// Calcul des coordonnées de la première case vide de la grille:
int i = 0, j = 0;
boolean caseVideRencontree = false;
for (i = 0; i < 9; i++)
{
for (j = 0; j < 9; j++)
if (grille[i][j] == 0) { caseVideRencontree = true; break; }
if (caseVideRencontree) break;
}

// Maintenant, (i,j) sont les coordonnées de la première case vide


// de la grille si cette case existe, sinon i et j valent 9
if (caseVideRencontree)
{
// On remplit la case vide trouvée avec les valeurs possibles:
boolean T[] = new boolean[9];
valeursPossibles(i, j, T);
for (int k = 0; k < 9; k++)
if (T[k])
{
grille[i][j] = k+1;
if (resoudre())
// la valeur k+1 conduit à une solution,
// ce n'est pas la peine de considérer
// les autres valeurs possibles:
return true;
else
// la valeur k+1 ne conduit pas à une
// solution, il faut donc vider la case

9
Algorithmique et Programmation 2 Université de La Réunion

// et considérer les autres valeurs possibles:


grille[i][j] = 0;
}
// Aucune valeur possible n'a conduit à une solution:
return false;
}
else return true;
}

private void valeursPossibles (int lig, int col, boolean T[])


{
// Recherche des valeurs possibles pour la case (lig,col).
// Ces valeurs sont stockees dans T.

// Initialisation de T:
for (int k = 0; k < 9; k++) T[k] = true;

// On elimine les valeurs presentes dans la ligne lig:


for (int j = 0; j < 9; j++)
if (grille[lig][j] != 0) T[grille[lig][j]-1] = false;
// On elimine les valeurs presentes dans la colonne col:
for (int i = 0; i < 9; i++)
if (grille[i][col] != 0) T[grille[i][col]-1] = false;
// On elimine les valeurs presentes dans le carre 3x3
// ou est situee la case (lig,col):
lig = lig - (lig % 3); // ligne du coin en haut a gauche du carre 3x3
col = col - (col % 3); // colonne du coin en haut a gauche du carre 3x3
for (int i = lig; i < lig+3; i++)
for (int j = col; j < col+3; j++)
if (grille[i][j] != 0) T[grille[i][j]-1] = false;
}
}

class TestSudoku
{
public static void main (String args[])
{
int exemple[][] = {
{0, 1, 0, 0, 0, 6, 0, 2, 0},
{0, 9, 8, 5, 0, 0, 0, 0, 7},
{7, 0, 0, 0, 0, 0, 1, 0, 0},

{0, 0, 0, 6, 0, 0, 9, 1, 5},
{6, 0, 0, 0, 0, 0, 0, 0, 2},
{4, 3, 9, 0, 0, 5, 0, 0, 0},

{0, 0, 6, 0, 0, 0, 0, 0, 4},
{3, 0, 0, 0, 0, 9, 2, 8, 0},
{0, 7, 0, 8, 0, 0, 0, 9 ,0}
};

Sudoku S = new Sudoku(exemple);


if (S.resoudre()) System.out.println(S);
else System.out.println("Pas de solution !\n\n");

10
Algorithmique et Programmation 2 Université de La Réunion

}
}

Exercice 6
class Exo6
{
public static void main (String args[])
{
// Saisie d'un mot au clavier:
System.out.print("donnez un mot: ");
String mot = Clavier.lireString();

// On recopie le mot et on convertit


// la copie en minuscules:
String motMinuscules = mot.toLowerCase();

// Les voyelles:
char voyelles[] = {'a', 'e', 'i', 'o', 'u', 'y'};

// Un tableau pour compter : une case par voyelle avec


// compte[0] -> a
// compte[1] -> e
// compte[2] -> o
// compte[3] -> i
// compte[4] -> u
// compte[5] -> y
int compte[] = {0, 0, 0, 0, 0, 0};

// Décompte des voyelles:


for (int i = 0; i < mot.length(); i++)
for (int j = 0; j < voyelles.length; j++)
if (motMinuscules.charAt(i) == voyelles[j])
{ compte[j]++; break; }

// Affichage des résultats:


System.out.println("le mot " + mot + " comporte:");
for (int i = 0; i < voyelles.length; i++)
System.out.println(compte[i] + " fois la lettre " + voyelles[i]);
}
}

Exercice 7
class Exo7
{
public static void main (String args[])
{
// On crée un tableau de String
// destiné à recevoir les mots:
System.out.print("combien de mots ? ");
int n = Clavier.lireInt();

11
Algorithmique et Programmation 2 Université de La Réunion

String lesMots[] = new String[n];

// Saisie des mots:


System.out.println("donnez vos mots:");
for (int i = 0; i < n; i++)
lesMots[i] = Clavier.lireString();

// On convertit les mots en minuscules:


String motsMinuscules[] = new String[n];
for (int i = 0; i < n; i++)
motsMinuscules[i] = lesMots[i].toLowerCase();

// Tri des mots (tri bulle):


String temp;
for (int i = 0; i < n-1; i++)
for (int j = n-1; j >= i+1; j--)
if (motsMinuscules[j].compareTo(motsMinuscules[j-1]) < 0)
{ // deux mots dans le mauvais ordre:
// on les intervertit dans motsMinuscules:
temp = motsMinuscules[j];
motsMinuscules[j] = motsMinuscules[j-1];
motsMinuscules[j-1] = temp;
// on les intervertit aussi dans lesMots:
temp = lesMots[j];
lesMots[j] = lesMots[j-1];
lesMots[j-1] = temp;
}

// Affichage du résultat:
System.out.println("Liste des mots par ordre alphabetique:");
for (int i = 0; i < n; i++)
System.out.println(lesMots[i]);
}
}

12