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

INF1563 Programmation I Automne 2023

Examen Intra #2
Durée : 3h00
Aucun document autorisé

Nom de l’étudiant(e) : ……………corrigé……………………………………….

Code permanent : ………………………………………………………………………….

Consignes:

1. Le sujet comporte 7 exercices et 12 pages, dont les deux dernières sont les exemples
de code: vérifiez que votre exemplaire est complet.
2. Écrivez vos réponses dans les emplacements prévus. Demandez des feuilles supplé-
mentaires au besoin.
3. L’examen porte sur les 5 premières unités du cours. Chaque unité sera notée sur un
barème à 4 niveaux, comme décrit dans le plan du cours : pour chaque unité, les
objectifs seront notés (N)on atteints, (P)artiellement atteints, (A)tteints ou (D)épas-
sés. Ces notes qualitatives seront converties en points selon le barème indiqué dans
le plan de cours.
4. Les étudiants ayant déjà validé les unités 1 et/ou 2 (note 18 ou 20) peuvent sauter
les exercices portant sur ces unités.
5. Lisez le sujet en entier avant de commencer.
6. Les questions ne seront pas expliquées pendant l’examen.
7. Si vous avez un doute sur comment interpréter une question, faites une hypothèse
raisonnable, et notez quelle est votre hypothèse. Mais relisez bien l’énoncé avant,
et ne faites pas d’hypothèses qui contredisent l’énoncé ou les exemples donnés.
8. Écrivez votre code Java tel qu’il serait sur un ordinateur: en particulier, utilisez *
pour une multiplication, et n’écrivez pas des fractions avec des lignes horizontales.
!"#$
Par exemple, au lieu de ! , vous devez écrire (2*a + b) / 2.
9. Utilisez les feuilles blanches comme brouillon. Des feuilles supplémentaires vous
seront fournies sur demande.

page 1/10
Exercice 1 : Lecture de code et expressions (unité 1)
1.1 – On donne le programme suivant :

Scanner clavier = new Scanner(System.in);

System.out.println("Entrer un nombre entier:");
int n = clavier.nextInt(); // n entré au clavier

int k=0;
if(n>10){
n = n - 10;
k = n;
}
if(n%2==0 || n>10){
k = k + 1;
} else {
k = k + 7;
}
System.out.println("k=" + k); // k affiché ici

a) On exécute ce programme et on entre le nombre 41 au clavier. Quelle sera la valeur de k

affichée à la fin ?

Réponse : _________32_____________________

b) Même question si on entre le nombre 8 au clavier.

Réponse : ________1______________________

1.2 – Dans le programme ci-dessus la condition du deuxième if est : n%2==0 || n>10.

a) Exprimer en Français ce que veut dire cette condition

Réponse :

n est pair ou n est strictement supérieur à 10

b) Écrire en Java une nouvelle expression booléenne qui exprime exactement le contraire
de cette condition. Cette condition ne doit pas contenir de parenthèses.

Réponse : _______n%2 != 0 && n<=10__________________________________

page 2/10
 Exercice 2 : Calculs, affectations (unité 1)
Bob veut acheter une voiture neuve, et regarde les « prix catalogues » des différents modèles. Au
prix catalogue il faudra ajouter les taxes de vente (14.975%) et des frais de $2000. Il peut payer
$15 000 comptant, et pour le restant il prendra un prêt sur un an, au taux d’intérêt (annuel) de 5%.
Il remboursera ce prêt en 12 paiements égaux. Bob voudrait un programme qui calcule le montant
de ses paiements mensuels.
Par exemple, pour un véhicule dont le prix catalogue est de $22000, les taxes seront de
22000 × 0.14975 = 3294.50, et le prix total sera donc : $22000 + $3294.50 + $2000, soit
$27294.50. Comme il paye $15000 comptant, il prend un prêt de $12294.50, et avec les intérêts il
devra payer 5% de plus, soit $12909.23.
!"#$#."&
Les paiements mensuels de Bob seront donc de !" = $1075.76
Écrire un programme qui calcule le montant des paiements mensuels de Bob, à partir du prix
catalogue d’une voiture. On pourra supposer que le prix catalogue du véhicule est toujours
supérieur à $15000, et il n’est pas nécessaire d’afficher deux chiffres après le point décimal.
Exemple d’utilisation du programme:
Entrer le prix catalogue du véhicule :
22000
Les paiements mensuels seront de $1075.76
Code à compléter :
public static void main(String[] args){
Scanner clavier = new Scanner(System.in);
System.out.println("Entrer le prix catalogue du vehicule:");
double prix = clavier.nextDouble();
// à compléter

double prixtotal, pret, versement;

prixtotal = prix *1.14975 + 2000;
pret = prixtotal - 15000;
versement = (pret *1.05)/12;
System.out.printf("Les paiements mensuels seront de $%.2f", versement);

page 3/10
Exercice 3 : Contrôle de flux (unité 2)
Le but de l’exercice est de tracer le programme suivant :
Scanner scan = new Scanner(System.in);
System.out.println("Entrer un nombre");
int n = scan.nextInt(); // lecture du nombre au clavier

int i = 2;
while(n>1) {
if(i==n) {
System.out.print(i); //affichage
break;
} else if(n%i == 0) {
System.out.print(i + " x "); //affichage
n = n/i;
} else {
i = i+1;
}
}

En supposant que l’utilisateur entre le nombre 50 au clavier, écrire dans le cadre ci-dessous tout le
texte qui s’affichera à l’écran durant l’exécution du programme.
Attention : remarquer que la fonction utilisée pour l’affichage est print et non println.

2 x 5 x 5

page 4/10
 Exercice 4 : Contrôle de flux (unité 2)
Dans cet exercice on veut écrire un programme qui calcule le produit de deux entiers en utilisant
des additions : par exemple, pour calculer 7 × 4, le programme calcule la somme 7 + 7 + 7 + 7.
Il y aurait aussi la possibilité de calculer la somme 4 + 4 + 4 + 4 + 4 + 4 + 4, mais on veut que la
somme soit la plus courte possible.
Compléter le code ci-dessous pour obtenir un programme qui lit deux nombres entiers m et n
au clavier, puis calcule leur produit à l’aide d’additions. Entre les deux sommes possibles
(m+m+…+m ou n+n+…+n), votre programme doit calculer la plus courte des deux.
Exemple d’utilisation :
Entrer deux nombres entiers:
9
6
Résultat : 9 x 6 = 54

Code à compléter:
[importations, déclarations de classe, main…]
Scanner clavier = new Scanner(System.in);
System.out.println("Entrer deux nombres entiers : ");
int m = clavier.nextInt();
int n = clavier.nextInt();
… // à compléter
int grand, petit;
if(m>n){
grand = m;
petit = n;
} else {
grand = n;
petit = m;
}
int resultat =0;
// faire une somme de grand + grand + grand… (petit fois)
for (int i=0; i<petit; i++){
resultat += grand;
}
System.out.println(m + " x " + n + " = " + resultat);

page 5/10
Exercice 5 : Fonctions (unité 3)
Le but de cet exercice est d’écrire et d’utiliser des fonctions dans un programme.
Le programme est écrit pour une boutique en ligne, qui offre des réductions aux abonnés de son
programme de fidélité. Ces abonnés peuvent avoir une carte de fidélité « or » ou une carte « pla-
tine » : les abonnés « or » reçoivent 5% de rabais, et les abonnés « platine » reçoivent 10% de ra-
bais.
On veut un programme qui lit le montant des achats avant taxes, et calcule le prix final pour les
différents programmes de fidélité. Le programme doit appliquer les réductions et ajouter les taxes
de vente (15%).
Exemple d’utilisation:
Entrer le prix des achats avant taxes:
100
Prix final (client ordinaire) : $115
Prix final (abonné "or") : $109.25
Prix final (abonné "platine") : $103.5
Un squelette est donné page suivante pour le programme. Il doit être complété selon les
spécifications suivantes (une solution non conforme aux spécifications ne sera pas acceptée):
prixRabais (erreur d’énoncé)
• La fonction prixFinal doit prendre en entrée 2 paramètres : le prix avant taxes (de type
double ) et le pourcentage de rabais (un entier entre 0 et 100, par exemple : 0 = 0% de
rabais, 5 = 5% de rabais). La fonction doit retourner le prix final calculé comme suit : on
applique le rabais au prix avant taxes, et ensuite on ajoute 15% de taxes de vente au résultat.
'
Indication : pour réduire un prix de x% on multiplie par 1 − !$$, pour l’augmenter on
'
multiplie par 1 + !$$,
• La fonction main lit les données au clavier (code donné) puis utilise la fonction
prixFinal pour calculer les trois prix possibles, avant de les afficher.
prixRabais

Le squelette de code à compléter est donné page suivante.

page 6/10
import java.util.Scanner;

public class Boutique{

public static …double…… prixRabais( …double prix, int rabais…………………){

double apresRabais = prix*(1-rabais/100.0);

double apresTaxe = apresRabais * 1.15;
return apresTaxe;

// désolé d’avoir laisse aussi peu de place ici

}

public static void main(String [] a){

Scanner clavier = new Scanner(System.in);
System.out.println("Entrer le montant des achats: ");
int prixBase = clavier.nextInt();
…//à compléter

double prixZero = prixRabais(prixBase, 0);

double prixOr = prixRabais(prixBase, 5);
double prixPlatine = prixRabais(prixBase, 10);
System.out.println("Prix final (client ordinaire) : $" + prixZero);
System.out.println("Prix final (abonné \"or\") : $" + prixOr);
System.out.println("Prix final (abonné \"platine\") : $" + prixPlatine);

(note : l’affichage des double quotes avec \" n’est pas évalué dans l’exercice, on
évalue l’usage des fonctions.)

page 7/10
 Exercice 6 : Tableaux (unité 4)
Le but est d’écrire une fonction public static int[] insere(int n, int[] tab)qui
permet d’insérer une valeur dans un tableau trié. La fonction est spécifiée comme suit :
- on suppose que tab est un tableau de nombres entiers, triés dans l’ordre décroissant, et peut
contenir des doublons (il n’est pas nécessaire de vérifier que tab est trié correctement).
- La fonction retourne un nouveau tableau qui contient un élément de plus que tab : il contient
toutes les valeurs originales de tab plus le nombre n, et tous ces nombres doivent être dans
l’ordre correct.
Exemple d’utilisation:
int[] tab = {27, 22, 22, 19, 16, 15, 10, 10, 2};
int[] nouveau = insere(20, tab);
// nouveau sera: [27, 22, 22, 20, 19, 16, 15, 10, 10, 2]
Indications: il faut créer un nouveau tableau, y copier tous les éléments de tab plus grands que n
et trouver la position correcte pour n. On place n, et ensuite on peut copier le reste des valeurs, en
les plaçant dans le nouveau tableau avec un décalage d’une position vers la droite. Le plus simple
est de faire deux boucles.
public static int[] insere(int n, int[] tab){
int[] nouveau = new int[tab.length + 1];
int position =0;
for (int i=0;i<tab.length; i++){
if(tab[i]>n){ // valeurs plus grandes que n
nouveau[i] = tab[i]; // on copie dans le nouveau tableau
} else {
// première fois qu’on arrive ici :
// premiere valeur tab[i]<=n, i = position correcte pour n
position = i;
break; // on a trouvé la position, on quitte la boucle tout de suite
} // fin if
} // fin for
// on place n :
nouveau[position] = n;
// on copie les autres valeurs:
for (int i = position; i<tab.length; i++){
nouveau[i+1] = tab[i]; // on copie avec un décalage de 1
}

page 8/10
 Exercice 7 : Récursivité et tests unitaires (unité 5)
Dans cet exercice on veut écrire et tester une fonction récursive qui calcule une « multifactorielle ».
Une « multifactorielle » est une variante de la fonction factorielle : sachant que la factorielle d’un
nombre n, notée n!, est le produit des entiers de 1 à n, la multifactorielle de n d’ordre k (où k<n),
notée n!(k) est le produit des nombres inférieurs à n parcourus par bonds de k. Autrement dit :
𝑛!()) = 𝑛 × (𝑛 − 𝑘) × (𝑛 − 2𝑘) × (𝑛 − 3𝑘) …
où le dernier facteur du produit est compris entre 1 et k inclusivement.
De plus, pour tout nombre positif m<k, m!(k) = m, et pour tout nombre k on a toujours 0!(k) = 1.
Exemples :
• 9!(") = 9 × (9 − 2) × (9 − 4) × (9 − 6) × (9 − 8) = 9 × 7 × 5 × 3 × 1 = 945
• 14!(+) = 14 × 9 × 4 = 504
7.1 – Écrire une fonction récursive multifact qui prend en entrée deux nombres entiers n et k et
retourne la valeur n!(k).
Indication : on pourra s’inspirer de la relation récursive 𝑛! = 𝑛 × (𝑛 − 1)! pour trouver la relation
pertinente pour n!(k).
class Examen {

public static int multifact(int n, int k){

// relation recursive: 𝑛!()) = 𝑛 × (𝑛 − 𝑘)!())

// cas de base:
if(n==0){
return 1;
} else if (n<=k){
return n;
} else {
// cas recursif
return n * multifact(n-k,k);
}
}
}

7.2 – Écrire deux tests unitaires pour tester la fonction multifact. On pourra utiliser assert,
ou bien des fonctions assert…() de la bibliothèque JUnit (documentation page suivante).
Attention : la fonction multifact se trouve dans une classe Examen., et les tests unitaires
seront dans une autre classe TestExamen, dont le squelette est donné page suivante.

page 9/10
// importations pour JUnit
import static org.junit.jupiter.api.Assertions.*;

class TestExamen {
//écrire deux tests ici

@test
void test1{
int res = Examen.multifact(9,2);
assertEquals(945, res);
}

@test
void test2{
int res = Examen.multifact(14,5);
assertEquals(504, res);
}

}
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.

page 10/10