Série N°7 : Tableaux 1D & Sous-programmes

Cochez la bonne réponse pour chacune des 10 questions suivantes :

Analysez les algorithmes et portions de code suivants portant sur les parcours types :

Fonction Moyenne(t : Tab, n : Entier) : Réel
Début
  Retourner Somme(t, n) / n
Fin

from numpy import array

def compter_positifs(t, n):
    c = 0
    for i in range(n):
        if t[i] > 0:
            c = c + 1
    return c

t = array([12, -4, 0, 7, -9, 15])
print(compter_positifs(t, 6))

Une station météorologique automatisée enregistre les températures journalières moyennes (en degrés Celsius, réels) d'une région sur une période de $N$ jours consécutifs ($3 \le N \le 31$).

L'opérateur de la station a besoin d'un programme modulaire pour :

• Saisir et valider le nombre effectif de jours $N$.
• Remplir un tableau de températures $T$ avec des valeurs réalistes comprises entre $-15.0^\circ\text{C}$ et $50.0^\circ\text{C}$.
• Calculer la température moyenne de la période.
• Identifier simultanément en un seul parcours la température la plus basse ($T_{min}$) et la plus haute ($T_{max}$).
• Dénombrer le nombre de jours de gelée ($T[i] \le 0.0^\circ\text{C}$).
• Afficher le rapport détaillé élément par élément et la synthèse statistique.

Le programme doit être décomposé selon les spécifications suivantes :

• Une procédure Saisie_N(@n : Entier) qui contrôle la saisie de $N$ dans l'intervalle $[3, 31]$.
• Une procédure Remplir_Temp(@t : TabReels, n : Entier) qui lit les $N$ réels dans $T$ en exigeant que chaque valeur soit dans $[-15.0, 50.0]$.
• Une fonction Moyenne_Temp(t : TabReels, n : Entier) : Réel qui calcule et retourne la moyenne arithmétique.
• Une procédure Extremes_Temp(t : TabReels, n : Entier, @t_min : Réel, @t_max : Réel) qui détermine $T_{min}$ et $T_{max}$ en un seul parcours de boucle.
• Une fonction Nb_Jours_Gel(t : TabReels, n : Entier) : Entier qui retourne le nombre de journées où $T[i] \le 0.0$.
• Une procédure Afficher_Bilan(t : TabReels, n : Entier) qui affiche le relevé jour par jour (ex: "Jour 1 : 12.5 °C"), puis le compte-rendu final (moyenne, minimum, maximum et jours de gel).

Dans une usine d'usinage mécanique de haute précision, un banc de mesure optique enregistre les diamètres effectifs (en millimètres) d'un lot de $N$ pièces cylindriques ($5 \le N \le 50$).

Le cahier des charges impose un diamètre nominal de référence $D_{ref} = 25.0\text{ mm}$ avec une tolérance admissible $\Delta = 0.2\text{ mm}$. Une pièce est déclarée conforme si son diamètre $d$ vérifie :

Condition de conformité dimensionnelle :

$$|d - D_{ref}| \le \Delta \iff (D_{ref} - \Delta) \le d \le (D_{ref} + \Delta)$$

Toute pièce hors de cet intervalle $[24.8\text{ mm}, 25.2\text{ mm}]$ est classée comme rebut.

Le système informatique doit intégrer les sous-programmes suivants :

• Une procédure Saisie_Taille(@n : Entier) qui garantit $5 \le N \le 50$.
• Une procédure Remplir_Mesures(@t : TabReels, n : Entier) qui lit les $N$ diamètres mesurés (chaque valeur devant être strictement positive).
• Une fonction Est_Conforme(val : Réel, ref : Réel, tol : Réel) : Booléen qui renvoie Vrai si $|val - ref| \le tol$ (en utilisant la fonction standard Abs), et Faux sinon.
• Une procédure Filtrer_Pieces(t : TabReels, n : Entier, ref : Réel, tol : Réel, @nb_ok : Entier, @nb_rebuts : Entier) qui parcourt le tableau et dénombre simultanément les pièces conformes et les rebuts.
• Une fonction Taux_Conformite(nb_ok : Entier, n : Entier) : Réel qui calcule et retourne le pourcentage de pièces conformes : $\frac{nb\_ok}{n} \times 100$.
• Une procédure Afficher_Rapport_Qualite(t : TabReels, n : Entier, ref : Réel, tol : Réel) qui affiche pour chaque pièce son numéro, sa mesure, son statut ([CONFORME] ou [REBUT]), puis le taux global de conformité et une décision finale : "Lot Accepté" si le taux $\ge 80\%$, sinon "Lot Refusé".

Un observatoire géophysique enregistre les amplitudes d'ondes sismiques à l'aide d'un capteur haute fréquence. Le signal discrétisé est stocké dans un tableau $T$ de $N$ entiers strictement positifs ($3 \le N \le 50$).

En traitement de signal, un pic sismique local est défini comme une mesure située à l'indice $i$ ($1 \le i \le N - 2$) strictement supérieure à son voisin immédiat de gauche ET à son voisin immédiat de droite :

Critère de pic sismique local :

$$T[i] > T[i - 1] \quad \text{ET} \quad T[i] > T[i + 1] \quad (\text{pour } 1 \le i \le N - 2)$$

Remarque : Les deux extrémités $T[0]$ et $T[N-1]$ ne possèdent qu'un seul voisin et ne peuvent donc jamais être qualifiées de pics stricts.

On désire implémenter la solution modulaire suivante :

• Une procédure Saisie_N(@n : Entier) pour valider $3 \le N \le 50$.
• Une procédure Remplir_Signal(@t : TabEntiers, n : Entier) qui lit les $N$ amplitudes entières positives.
• Une fonction Est_Pic(t : TabEntiers, i : Entier) : Booléen qui prend le tableau et un indice $i$ ($1 \le i \le N - 2$) et teste si $T[i]$ est un pic local.
• Une fonction Compter_Pics(t : TabEntiers, n : Entier) : Entier qui calcule le nombre total de pics dans le signal.
• Une procédure Extraire_Pics(t : TabEntiers, n : Entier, @pics : TabEntiers, @pos : TabEntiers, @nb_p : Entier) qui construit deux tableaux parallèles :
  • pics : contient les valeurs d'amplitude de chaque pic détecté.
  • pos : contient les indices respectifs $i$ où ces pics apparaissent.
  • @nb_p : retourne le nombre effectif de pics insérés dans ces deux tableaux.
• Une procédure Afficher_Analyse_Sismique(t : TabEntiers, n : Entier) qui affiche le signal complet, puis les résultats de l'extraction (si aucun pic n'est trouvé, afficher "Signal plat : aucun pic sismique détecté.").

Dans un protocole expérimental de chiffrement par transposition, un bloc de données est représenté par un tableau $T$ de $N$ entiers ($4 \le N \le 40$), avec $N$ obligatoirement pair.

Pour rendre les données méconnaissables avant transmission, le vecteur subit une cascade de transformations géométriques sur place (in-place, sans tableau auxiliaire) :

1. Inversion miroir : Échange des éléments symétriques ($T[0] \leftrightarrow T[N-1]$, $T[1] \leftrightarrow T[N-2]$, etc.).
2. Permutation circulaire droite : Chaque élément avance d'une case vers la droite ($T[i] \to T[i+1]$), et le dernier élément revient en première case ($T[N-1] \to T[0]$).
3. Échange des deux moitiés : La première moitié du tableau ($0 \dots \frac{N}{2}-1$) est permutée avec la seconde moitié ($\frac{N}{2} \dots N-1$).

On demande de modulariser la solution comme suit :

• Une procédure Saisie_Taille_Paire(@n : Entier) qui exige que $N \in [4, 40]$ et que $N \text{ Mod } 2 = 0$.
• Une procédure Remplir_Vecteur(@t : Tab, n : Entier) pour saisir les $N$ valeurs.
• Une procédure élémentaire Permuter_Cases(@t : Tab, i : Entier, j : Entier) qui échange les valeurs de $T[i]$ et $T[j]$.
• Une procédure Inverser_Miroir(@t : Tab, n : Entier) qui inverse le tableau sur place en effectuant une boucle Pour i de 0 à (n Div 2) - 1 et en appelant Permuter_Cases(t, i, n - 1 - i).
• Une procédure Rotation_Droite(@t : Tab, n : Entier) qui sauvegarde le dernier élément $T[N-1]$ dans une variable temporaire, décale tous les éléments vers la droite de $N-2$ à $0$, puis place la sauvegarde en $T[0]$.
• Une procédure Echanger_Moities(@t : Tab, n : Entier) qui échange chaque case $i$ ($0 \le i < \frac{N}{2}$) avec la case $i + \frac{N}{2}$ correspondante.
• Une procédure Afficher_Vecteur(t : Tab, n : Entier, titre : Chaîne) qui affiche le titre et le contenu du tableau sur une seule ligne.

Dans une plateforme d'analyse génomique, un fragment de brin d'acide désoxyribonucléique (ADN) est représenté par un tableau de caractères $ADN$ de taille $N$ ($5 \le N \le 60$).

Chaque cellule du tableau représente un nucléotide élémentaire et doit impérativement être l'une des 4 bases azotées :

'A' : Adénine 'C' : Cytosine 'G' : Guanine 'T' : Thymine

Avant de stocker ou d'aligner le brin, le système doit calculer la composition nucléotidique, évaluer le ratio de stabilité thermique ($GC\%$), et générer une séquence compactée éliminant les nucléotides répétés consécutivement (ex: ['A','A','C','G','G','G','T'] $\to$ ['A','C','G','T']).

La conception impose les modules suivants :

• Une procédure Saisie_Taille(@n : Entier) avec validation $5 \le N \le 60$.
• Une fonction Est_Nucleotide(c : Caractère) : Booléen qui renvoie Vrai si $c \in \{'A', 'C', 'G', 'T'\}$ et Faux sinon.
• Une procédure Remplir_ADN(@adn : TabCar, n : Entier) qui saisit chaque case avec une boucle Répéter ... Jusqu'à Est_Nucleotide(adn[i]) pour refuser toute saisie invalide.
• Une procédure Compter_Bases(adn : TabCar, n : Entier, @nb_a : Entier, @nb_c : Entier, @nb_g : Entier, @nb_t : Entier) qui comptabilise les 4 fréquences en un unique parcours.
• Une fonction Taux_GC(nb_c : Entier, nb_g : Entier, n : Entier) : Réel qui retourne le pourcentage de bases G et C : $\frac{nb\_c + nb\_g}{n} \times 100$.
• Une procédure Compacter_Sequence(adn : TabCar, n : Entier, @compact : TabCar, @nb_comp : Entier) qui construit le tableau compact ne contenant aucun doublon consécutif et calcule sa taille effective nb_comp.
• Une procédure Afficher_Sequence(t : TabCar, n : Entier, libelle : Chaîne) qui affiche les nucléotides accolés ou séparés par des tirets.

Une plateforme internationale de diffusion vidéo en streaming héberge deux clusters de serveurs régionaux $S_1$ et $S_2$. Chaque serveur enregistre les identifiants numériques ($ID$) des abonnés actuellement connectés.

Chaque serveur maintient sa liste d'abonnés classée par ordre strictement croissant :

• Serveur 1 : Tableau $T_1$ de taille $N_1$ ($2 \le N_1 \le 30$).
• Serveur 2 : Tableau $T_2$ de taille $N_2$ ($2 \le N_2 \le 30$).

Pour consolider l'audience globale, l'administrateur souhaite :

1. Saisir chaque tableau en imposant que chaque valeur saisie soit strictement supérieure à la précédente ($T[i] > T[i-1]$ pour $i \ge 1$).
2. Fusionner les deux listes en un troisième tableau $T_3$ de taille $N_3 = N_1 + N_2$ trié par ordre croissant en un seul passage (algorithme d'interclassement linéaire sans aucun tri ultérieur !).
3. Extraire dans un tableau communs les identifiants d'abonnés connectés simultanément sur les deux serveurs (détection des partages de comptes).

La structure modulaire requise est la suivante :

• Une procédure Saisie_Taille(@n : Entier, num_serveur : Entier) pour valider $2 \le N \le 30$.
• Une procédure Remplir_Croissant(@t : Tab, n : Entier) qui saisit la première case $t[0]$, puis pour chaque case $i$ ($1 \le i < n$), boucle jusqu'à ce que $t[i] > t[i-1]$.
• Une procédure Fusionner(t1 : Tab, n1 : Entier, t2 : Tab, n2 : Entier, @t3 : TabGrand, @n3 : Entier) :
  • Utilise trois indices : $i$ (curseur sur $T_1$), $j$ (curseur sur $T_2$) et $k$ (curseur sur $T_3$).
  • Tant que $i < n_1$ et $j < n_2$, compare $t_1[i]$ et $t_2[j]$ et insère le plus petit dans $t_3[k]$.
  • Copie ensuite les éléments restants du tableau non encore épuisé.
  • Fixe $n_3 \leftarrow n_1 + n_2$.
• Une procédure Trouver_Doublons(t1 : Tab, n1 : Entier, t2 : Tab, n2 : Entier, @communs : Tab, @nb_com : Entier) qui tire parti du tri croissant des deux tableaux pour identifier les valeurs communes en un seul parcours conjoint.
• Une procédure Afficher_Liste(t : Tab, n : Entier, titre : Chaîne) pour afficher les éléments d'un tableau.