Département d’informatique et d’ingénierie

INF1563 Programmation I Automne 2022

Fiche d’exercices 5 - Fonctions

Les exercices proposés dans cette fiche portent sur les fonctions et les tests. Ils font aussi usage de
contrôle de flux simple. Un corrigé sera fourni séparément.
Exercice 1 : Appels de fonctions
On travaille sur une classe Ex1, dont le code est en partie donné ci-dessous:

public class Ex1 {

public static int trois(){

return 3;
}

public static int triple(int x){

return 3 * x;
}

public static boolean sup(int x, int y){

if (x > y)
return true;
else
return false;
}

public static void main(String[] a) {

// … du code ici …
}

Les questions suivantes portent sur du code qui serait à l’intérieur de la méthode main.
1.1 – Pour les différents fragments de code suivants, indiquer s’ils causeraient une erreur ou non
Code Erreur
oui non
int x = 0;
x = trois();
int i = 0, j = 2;
i = sup(j, 4);
int i = 0, j = 2;

page 1/5
 boolean z = (i==j)
boolean b = sup(i, j);
if (z || b){
System.out.println(i);
}
int i = trois();
int j = triple(i);
int i = triple()
int j = trois(i);

1.2 – Pour les différents fragments de code suivants, indiquer ce qui s’affiche à l’écran s’ils sont
exécutés.
Note : le code est correct.
Code Texte affiché à l’écran
int x = triple(2);
System.out.println("x =" + x);
int z = trois();
int y = trois();
if ( sup(y, z) == true )
System.out.println("oui");
else
System.out.println("non");
boolean b = sup(3, 1);
boolean c = sup(1, 3);
if (b && c)
System.out.println("oui");
else
System.out.println("non");
for (int i = 0; i<=3; i++){
System.out.println(triple(i));
}
int i = 10;
while( sup(i, 4) ){
i = i-1;
}
System.out.println(i);
int i = triple(2);
if sup(triple(i), 7){
System.out.println("oui");
} else {
System.out.println("non");
}

page 2/5
Exercice 2: Opposé et valeur absolue
2.1 – Écrire une fonction opposé qui prend en entrée une valeur de type double et re-
tourne son opposé (exemple : si on lui passe 2.0 elle retourne -2.0).
2.2 – Écrire une fonction v_absolue qui prend en entrée une valeur de type double et
retourne sa valeur absolue. La fonction v_absolue doit appeler la fonction opposé.

Exercice 3: Maximum
On veut une fonction qui renvoie le maximum parmi trois valeurs. Par exemple, si on lui
passe en entrée 5, 2, et 8 elle doit retourner 8.
On a écrit trois fonctions possibles pour faire cela. Pour chacune des fonctions, indiquer si
elle fonctionne correctement, et si non, donner un exemple de valeurs a, b, c pour lesquelles
la fonction ne renvoie pas le maximum des trois (et indiquer ce qu’elle renvoie).

public static int max3(int a, int b, int c){

if (a>b)
return a;
else if (b>c)
return b;
else
return c;
}

public static int max3(int a, int b, int c){

if (a>b)
if (a>c)
return a;
else
return c;
else
if (b>c)
return b;
else
return c;
}

public static int max3(int a, int b, int c){

if (a>b && b>c)
return a;
else if (b>a && a>c)
return b;
else
return c;
}

page 3/5
Exercice 4
Les spécifications ci-dessous définissent des fonctions. Pour chacune des spécifications, faire :
1. Écrire l’en-tête de la fonction avec les types appropriés pour les paramètres et le retour;
2. Écrire le corps de la fonction pour que la fonction réalise la fonctionnalité demandée;
3. Écrire deux cas de test JUnit pour vérifier que la fonction est correcte
4.1 – La fonction hypotenuse calcule la longueur de l’hypoténuse d’un triangle rectangle, à
partir des longueurs des deux autres cotés l et L.

Rappel : h2 =12 +L2 . Les trois longueurs seront exprimées par des variables de type double.
Pour calculer une racine carrée, on utilisera la fonction de bibliothèque Math.sqrt().
4.2 – La fonction commenceParA prend en entrée un mot (de type String) et renvoie true si le
mot commence par la lettre A (majuscule ou minuscule), sinon elle renvoie false.
Indication : utiliser la méthode charAt() de la classe String. Exemple d’utilisation :
String s = "hello";
char c = s.charAt(0); // on aura c == 'h'

4.3 – La fonction celsius convertit en degrés Celsius une température donnée en degrés Fa-
hrenheit. Les valeurs manipulées ne seront pas toujours entières.
Note : La formule de conversion est : on prend la température en Fahrenheit, on enlève 32, et on
multiplie par 5/9. (Attention à la division entière!)

Exercice 5 : comptage
5.1 – Écrire une méthode sommeEntre qui prend deux entiers n1 et n2 (n1 < n2) et calcule la
somme des entiers de cet intervalle. Utiliser une boucle for.
Exemple : sommeEntre(3, 7) doit retourner 25, parce que 3 + 4 + 5 + 6 + 7 = 25.
5.2 – Écrire une méthode sommeJusquA qui prend un seul entier n en paramètre et calcule la
somme des entiers entre 0 et n. Utiliser un appel de la méthode sommeEntre pour faire le calcul.

Exercice 6 : diviseurs
6.1 – Écrire une méthode boolean divise(int i, int j)qui retourne true si i divise
j, sinon false.

6.2 – Écrire une méthode void division(n) qui prend en entrée un entier n et affiche un
tableau de taille n × n à deux entrées dont la case (i, j) est cochée lorsque i divise j ou j divise i. La
méthode division doit appeler la méthode divise.
Note : la première ligne et la première colonne correspondent au nombre 1.

Exemple : division(6) doit afficher le tableau suivant :

page 4/5
x x x x x x
x x x x
x x x
x x x
x x
x x x x

Exercice 7 : Méthode de Héron

Cet exercice porte sur l’approximation d’une racine carrée par la méthode de Héron d’Alexandrie.

L’idée est de calculer une suite de nombres qui sont de plus en plus proches de la valeur de la
racine carrée cherchée.

Supposons qu’on veuille calculer la racine carrée d’un nombre n.

On peut commencer à approximer √𝑛 par une valeur quelconque, inférieure à n : soit r1 cette
première approximation de √𝑛.
On peut dessiner un rectangle dont un côté est le longueur r1 et dont l’aire vaut n. Comme l’aire
!
est le produit de la longueur et de la largeur, l’autre dimension (longueur ou largeur) vaut alors .
"#

𝑟1
.

𝑛
𝑟1
.
!
Si r1 est inférieur à √𝑛, alors "# est forcément supérieur à √𝑛, et plus l’approximation est bonne,
plus le rectangle se rapproche d’un carré (de côté √𝑛).
!
Pour se rapprocher de la racine, on doit donc choisir un nombre entre r1 et "#
: par exemple, la
!
("#% "#)
moyenne de ces deux nombres. On prendra donc r2 = . De la même façon, on pourra
(
!
("(% "$)
encore améliorer cette approximation en choisissant une nouvelle valeur r3 = (
. La suite des
nombres r1, r2, r3,… converge vers √𝑛 (mais n’atteint jamais exactement cette valeur). Pour
!
décider quand s’arrêter, on peut évaluer la différence 𝑟𝑖 − "), qui se rapproche de zéro au fur et à
mesure que ces deux nombres se rapprochent tous deux de √𝑛.
!
On peut donc choisir un niveau de précision e, et s’arrêter quand la différence entre ri et ") est
inférieure à e (en valeur absolue).
7.1 – Écrire une méthode double rplus(double r, double n) qui calcule une
approximation r(i+1) en fonction d’une approximation ri
7.2 – Écrire une méthode double racineHeron(double n, double epsilon) qui
calcule la racine carrée d’un nombre n avec la précision epsilon donnée en paramètre : prendre
!
comme première approximation r1 = ( , puis calculer des nouvelles approximations (en utilisant la
méthode rplus) jusqu’à atteindre la précision demandée. Retourner la dernière valeur calculée.

page 5/5