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

INF1563 Programmation I Automne 2021

Exercices de révision

Exercice 1 : Budget (Unité 1)

Votre tante fortunée vous a envoyé une généreuse somme d’argent pour vous aider durant vos études
à l’UQO. De cette somme de départ, vous devez garder les deux tiers pour vos livres et fournitures
(arrondir ou tronquer au dollar près), mettre $10 de côté pour lui envoyer une carte de
remerciements, et vous décidez de diviser le reste équitablement entre les trois catégories de
dépenses suivantes : sorties cinéma ($12), ski ($35) et tickets pour voir jouer le club de hockey
local ($20). Enfin, comme les différents budgets ne tombent pas forcément juste (par exemple, si
votre budget cinéma est de $50 vous pourrez y aller quatre fois, pour $48, et il vous restera $2), il
vous restera un peu d’argent pour vous acheter des cafés et des beignes.
Écrire un programme pour calculer les différents budgets et calculer le nombre de sorties que ce
budget vous permet. Votre programme doit lire au clavier le montant de départ, et calculer les
différents budgets. Il doit ensuite afficher le montant réservé pour les livres et fournitures, pour la
carte, le nombre de sorties cinéma, ski et hockey prévues, et enfin le montant restant pour les cafés.
Exemple d’utilisation :

Entrer le montant donné :

1000
Montant pour livres et fournitures : $666
Carte de remerciements : $10
Nombre de sorties cinéma : 9
Nombre de sorties ski : 3
Nombre de sorties hockey : 5
Budget cafés : $11

Exercice 2 : Moyenne (Unité 2)

On veut écrire un programme pour qu’un professeur puisse facilement calculer la moyenne d’une
liste de notes. Le programme doit permettre à l’utilisateur d’entrée autant de notes qu’il le souhaite :
pour indiquer que la liste est terminée, l’utilisateur entre la valeur -1.
Consignes :
- Le programme ne doit pas stocker toutes les valeurs entrées : pour pouvoir calculer la moyenne,
il suffit de compter les valeurs et faire leur somme au fur et à mesure qu’elles sont entrées.
- Les valeurs entrées doivent être des entiers, et la moyenne affichée doit être exacte.
Exemple d’utilisation :
Entrer une note (-1 pour terminer) :
92
Entrer une note (-1 pour terminer) :
58
Entrer une note (-1 pour terminer) :
page 1/4
63
Entrer une note (-1 pour terminer) :
-1
Moyenne : 71.0

Exercice 3 : fonctions (Unités 1, 3, 5)

On veut écrire un programme qui calcule la différence entre deux horaires donnés au format (heures,
minutes). Par exemple, quelle est la durée qui sépare 13h35 et 18h14 ? (réponse : 4 heures et 39
minutes).
Pour ceci on va écrire une fonction qui convertit un horaire (donné en heures et minutes) en minutes
depuis minuit (question 1) puis utiliser cette fonction dans le programme principal (question 2): on
convertit les deux horaires en minutes depuis minuit, puis on fait la différence, et enfin on recon-
vertit le résultat en heures / minutes.
Enfin, on veut écrire des tests uitaires pour cette fonction, en utilisant la bibliothèque JUnit.
On va donc implémenter deux méthodes statiques minutesDepuisMinuit(…) et main(…)
dans une classe Horaires dont le squelette est donné ci-dessous.

import java.util.Scanner;

public class Horaire{

public static void main(String [] a){

Scanner clavier = new Scanner(System.in);
// à compléter
}

public static ……… minutesDepuisMinuit(…………………){

// à completer
}
}

3.1 – Écrire la fonction minutesDepuisMinuit(…) qui prend en entrée un horaire en heures

et minutes (deux paramètres entiers) et renvoie le nombre de minutes entre minuit (le minuit
précédent) et cet horaire. Le résultat est un nombre entier.
Par exemple, pour l’horaire 10h47, la fonction doit retourner 647. La fonction doit être déclarée
public static.
3.2 – Écrire la fonction main: l’utilisateur entre au clavier les deux horaires (d’abord le nombre
de minutes puis le nombre de secondes), le programme appelle ensuite la méthode
minutesDepuisMinuit pour les convertir en minutes, calcule la différence, et enfin
reconvertit le résultat en heures / minutes et l’affiche à l’écran.
Votre programme doit se conformer à l’exemple d’utilisation ci-dessous.
Entrez l’horaire 1 :
heures:
6
minutes:
17
Entrez l’horaire 2:
heures:
14

page 2/4
minutes:
22
La différence est de 8 heures et 5 minutes.

3.3 – Dans une nouvelle classe, écrire deux tests unitaires pour la fonction
minutesDepuisMinuit(…). On utilisera la fonction générique assert ou une des
fonctions spécifiques assertEquals, assertTrue, assertFalse,
assertNotEquals… de la bibliothèque JUnit : la documentation de ces fonctions est donnée
ci-après.

Documentation des principales fonctions assert… spécifiques de la bibliothèque JUnit:

static void assertEquals(double expected, double actual, double delta)
Asserts that two doubles are equal to within a positive delta.
static void assertEquals(float expected, float actual, float delta)
Asserts that two floats are equal to within a positive delta.
static void assertEquals(long expected, long actual)
Asserts that two longs are equal.
static void assertFalse(boolean condition)
Asserts that a condition is false.
static void assertNotEquals(double unexpected, double actual,
double delta)
Asserts that two doubles are not equal to within a positive delta.
static void assertNotEquals(float unexpected, float actual,
float delta)
Asserts that two floats are not equal to within a positive delta.
static void assertNotEquals(long unexpected, long actual)
Asserts that two longs are not equals.
static void assertTrue(boolean condition)
Asserts that a condition is true.
Remarque: pour comparer des entiers de type int, on peut utiliser la fonction assertEquals
qui prend des long (qui est le type entier 64 bit) : la conversion int -> long ne pose aucun
problème et se fait automatiquement.

Exercice 4 : ADN (Unité 4)

Dans cet exercice on va représenter des fragments d’ADN (le support de l’information génétique)
sous forme de tableaux, et implémenter une méthode qui pourrait être utile en bio-informatique.
L’ADN est le support de l’information génétique pour tous les êtres vi-
vants, et se trouve dans toutes nos cellules sous formes de chromosomes.
L’information génétique est codée par la séquence de nucléotides (des
molécules avec une structure particulière) qui forme l’ADN : il existe seu-
lement quatre nucléotides différents, qu’on note par des lettres :
- Adénine (A)
- Cytosine (C)
- Thymine (T)
- Guanine (G)
L’ADN est formée de deux chaînes de nucléotides qui se font face, comme
illustré par le schéma ci-contre. Les paires de nucléotides qui se font face

page 3/4
sont toujours associées de la même manière : un nucléotide A est toujours associé à un nucléotide
T, et un nucléotide C est toujours associé à un nucléotide G (et vice-versa).
On peut donc représenter un fragment d’ADN par une séquence de symboles A, C, T, et G: par
exemple le brin de gauche dans le schéma est représenté par la séquence AGTCATACCG (de haut
en bas). Comme les nucléotides sont toujours appareillés (associés en paires) de la même façon, on
peut calculer, à partir d’une séquence donnée, la séquence complémentaire, c’est-à-dire la séquence
de nucléotides qui font face à la première séquence. Par exemple, le complément de AGTCA-
TACCG (le brin de gauche) est TCAGTATGGC (le brin de droite).
Dans cet exercice on va représenter des séquences de nucléotides par des tableaux de caractères.
Pour représenter le brin de gauche ci-dessus, on aurait le tableau :
char [] tab = { 'A','G','T','C','A','T','A','C','C','G'}

Écrire une fonction public static boolean sontComplementaires(char[]

tab1, char[] tab2) qui prend en entrée deux séquences de nucléotides et retourne true si
les deux séquences sont complémentaires, sinon false. Plus précisément, la méthode prendra en
entrée deux tableaux de caractères (de longueurs quelconques) et dont chaque élément sera un des
quatre caractères 'A', 'G', 'T', ou 'C'. Pour être complémentaires, les deux tableaux doivent
avoir la même longueur et à chaque position, les nucléotides des deux tableaux doivent se corres-
pondre selon la correspondance A à T, T à A, G à C, C à G.

Exercice 5 : Récursivité (unité 5)

Dans cet exercice on veut écrire une fonction récursive qui écrit une chaîne de caractères à
l’envers (les caractères dans l’ordre inverse). Si par exemple on l’applique au mot « algo-
rithme », la méthode doit afficher « emhtirogla ».
5 – Écrire une fonction récursive public static void alenvers(String s) qui
affiche à l’écran la chaîne s à l’envers (elle ne retourne rien).
Indications :
- Utiliser la méthode vue en cours : identifier le paramètre de complexité et le cas de
base, écrire les fonctions « d’ordre » 1, 2, 3, puis chercher à se ramener au « cas
inférieur ». Enfin, généraliser pour une complexité quelconque.
- Il sera utile de séparer un String en deux : le premier caractère et le reste.
o on peut obtenir le premier caractère en appelant la méthode charAt() (si
s = "hello" alors s.charAt(0) renvoie le caractère 'h').
o on peut obtenir une partie d’un String avec la méthode substring :
s.substring(i) donne s amputée des i premiers caractères : par
exemple, si s = "hello", alors s.substring(1) donne "ello"

page 4/4