Editions ENI Livres | Vidéos | e-Formations
Corrigé 1
Prérequis
|
1. |
a. et c. Une variable est un emplacement mémoire contenant une valeur dont l’accès se fait par le nom de la variable. |
|
2. |
La valeur d’une variable est modifiée pendant l’exécution du programme par une instruction d’affectation. |
|
3. |
a. Le type d’une variable définit l’ensemble des valeurs que peut prendre une variable. Par exemple, une variable de type short indique que ses valeurs sont des entiers compris entre -32 768 et 32 767. |
|
4. |
La valeur d’une variable peut changer lors de l’exécution d’un programme. Ce n’est pas le cas pour une constante. |
|
5. |
Une constante est utilisée pour associer un nom à une valeur qui ne varie pas au cours de l’exécution d’un programme. L’avantage d’une constante est qu’il est possible de modifier sa valeur à un seul endroit dans le code source. Pour que ce changement soit pris en compte, il est cependant nécessaire de recompiler. |
|
6. |
a., b., d., f. Les opérateurs, les parenthèses, les variables, les constantes mais aussi les appels de fonction ou les transtypages sont des éléments pouvant figurer dans une expression. |
|
7. |
Une affectation sert à modifier le contenu d’une variable en lui donnant une nouvelle valeur. |
|
8. |
Il s’agit des opérateurs qui sont compatibles avec son type. Si la variable... |
Corrigé 1.1 : Affichage de 4/3
Le premier programme en Java qui vient à l’esprit se trouve à la suite. Cependant, il ne convient pas pour afficher la valeur de 4/3 en tant que nombre réel.
public class QuatreTiers {
public static void main(String[] args) {
System.out.println("Affichage de quatre tiers");
System.out.println(4/3);
}
} En effet, la valeur affichée est un. La division est réalisée sur deux nombres entiers et calcule le quotient entier qui vaut un. En effet, 4/3 est égal à 1.3333, qui a pour valeur entière un.
Pour obtenir le résultat comme un nombre réel, il faut utiliser l’une des deux solutions présentées dans le programme ci-dessous.
public class QuatreTiers {
public static void main(String[] args) {
System.out.println("Affichage de quatre tiers");
System.out.println((float)4/3);
System.out.println(4.0/3);
}
} Il faut noter que la première solution renvoie un nombre réel de simple précision (type float) à la suite du transtypage. La seconde renvoie un nombre réel de double précision...
Corrigé 1.2 : Conversion de degrés en radians et vice versa
Le programme Java de conversion de degrés en radians est illustré à la suite. Il consiste à déclarer la variable angle, à inviter l’utilisateur à saisir l’angle en degrés, à lire le contenu de la variable angle au clavier, puis à afficher le résultat en le calculant dans le println.
import java.util.Scanner;
public class ConversionDegreRadian {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
double angle;
System.out.print("Entrez la valeur de l'angle en degrés : ");
angle = reader.nextDouble();
System.out.println("La valeur de l'angle en radians
est : " + angle/180*Math.PI);
}
} Le programme Java de conversion de radians en degrés ressemble au précédent, hormis la conversion.
import java.util.Scanner;
public class ConversionRadianDegre {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
double angle;
System.out.print("Entrez...Corrigé 1.3 : Calcul de la moyenne de quatre nombres entiers
Le programme Java de calcul de la moyenne utilise quatre variables de type entier pour stocker la valeur des nombres lus et une variable de type double pour stocker le résultat. Dans ce programme, la division sur les nombres réels est effectivement utilisée car le diviseur (4) est écrit sous la forme d’un nombre réel.
import java.util.Scanner;
public class MoyenneQuatre {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
int n1,n2,n3,n4;
double moyenne;
System.out.print("Entrez la valeur du premier nombre : ");
n1 = reader.nextInt();
System.out.print("Entrez la valeur du deuxième nombre : ");
n2 = reader.nextInt();
System.out.print("Entrez la valeur du troisième nombre : ");
n3 = reader.nextInt();
System.out.print("Entrez la valeur du quatrième nombre : ");
n4 = reader.nextInt();
// calcul de la moyenne
...Corrigé 1.4 : Somme des n premiers nombres entiers pairs
Le calcul de la somme s’effectue grâce à une boucle Pour pour laquelle il convient de spécifier la valeur initiale à 2, de la terminer à 2*n et de fixer le pas à 2.
Dans cette boucle, la valeur de i est ajoutée à la somme.
PROGRAMME SommeNombresPairs
VAR
n, i, somme : entier
DÉBUT
Lire n
somme <- 0
Pour i De 2 à 2*n Pas 2 Faire
somme <- somme + i
FinPour
Écrire somme
FIN Il est à noter aussi qu’il ne faut pas oublier d’initialiser la somme à 0. Le programme correspondant en Java se présente ainsi :
import java.util.Scanner;
public class SommeNombresPairs {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
int n,i;
long somme;
System.out.print("Donnez la valeur de n : ");
n = reader.nextInt();
// calcul de la somme ...Corrigé 1.5 : Livret d’épargne
L’algorithme utilise une boucle Pour, basée sur le nombre d’années, pour calculer le montant épargné après chaque année et l’afficher.
PROGRAMME LivretÉpargne
VAR
montantInitial, intérêt, montantÉpargné : réel
nombreAnnées, i : entier
DÉBUT
Lire montantInitial
Lire intérêt
Lire nombreAnnées
montantÉpargné <- montantInitial
Pour i De 1 à nombreAnnées Faire
montantÉpargné <- montantÉpargné * (l + intérêt / 100)
Écrire montantÉpargné
FinPour
FIN Un point important est l’initialisation avant le début de la boucle de la variable montantÉpargné.
Le programme correspondant en Java se présente ainsi :
import java.util.Scanner;
public class LivretEpargne {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
double montantInitial, interet, montantEpargne; ...Corrigé 1.6 : Année bissextile
La première version de l’algorithme utilise des tests imbriqués. Le premier test vérifie si l’année est divisible par 400, auquel cas elle est forcément bissextile. Dans le cas contraire, le test se fait ensuite sur la division par 100. Si l’année est divisible par 100 (et donc ici pas par 400), elle n’est pas bissextile. Enfin, dans le dernier cas, l’année n’est divisible ni par 400 ni par 100, le test peut simplement se faire sur la division par 4.
PROGRAMME AnnéeBissextile
VAR
année : entier
DÉBUT
Lire année
Si année % 400 = 0 Alors
Écrire "l'année est bissextile"
Sinon
Si année % 100 = 0 Alors
Écrire "l'année n'est pas bissextile"
Sinon
Si année % 4 = 0 Alors
Écrire "l'année est bissextile"
Sinon
Écrire "l'année n'est pas bissextile" ...Corrigé 1.7 : Calcul de l’impôt sur le bénéfice des sociétés luxembourgeoises
Nous étudions d’abord la première version, celle basée sur des imbrications de tests afin de déterminer la tranche d’imposition du bénéfice. Pour chacune de ces tranches, l’impôt sur les tranches inférieures est ajouté au calcul du pourcentage sur le montant du bénéfice restant à imposer.
PROGRAMME ImpôtBénéfice
VAR
impôt : réel
bénéfice : entier
DÉBUT
Lire bénéfice
Si bénéfice <= 10000 Alors
impôt <- 0.2 * bénéfice
Sinon
Si bénéfice < 15000 Alors
impôt <- 0.2*10000 + 0.26 * (bénéfice - 10000)
Sinon
impôt <- 0.2*10000 + 0.26*5000 +
0.22 * (bénéfice-15000)
FinSi
FinSi
Écrire impôt
FIN Ainsi pour la dernière tranche, l’impôt est égal à 20 % de 10 000, 26 % de 5 000 et 22 % de la partie du bénéfice supérieure à 15 000 €. Dans la version donnée ci-dessus, aucune optimisation n’a été effectuée pour obtenir un résultat lisible. Une version plus optimisée est donnée ci-dessous.
PROGRAMME ImpôtBénéfice2
VAR
impôt : réel
bénéfice...Corrigé 1.8 : Produit des n premiers nombres entiers impairs
Le calcul du produit des n premiers nombres impairs avec une boucle Tant Que est réalisé en faisant varier une variable i de 3 à 2*n-1. Il est suffisant de démarrer à 3 (1 étant neutre pour la multiplication). Quant à 2*n-1, il s’agit bien du énième nombre impair (le premier est 1).
PROGRAMME ProduitNombresImpairsTantQue
VAR
n, i, produit : entier
DÉBUT
Lire n
produit <- 1
i <- 3
Tant Que i <= 2 * n - 1 Faire
produit <- produit * i
i <- i + 2
FinTantQue
Écrire produit
FIN L’utilisation d’une boucle Répéter impose de passer au moins une fois dans le corps de la boucle. Il faut donc commencer la valeur de i à 1 (sinon il y aurait au moins une multiplication par 3 qui donnerait un résultat faux dans le cas où n vaut 1). Ici, la programmation avec la boucle Répéter est donc un tout petit peu moins efficace.
PROGRAMME ProduitNombresImpairsRépéter
VAR
n, i, produit : entier
DÉBUT
Lire n
produit <- 1
i...Corrigé 1.9 : Calcul de la moyenne de n nombres entiers
Le premier algorithme lit la valeur de n puis celle des n valeurs. Cette saisie est réalisée par une boucle Pour dans laquelle la somme totale des valeurs est également calculée. Le calcul de la moyenne se fait ensuite simplement en divisant la somme par n.
PROGRAMME MoyenneNombresl
VAR
n, i, somme, valeur : entier
moyenne : réel
DÉBUT
Lire n
somme <- 0
Pour i De 1 à n Faire
Lire valeur
somme <- somme + valeur
FinPour
Écrire somme / n
FIN Dans la seconde version, l’utilisateur doit saisir 0 pour terminer l’introduction des valeurs. La boucle Répéter Jusqu’à demande une valeur et l’ajoute à la somme (l’addition se fait aussi avec le 0). La division se fait par n-1, n étant égal au nombre de valeurs y compris le 0 final.
PROGRAMME MoyenneNombres2
VAR
n, somme, valeur : entier
moyenne : réel
DÉBUT
somme <- 0
n <- 0
Répéter
n <- n + 1
Lire valeur
...Corrigé 1.10 : Suite de Fibonacci
L’algorithme de calcul du énième terme de la suite de Fibonnaci est basé sur une boucle qui calcule tous les termes de la suite de 3 à n. Les variables terme et termePrécédent sont utilisées à chaque itération de la boucle pour calculer le nouveau terme. termePrécédent est affecté à la valeur de terme.
PROGRAMME Fibonacci
VAR
somme, terme, termePrécédent, n, i : entier
DÉBUT
Répéter
Lire n
Jusqu'à n >= l
Selon que :
n=l : Écrire "Le résultat vaut 1"
n=2 : Écrire "Le résultat vaut 1"
sinon :
DÉBUT
termePrécédent <- 1
terme <- 1
Pour i De 3 à n Faire
somme <- terme + termePrécédent
termePrécédent <- terme
terme <-...Corrigé 1.11 : L’utilisateur devine un nombre pair
Comme indiqué dans l’énoncé, la description de la génération du nombre aléatoire n’est pas détaillée dans l’algorithme. Cette génération est indiquée par l’appel de la fonction nombrePairAléatoire.
La suite est basée sur une boucle Répéter qui s’arrête quand l’utilisateur a trouvé le nombre. Cette boucle est appropriée car l’utilisateur doit au moins faire une tentative. Deux tests permettent d’indiquer à l’utilisateur s’il a saisi un nombre trop grand ou trop petit.
PROGRAMME UtilisateurDevine
VAR
nombre, nombreLu, nbrTentatives : entier
DÉBUT
nombre <- nombrePairAléatoire(0, 100)
nbrTentatives <- 0
Répéter
nbrTentatives nbrTentatives + 1
Lire nombreLu
Si nombreLu > nombre Alors
Écrire "trop grand"
Sinon Si nombreLu < nombre Alors
Écrire "trop petit"
Jusqu'à nombre = nombreLu ...Corrigé 1.12 : L’ordinateur devine un nombre pair
Dans cet exercice, l’ordinateur doit essayer de trouver un nombre pair compris entre 0 (borne inférieure) et 100 (borne supérieure). Pour réaliser cette tâche, il va proposer un nombre pair situé au milieu de cet intervalle. Si le nombre de l’utilisateur est plus grand, alors il va continuer avec un nouvel intervalle dont la borne supérieure est inchangée et dont la borne inférieure est égale au nombre proposé plus deux (qui est le premier nouveau nombre possible).
Si le nombre de l’utilisateur est plus petit, alors il va continuer avec un nouvel intervalle dont la borne inférieure est inchangée et dont la borne supérieure est égale au nombre proposé moins deux.
Pour calculer un nombre pair situé au milieu de l’intervalle, la somme des deux bornes est divisée par 4. Le résultat de cette division fournit un nombre entier qui est ensuite multiplié par 2, ce qui garantit d’obtenir un nombre pair. Si nous avions simplement divisé par 2, l’algorithme aurait aussi proposé des nombres impairs.
L’algorithme présenté utilise une boucle Répéter. En effet, étant donné que l’ordinateur fait au moins une proposition, celle-ci est donc la boucle la plus appropriée.
PROGRAMME OrdinateurDevine...Corrigé 1.13 : Calcul du PGCD de deux nombres entiers positifs
L’algorithme de calcul du PGCD est indiqué ci-dessous.
Il est basé sur le calcul du reste de la division euclidienne de a par b. Tant que ce reste n’est pas nul, la valeur de b est affectée à a et le reste est affecté à b. Ainsi le calcul du reste correspond toujours au reste de la division entière de an-2 par an-1.
La valeur de b correspond à la valeur de an-1. Ainsi, cette variable est affichée car elle contient le PGCD des deux nombres lus au clavier.
PROGRAMME CalculPGCD
VAR
a, b, reste : entier
DÉBUT
Lire a
Lire b
reste <- a % b
Tant Que reste != 0 Faire
a <- b
b <- reste
reste <- a % b
FinTantQue
Écrire b
FIN La traduction de l’algorithme en Java est indiquée ci-dessous.
import java.util.Scanner;
public class CalculPGCD {
public static void main(String[] args) {
int a, b, reste;
Scanner reader = new Scanner(System.in);
System.out.print("Entrez le premier nombre entier strictement positif...
