Exercices: Les structures d'un programme

Expliquer ce qu'est une variable dans un programme et donner un exemple : quel nom et quel contenu aurait une variable dans un jeu vidéo qui enregistre les points du joueur ? Quelle opération changerait sa valeur au passage d'un niveau ?

Expliquer ce qu'est une structure conditionnelle (si... alors... sinon...) et écrire deux exemples de décisions quotidiennes exprimées avec cette structure, en indiquant la condition et les deux actions possibles.

Expliquer ce qu'est une boucle et quel problème elle résout par rapport à la répétition des mêmes instructions de nombreuses fois. Écrire en pseudo-code une boucle qui affiche les nombres de 1 à 5.

Expliquer la différence entre une variable et une constante dans un programme, avec un exemple de chacune dans un programme de facturation (le prix du produit face au taux de TVA).

Les données d'un programme ont un type : entier, décimal, texte ou booléen. Indiquer le type le plus adapté à chaque donnée et le justifier : l'âge d'une personne, sa taille en mètres, son nom et le fait qu'elle ait réussi ou non.

Expliquer ce qu'est une fonction dans un programme et deux avantages à découper le code en fonctions nommées (réutiliser sans copier, comprendre et tester chaque partie séparément).

Qu'est-ce qu'un commentaire dans le code source ? Expliquer à qui s'adressent les commentaires (non pas à l'ordinateur, mais à celui qui lira le code ensuite) et ce que doit expliquer un bon commentaire (le pourquoi des décisions, pas ce qui se voit déjà).

Lire ce fragment et réaliser la trace :

début

    x ← 4

    x ← x + 2

    afficher x

fin

Indiquer quelle valeur s'affiche à l'écran et expliquer pourquoi la deuxième instruction n'est pas une équation mathématique mais une affectation.

Lire ce programme en pseudo-code :

début

    somme ← 0

    n ← 1

    tant que n ≤ 5 faire

        somme ← somme + n

        n ← n + 1

    fin tant que

    afficher somme

fin

Réaliser la trace pas à pas (valeur de somme et de n à la fin de chaque tour), puis indiquer combien de fois la boucle se répète et quelle valeur est affichée à la fin.

Écrire en pseudo-code un programme qui lit la note d'un examen (un nombre de 0 à 10) et affiche « reçu » si la note est supérieure ou égale à 5, et « non reçu » dans le cas contraire. Utiliser une variable, une lecture de donnée et une structure conditionnelle.

L'algorigramme de la figure représente un programme avec une boucle : il lit un nombre n et, tant que n est supérieur à 0, affiche sa valeur et lui retranche 1, comme le montre la figure.

Si l'utilisateur saisit n = 3 : (a) réaliser la trace en indiquant les valeurs que prend n et ce qui est affiché à chaque tour ; (b) indiquer combien de fois le corps de la boucle est exécuté ; (c) expliquer ce qui se passerait si l'utilisateur saisissait n = 0.

Ce programme classe une personne selon son âge :

début

    lire âge

    si âge ≥ 18 alors

        afficher "majeur"

    sinon

        afficher "mineur"

    fin si

fin

Réaliser la trace pour une entrée de 17 et pour une entrée de 21, en indiquant dans chaque cas quelle condition est évaluée et ce qui s'affiche à l'écran.

Écrire en pseudo-code un programme qui affiche le compte à rebours de 10 à 1 et, à la fin de la boucle, affiche « Décollage ! ». Utiliser une variable et une boucle tant que.

Ce programme additionne les nombres saisis par l'utilisateur jusqu'à ce qu'il saisisse un zéro :

début

    somme ← 0

    lire n

    tant que n ≠ 0 faire

        somme ← somme + n

        lire n

    fin tant que

    afficher somme

fin

Réaliser la trace pour la suite d'entrées 4, 3, 0 : indiquer la valeur de n et de somme après chaque lecture et ce qui est affiché à la fin. Expliquer en outre pourquoi le premier lire n est placé en dehors de la boucle.

L'algorigramme de la figure représente le contrôle d'accès d'un appareil : il y a un maximum de trois essais pour saisir le bon code, comme le montre la figure.

(a) Expliquer le parcours complet du programme lorsque l'utilisateur se trompe deux fois de code et trouve le bon au troisième essai. (b) Indiquer le nombre maximal de fois où le programme demande le code. (c) Justifier pourquoi la variable essais n'est incrémentée que dans l'une des branches du second losange.

Ce programme devrait afficher les nombres de 1 à 5, mais il comporte une erreur :

début

    n ← 1

    tant que n ≤ 5 faire

        afficher n

    fin tant que

fin

1. a) Identifier l'erreur : que manque-t-il dans le corps de la boucle ?

1. b) Expliquer ce qui se passe lorsqu'on exécute le programme tel qu'il est écrit.

1. c) Écrire le pseudo-code corrigé.

Un camarade affirme que, pour compter combien de nombres entre deux entiers positifs quelconques $A$ et $B$ ($A \le B$) sont divisibles à la fois par $3$ et par $5$, le pseudo-code suivant fonctionne toujours et est le plus efficace :

début

    lire A, B

    total ← 0

    tant que A ≤ B faire

        si (A mod 3 = 0) ou (A mod 5 = 0) alors

            total ← total + 1

        fin si

        A ← A + 1

    fin tant que

    afficher total

fin

(a) Réfuter deux défauts de sa proposition : une erreur de logique conditionnelle par rapport à la spécification demandée et une inefficacité algorithmique (analyser combien d'itérations et d'évaluations de conditions sont effectuées si $B - A = 1\,000\,000$).

(b) Si l'on doit obligatoirement employer une boucle tant que, réécrire l'algorithme en optimisant la valeur initiale et le pas d'incrémentation afin de réaliser le moins d'itérations possible sans évaluer aucune instruction conditionnelle dans la boucle.

(c) Concevoir une solution mathématique en temps constant $O(1)$ sans boucle, en pseudo-code, et justifier formellement la formule employée.

Concevoir en pseudo-code un algorithme pour le jeu du « nombre mystère » où les rôles sont inversés : l'utilisateur pense à un nombre secret entier compris entre $1$ et $100$ et l'ordinateur doit le deviner en employant la stratégie optimale de recherche dichotomique.

(a) Écrire le pseudo-code de l'algorithme. À chaque itération, l'ordinateur proposera le milieu de l'intervalle courant et l'utilisateur répondra si le nombre secret est « plus grand », « plus petit » ou si la machine a « trouvé ».

(b) Intégrer un mécanisme de validation qui détecte si l'utilisateur se contredit ou triche (par exemple si les bornes de l'intervalle de recherche se croisent parce que la borne inférieure dépasse la borne supérieure), en arrêtant le programme avec un message d'alerte justifié.

(c) Justifier formellement quel est le nombre maximal d'essais dont l'ordinateur aura besoin pour deviner n'importe quel nombre de l'intervalle $[1, 100]$ et prévoir combien d'essais au maximum seraient nécessaires si l'intervalle était étendu à $[1, 1\,000]$.

Concevoir en pseudo-code l'algorithme de commande d'un feu de passage piéton à bouton-poussoir qui gère en toute sécurité la circulation d'une avenue avec les exigences suivantes :

1. Au repos, le feu pour les véhicules reste au vert.

2. Pour éviter les embouteillages provoqués par des appels continus, un temps minimal de vert pour les véhicules de $30$ secondes doit être garanti entre deux phases piétons consécutives.

3. Une fois ce temps minimal écoulé et l'appui d'un piéton détecté, la séquence obligatoire est : orange pour les véhicules pendant $3$ secondes, rouge pour les véhicules et vert piéton pendant $15$ secondes, puis vert piéton clignotant pendant $4$ secondes avant de rétablir le vert pour les véhicules.

(a) Écrire le pseudo-code du système, structuré dans une boucle continue de supervision.

(b) Analyser quel blocage subirait le carrefour si le capteur tombait en panne à l'état actif en permanence (bouton coincé) et justifier comment votre conception empêche l'avenue d'être indéfiniment saturée.

(c) Justifier techniquement pourquoi, dans les systèmes de commande concurrents en temps réel, il est préférable de consulter une horodatage de l'horloge (temps_actuel()) plutôt que de suspendre le processeur par des attentes bloquantes passives (attendre()).

Analyser l'algorithme suivant, qui traite des couples d'indices $(i, j)$ :

début

    lire N

    compteur ← 0

    pour i de 1 à N faire

        pour j de i à N faire

            si (i + j) mod 2 = 0 alors

                compteur ← compteur + 1

            fin si

        fin pour

    fin pour

    afficher compteur

fin

(a) Déduire et justifier algébriquement une formule exprimant combien de fois au total la condition si est évaluée en fonction de $N$ (en calculant la somme des itérations de la boucle interne par rapport à la boucle externe).

(b) Prévoir la valeur finale exacte de compteur si l'entrée est $N = 5$, en élaborant un tableau de trace qui montre les valeurs de $i$, $j$, le résultat de la condition et les mises à jour de compteur.

(c) Un élève affirme : « Comme la boucle imbriquée parcourt des couples de nombres, remplacer pour j de i à N par pour j de 1 à N et diviser le résultat final par $2$ produirait exactement le même résultat pour tout $N$ ». Démontrer par un raisonnement formel ou un contre-exemple si cette affirmation est vraie ou fausse.

Un analyste en cybersécurité examine le pseudo-code suivant, conçu pour contrôler l'accès par carte et code PIN sur un terminal bancaire :

début

    pin_secret ← 3852

    essais ← 0

    bloquée ← faux

    tant que essais < 3 et non bloquée faire

        lire pin_saisi

        si pin_saisi = pin_secret alors

            afficher "Bienvenue dans le système"

        sinon

            essais ← essais + 1

            afficher "Code PIN incorrect"

        fin si

    fin tant que

    si essais = 3 alors

        bloquée ← vrai

        afficher "Carte bloquée par sécurité"

    fin si

fin

(a) Identifier et justifier une erreur grave de contrôle de flux qui se produit lorsque l'utilisateur saisit le bon code PIN dès le premier essai.

(b) Prévoir le comportement du programme et la valeur finale des variables essais et bloquée si l'utilisateur saisit la suite d'entrées : 1111, 3852, 9999.

(c) Réécrire l'algorithme en pseudo-code en corrigeant le flux d'exécution afin de garantir une sortie propre immédiate après la réussite et un blocage strict après trois échecs consécutifs, en s'assurant qu'en aucun cas le message de bienvenue ne s'affiche si la carte est bloquée.

Dans la conception d'une installation hydraulique, on utilise des manchons cylindriques en fonte nodulaire de section annulaire (couronne circulaire) de masse volumique $\rho = 7{,}2\text{ g/cm}^3$.

(a) Concevoir en pseudo-code une fonction aire_anneau(rayon_int, rayon_ext) qui calcule et renvoie l'aire de la couronne circulaire ($\pi \cdot (r_{ext}^2 - r_{int}^2)$). La fonction doit valider que $rayon\_ext > rayon\_int > 0$ ; si les paramètres ne respectent pas cette condition physique, elle doit renvoyer $-1{,}0$ comme code d'erreur. Considérer $\pi \approx 3{,}1416$.

(b) Concevoir une seconde fonction masse_tube(rayon_int, rayon_ext, longueur, masse_volumique) qui appelle aire_anneau pour calculer le volume et la masse totale du tronçon en kilogrammes (en considérant que les dimensions sont saisies en centimètres et la masse volumique en $\text{g/cm}^3$). Si aire_anneau renvoie une erreur ou si la longueur est inférieure ou égale à zéro, la fonction doit propager la valeur $-1{,}0$.

(c) Réaliser la trace complète de l'exécution de masse_tube(4{,}0, 5{,}0, 100{,}0, 7{,}2), en indiquant les valeurs qui entrent et sortent de chaque fonction et en justifiant le résultat numérique obtenu.

La commission d'assurance qualité d'un établissement évalue l'algorithme suivant, destiné à déterminer la note finale d'un module technique à partir de trois notes partielles ($N_1, N_2, N_3 \in [0{,}0; 10{,}0]$). Le règlement officiel établit : « L'élève est “Reçu” si la moyenne pondérée ($30\,\%$ pour $N_1$, $30\,\%$ pour $N_2$ et $40\,\%$ pour $N_3$) est supérieure ou égale à $5{,}0$, à condition qu'aucune des notes individuelles ne soit inférieure à $4{,}0$ ; dans le cas contraire, il sera “Non reçu” ».

début

    lire N1, N2, N3

    moyenne ← N1 · 0,3 + N2 · 0,3 + N3 · 0,4

    si moyenne ≥ 5,0 ou (N1 ≥ 4,0 et N2 ≥ 4,0 et N3 ≥ 4,0) alors

        afficher "Reçu"

    sinon

        afficher "Non reçu"

    fin si

fin

(a) Expliquer en détail pourquoi le programme ne génère aucune erreur de syntaxe et s'exécute normalement alors qu'il contient une erreur logique critique dans la structure conditionnelle.

(b) Concevoir deux triplets de notes de test $(N_1, N_2, N_3)$ qui mettent en évidence l'erreur de l'algorithme : un qui provoque un faux positif (le programme déclare « Reçu » alors que ce devrait être « Non reçu ») et un autre qui provoque un faux négatif (ou justifier si ce dernier est possible avec l'expression actuelle).

(c) Réécrire l'algorithme en pseudo-code en corrigeant la condition logique et en ajoutant une vérification préalable que les trois notes saisies se situent dans l'intervalle valide $[0{,}0; 10{,}0]$.

Un programmeur débutant a implémenté le jeu du « nombre mystère » à l'aide d'une unique fonction qui accède directement à des variables globales :

variables globales : secret, essais

fonction jouer_manche()

    afficher "Saisir un nombre (1-100) : "

    lire essai

    essais ← essais + 1

    si essai = secret alors

        afficher "Gagné en ", essais, " essais !"

    sinon

        si essai < secret alors

            afficher "Le nombre secret est plus grand"

        sinon

            afficher "Le nombre secret est plus petit"

        fin si

    fin si

fin fonction

(a) Justifier trois inconvénients de cette conception en s'appuyant sur les notions de couplage, d'effets de bord et de manque de cohésion. Pourquoi mélanger les entrées/sorties de la console avec la logique de comparaison empêche-t-il de réutiliser cette fonction dans une interface graphique ou une application web ?

(b) Redéfinir l'architecture modulaire en créant trois fonctions à faible couplage : une fonction pure de comparaison (qui reçoit l'essai et le secret et renvoie un indicateur de résultat), une fonction de validation de la saisie (qui vérifie l'intervalle $[1 ; 100]$) et une fonction de mise à jour de l'état. Préciser pour chacune sa signature exacte (nom, paramètres avec leur type et type de retour) et ses responsabilités.

(c) Écrire en pseudo-code le programme principal qui coordonne ces fonctions par passage de paramètres et valeurs de retour, sans utiliser aucune variable globale.