Remarque: Le
but n'est pas de "faire" une liste d'exercice, mais de comprendre ce
qui se passe. Les exercices doivent servir de support à la
discussion, n'hésitez
pas à poser des questions !
Objectifs de
la séance: boucles, tableaux...
Rappels:
Déclaration/instantiation
d'un tableau:
int monTableau[] = new int[N];
-> déclaration d'un tableau d'entiers de taille N (où
N est un entier).
remarque:
monTableau.length est la taille de monTableau (ici la valeur de N).
double monTableau2[][] = new double[3][N];
-> déclaration d'un tableau de 3 tableaux de doubles, chacun
étant de taille N (il s'agit donc d'une "matrice" d'ordre 3xN).
Les fonctions:
On les définit entre la première ligne ( public class
exercice { ) et la ligne du main.
Syntaxe:
public static type0 nom_de_la_fonction(type1 argument1, type2 argument2
...) {
// corps de la fonction
}
où type0 est le type de retour de la fonction
(éventuellement void s'il n'y a pas de retour)
et type 1, type 2 ... sont les types des variables argument1, argument2
... passées en argument de la fonction.
Exemple 1:
public static double fonction_1(int k, double x) {
return Math.cos(x*k);
}
Cette fonction sera appelée dans le main (et son résultat
affecté à la variable x de type double) par:
x=fonction_1(2,3.4);
Exemple 2:
public static double trace(double mat[][]) {
// trace d'une matrice carree
double t=0.0;
for (int i=0;i<mat.length;i++)
t+=mat[i][i];
return t;
}
Pour les exercices suivants, on
créera un nouveau projet sous Eclipse et on inclura le
package Utilitaire.jar comme en TD.
Exercice 0 - manipulation d'un
tableau (déclaration, boucles for) (pour ceux qui n'étaient pas
présents à la séance de clinique
précédente)
Ecrire un programme qui crée un tableau de 10 entiers dont le
ième élément a pour valeur le carré de i,
un tableaux de 10 double dont le ième élément a
pour valeur le cosinus de i (fonction Math.cos), et un tableau
bidimensionnel d'entiers de taille 3x4 dont l'élément
d'indice (i,j) a pour valeur i*j.
Afficher ces trois tableaux (forme libre).
Exercice 1 - manipulation d'un
tableau (bis) (déclaration, boucles for, fonctions)
Ecrire un programme qui
1) demande la taille d'un tableau d'entiers à l'utilisateur;
2) le remplit d'entiers tirés au hasard entre 1 et 100
(Utilitaire.tirerUnEntier), tout en construisant une chaine de
caractère de manière à pouvoir afficher le tableau
sous la forme [ 10 14 5 84 56 ] avec Utilitaire.ecrire;
3) calcule (et affiche) la moyenne des éléments
stockés dans le tableau ainsi que les plus petits et plus grands
éléments.
On écrira une fonction pour chacune de ces opérations.
Les prototypes seront:
public static double moyenne(double[] tableau)
public static double elementmini(double[] tableau)
public static double elementmaxi(double[] tableau)
Exercice 2 - suite de Syracuse
(écriture d'une fonction)
On définit par récurrence la suite d'entiers (u_n) par:
u_0 est un entier naturel non nul;
pour tout entier n, si u_n est pair alors u_{n+1} = u_n / 2
et si u_n est impair alors u_{n+1} = 3.u_n + 1.
On conjecture que pour toute valeur de u_0, la suite (u_n) finit par
devenir périodique et prend pour valeurs successives 4, 2, 1.
Ecrire un programme qui demande à l'utilisateur un entier non
nul, et, au sein d'une boucle while (de manière à
s'arrêter lorsque l'on arrive à 1), appelle une fonction
qui calcule les termes successifs de la suite.
Etant donnés deux réels positifs u_0 et v_0, on
définit par récurrence les deux suite (u_n) et (v_n) par
u_{n+1} = sqrt(u_n . v_n) et v_{n+1} = (u_n + v_n) / 2.
Ecrire un programme qui demande à l'utilisateur deux doubles u_0
et v_0 et stocke dans deux tableaux les 10 premières valeurs de
(u_n) et (v_n).
La racine carrée s'obtient par la méthode Math.sqrt().
Exercice 4 - tri à bulle
(fonctions, tableaux...)
On se donne un tableau de doubles, initialisé à (par
exemple):
double tab[] = {5.5, 2.0, 3.5, 7.0, 4.4, 3.5, 0.2, 5.4, 0.4, 6.6};
On cherche à trier ce tableau dans l'ordre croissant.
Le principe du tri à bulle est le suivant: on parcourt le
tableau et quand on rencontre deux éléments successifs
tels que tab[i]>tab[i+1] on inverse la position de ces
éléments. Tant qu'on a inversé au moins une paire
d'éléments lors d'un parcours, on recommence.
Ecrire un programme qui trie le tableau tab. Il comportera une fonction
tri_a_bulle qui appellera une fonction permutant deux
éléments du tableau.
Contact:
Frédéric Sur, ATER au département d'informatique.
