Aller au contenu
Réussir mon BTS SIO

Tape une notion, une commande ou le nom d'une épreuve.

Par exemple

Chapitre 1434 minDébutant

Sujets d'algorithmique corrigés type BTS SIO

Par Josselyn C., prof de BTS SIO. Mis à jour le .

À la fin de ce chapitre, tu sauras

  • traiter un sujet complet dans les conditions de l'épreuve ;
  • mobiliser parcours, chaînes, fonctions et tris sur un contexte professionnel ;
  • comparer ta solution à un corrigé commenté.

12 exercices corrigés

Ce chapitre propose trois sujets d'entraînement corrigés, construits comme la situation A de l'épreuve E3 : une situation professionnelle, des données, parfois des composants fournis, des questions à traiter sur table puis sur machine, et les questions qu'une commission peut poser à l'oral. Chaque corrigé donne l'analyse, l'algorithme, le programme Python, le jeu d'essai et les réponses d'entretien.

Comment utiliser ces sujets

Mets-toi en condition : 30 minutes sur papier pour les questions « sur table », sans ordinateur, puis 30 minutes sur machine. Ouvre les corrigés seulement après. Le premier sujet est le plus guidé, le troisième le plus ouvert. Ce ne sont pas des sujets officiels : ils reprennent la forme décrite par le référentiel (chapitre 13) et les notions de ce cours.

SujetContexteNotions mobilisées
1Supervision des temps de réponse d'un serveur webParcours, moyenne, maximum avec position, comptage, séries consécutives
2Contrôle des numéros de badge par l'algorithme de LuhnChaînes, conversions, MOD, fonctions, composant fourni
3Gestion du stock d'un service informatiqueTableau à colonnes de types différents, recherche, mise à jour, tri

Sujet 1 : supervision d'un serveur web

Contexte. L'outil de supervision d'une PME relève toutes les heures le temps de réponse de son serveur web, en millisecondes. Les 24 relevés d'une journée sont fournis dans une liste ; l'indice correspond à l'heure (indice 0 pour le relevé de 0 h, indice 23 pour celui de 23 h).

python
releves = [120, 135, 128, 410, 520, 480, 150, 140, 610, 132, 125, 118,
           450, 470, 500, 530, 140, 130, 125, 122, 119, 380, 395, 128]
SEUIL = 400

Un relevé est lent s'il dépasse strictement SEUIL. Le responsable veut un bilan de la journée.

Sur table.

  1. Écris l'algorithme de la fonction moyenne(t) et celui de la fonction heure_du_max(t), qui renvoie l'indice du plus grand relevé.
  2. Écris l'algorithme de la fonction nb_lents(t, seuil).
  3. Écris l'algorithme de la fonction plus_longue_serie(t, seuil), qui renvoie la longueur de la plus longue suite de relevés lents consécutifs et l'heure à laquelle elle commence.
  4. Prépare un jeu d'essai pour plus_longue_serie.

Sur machine.

  1. Programme les fonctions et affiche le bilan de la journée.
  2. Le responsable veut une alerte dès que trois relevés consécutifs sont lents. Modifie ton programme pour afficher l'heure de chaque alerte (l'heure du troisième relevé lent consécutif).

Exercice 1 sur 12 Sujet 1, questions 1 et 2 Réussi À revoir

Écris moyenne, heure_du_max et nb_lents, en pseudo-code puis en Python. Quelles valeurs obtiens-tu pour la journée ?

Voir la réponseMasquer la réponse de l'exercice 1

Trois motifs du cours : l'accumulateur, le maximum avec position (chapitre 7), le compteur.

text
Fonction Moyenne(t : tableau d'entiers) : réel
    somme ← 0
    Pour i de 0 à longueur(t) - 1 Faire
        somme ← somme + t[i]
    FinPour
    Retourner somme / longueur(t)
FinFonction

Fonction HeureDuMax(t : tableau d'entiers) : entier
    i_max ← 0
    Pour i de 1 à longueur(t) - 1 Faire
        Si t[i] > t[i_max] Alors
            i_max ← i
        FinSi
    FinPour
    Retourner i_max
FinFonction

Fonction NbLents(t : tableau d'entiers, seuil : entier) : entier
    nb ← 0
    Pour i de 0 à longueur(t) - 1 Faire
        Si t[i] > seuil Alors
            nb ← nb + 1
        FinSi
    FinPour
    Retourner nb
FinFonction
python
def moyenne(t):
    somme = 0
    for valeur in t:
        somme = somme + valeur
    return somme / len(t)


def heure_du_max(t):
    i_max = 0
    for i in range(1, len(t)):
        if t[i] > t[i_max]:
            i_max = i
    return i_max


def nb_lents(t, seuil):
    nb = 0
    for valeur in t:
        if valeur > seuil:
            nb = nb + 1
    return nb


releves = [120, 135, 128, 410, 520, 480, 150, 140, 610, 132, 125, 118,
           450, 470, 500, 530, 140, 130, 125, 122, 119, 380, 395, 128]
print(round(moyenne(releves), 1), heure_du_max(releves), nb_lents(releves, 400))

Résultat : 273.2 8 8. La somme des relevés vaut 6 557, soit une moyenne de 273,2 ms ; le pic, 610 ms, a lieu à 8 h ; 8 relevés dépassent 400 ms (410, 520, 480, 610, 450, 470, 500 et 530).

Tu avais trouvé ?

Exercice 2 sur 12 Sujet 1, questions 3 et 4 Réussi À revoir

Écris plus_longue_serie(t, seuil) et son jeu d'essai. Que renvoie-t-elle pour la journée ?

Voir la réponseMasquer la réponse de l'exercice 2

Analyse. On parcourt les relevés en tenant à jour la longueur de la série en cours : elle augmente de 1 sur un relevé lent et retombe à 0 sur un relevé normal. Quand elle dépasse le meilleur résultat, on retient sa longueur et son heure de début. L'heure de début est l'indice du relevé où la série en cours a démarré, c'est-à-dire où elle valait 0 juste avant.

text
Fonction PlusLongueSerie(t : tableau d'entiers, seuil : entier) : entier, entier
    meilleure ← 0
    debut_meilleure ← -1
    en_cours ← 0
    debut_en_cours ← 0
    Pour h de 0 à longueur(t) - 1 Faire
        Si t[h] > seuil Alors
            Si en_cours = 0 Alors
                debut_en_cours ← h
            FinSi
            en_cours ← en_cours + 1
            Si en_cours > meilleure Alors
                meilleure ← en_cours
                debut_meilleure ← debut_en_cours
            FinSi
        Sinon
            en_cours ← 0
        FinSi
    FinPour
    Retourner meilleure, debut_meilleure
FinFonction
python
def plus_longue_serie(t, seuil):
    """Longueur et heure de début de la plus longue série de valeurs > seuil.

    Renvoie (0, -1) s'il n'y a aucune valeur au-dessus du seuil.
    """
    meilleure = 0
    debut_meilleure = -1
    en_cours = 0
    debut_en_cours = 0
    for h in range(len(t)):
        if t[h] > seuil:
            if en_cours == 0:
                debut_en_cours = h
            en_cours = en_cours + 1
            if en_cours > meilleure:
                meilleure = en_cours
                debut_meilleure = debut_en_cours
        else:
            en_cours = 0
    return meilleure, debut_meilleure


assert plus_longue_serie([500, 100, 600, 700, 100], 400) == (2, 2)   # cas normal
assert plus_longue_serie([100, 200], 400) == (0, -1)                 # aucun relevé lent
assert plus_longue_serie([500, 600, 700], 400) == (3, 0)             # tout est lent
assert plus_longue_serie([100, 500, 600], 400) == (2, 1)             # série en fin de liste
assert plus_longue_serie([500, 100, 600], 400) == (1, 0)             # égalité : la première
assert plus_longue_serie([400, 401], 400) == (1, 1)                  # frontière : 400 n'est pas lent

releves = [120, 135, 128, 410, 520, 480, 150, 140, 610, 132, 125, 118,
           450, 470, 500, 530, 140, 130, 125, 122, 119, 380, 395, 128]
print(plus_longue_serie(releves, 400))

Résultat : (4, 12). De 12 h à 15 h, quatre relevés lents se suivent (450, 470, 500, 530) ; la série de 3 h à 5 h n'en compte que trois.

Le jeu d'essai couvre les cas où une erreur se cache : aucune série (la valeur −1 doit être documentée), une série qui va jusqu'au bout de la liste (aucun relevé normal ne vient la « clore »), deux séries de même longueur (> garde la première), et la frontière du seuil.

Tu avais trouvé ?

Exercice 3 sur 12 Sujet 1, questions 5 et 6 Réussi À revoir

Affiche le bilan complet, puis ajoute la détection des alertes : l'heure de chaque troisième relevé lent consécutif.

Voir la réponseMasquer la réponse de l'exercice 3

La détection d'alerte réutilise la série en cours : une alerte se déclenche quand elle atteint exactement 3. Avec >= 3, une série de quatre relevés lents déclencherait deux alertes.

python
def heures_alerte(t, seuil):
    alertes = []
    en_cours = 0
    for h in range(len(t)):
        if t[h] > seuil:
            en_cours = en_cours + 1
        else:
            en_cours = 0
        if en_cours == 3:
            alertes.append(h)
    return alertes


releves = [120, 135, 128, 410, 520, 480, 150, 140, 610, 132, 125, 118,
           450, 470, 500, 530, 140, 130, 125, 122, 119, 380, 395, 128]
SEUIL = 400
print(f"Alertes à : {heures_alerte(releves, SEUIL)}")
text
Alertes à : [5, 14]

Le bilan complet assemble les appels (avec les fonctions des questions précédentes dans le même fichier) :

python
print(f"Temps de réponse moyen : {moyenne(releves):.1f} ms")
h = heure_du_max(releves)
print(f"Pic : {releves[h]} ms à {h} h")
print(f"Relevés lents : {nb_lents(releves, SEUIL)} sur {len(releves)}")
longueur, debut = plus_longue_serie(releves, SEUIL)
print(f"Plus longue série lente : {longueur} h à partir de {debut} h")
print(f"Alertes à : {heures_alerte(releves, SEUIL)}")
text
Temps de réponse moyen : 273.2 ms
Pic : 610 ms à 8 h
Relevés lents : 8 sur 24
Plus longue série lente : 4 h à partir de 12 h
Alertes à : [5, 14]

Tu avais trouvé ?

Exercice 4 sur 12 Sujet 1, entretien Réussi À revoir

Prépare tes réponses à ces questions de la commission.

  1. « Pourquoi en_cours == 3 et pas en_cours >= 3 ? »
  2. « Que renvoie moyenne si l'outil n'a fait aucun relevé ? Comment l'éviter ? »
  3. « Vous parcourez la liste cinq fois. Pourriez-vous faire mieux ? Est-ce utile ici ? »
Voir la réponseMasquer la réponse de l'exercice 4
  1. « Avec >=, chaque relevé lent supplémentaire de la même série redéclencherait une alerte : la série de 12 h à 15 h en produirait deux, à 14 h et 15 h. Avec ==, une série donne une seule alerte, au moment où elle atteint trois relevés. »
  2. « La liste vide provoque une division par zéro, ZeroDivisionError. Je l'écris en précondition dans la docstring et je teste len(releves) > 0 avant d'appeler, ou je renvoie None dans ce cas. »
  3. « On pourrait tout calculer en un seul parcours, avec toutes les variables dans la même boucle. Le coût reste proportionnel au nombre de relevés dans les deux cas. Avec 24 valeurs, c'est imperceptible, et des fonctions séparées se testent et se réutilisent plus facilement : je garde ce découpage. »

Tu avais trouvé ?

Sujet 2 : contrôler des numéros de badge

Contexte. Les badges d'accès d'une entreprise portent un numéro dont le dernier chiffre est une clé de contrôle calculée par l'algorithme de Luhn, le même que pour les numéros de cartes bancaires. Le logiciel d'accueil doit refuser les numéros mal saisis.

Méthode fournie (algorithme de Luhn). On lit les chiffres du numéro de droite à gauche, en numérotant les positions à partir de 0 (le dernier chiffre, la clé, est en position 0). On double les chiffres des positions impaires ; si le double dépasse 9, on lui retire 9. On fait la somme de tous les chiffres ainsi obtenus (doublés ou non). Le numéro est valide si cette somme est un multiple de 10.

Composant fourni.

python
def chiffre(numero, position):
    """Renvoie le chiffre (un entier) situé à la position donnée,
    les positions étant comptées à partir de 0 depuis la DROITE du numéro."""
    return int(numero[len(numero) - 1 - position])

Sur table.

  1. Applique l'algorithme à la main au numéro 79927398713. Est-il valide ?
  2. Écris l'algorithme de la fonction somme_luhn(numero) en utilisant le composant chiffre.
  3. Écris est_valide(numero), qui renvoie faux aussi si la chaîne est vide ou contient autre chose que des chiffres.

Sur machine.

  1. Programme et teste ces fonctions.
  2. Écris cle(debut), qui calcule le chiffre de contrôle à ajouter à un numéro sans clé.
  3. Montre qu'une erreur sur un seul chiffre est toujours détectée sur un exemple, et qu'une inversion de deux chiffres voisins l'est le plus souvent.

Exercice 5 sur 12 Sujet 2, question 1 Réussi À revoir

Applique l'algorithme de Luhn à la main à 79927398713.

Voir la réponseMasquer la réponse de l'exercice 5
Position (depuis la droite)109876543210
Chiffre79927398713
Doublé (positions impaires)1846162
Valeur retenue79947697723

Les doubles 18 et 16 dépassent 9 : on retient 18 − 9 = 9 et 16 − 9 = 7. Somme : 7 + 9 + 9 + 4 + 7 + 6 + 9 + 7 + 7 + 2 + 3 = 70, un multiple de 10. Le numéro est valide.

Tu avais trouvé ?

Exercice 6 sur 12 Sujet 2, questions 2 à 4 Réussi À revoir

Écris somme_luhn et est_valide en pseudo-code puis en Python, avec un jeu d'essai.

Voir la réponseMasquer la réponse de l'exercice 6
text
Fonction SommeLuhn(numero : chaîne) : entier
    somme ← 0
    Pour p de 0 à longueur(numero) - 1 Faire
        c ← chiffre(numero, p)          // composant fourni
        Si p MOD 2 = 1 Alors
            c ← c × 2
            Si c > 9 Alors
                c ← c - 9
            FinSi
        FinSi
        somme ← somme + c
    FinPour
    Retourner somme
FinFonction

Fonction EstValide(numero : chaîne) : booléen
    Si longueur(numero) = 0 OU NON QueDesChiffres(numero) Alors
        Retourner FAUX
    FinSi
    Retourner SommeLuhn(numero) MOD 10 = 0
FinFonction
python
def chiffre(numero, position):
    return int(numero[len(numero) - 1 - position])


def somme_luhn(numero):
    somme = 0
    for p in range(len(numero)):
        c = chiffre(numero, p)
        if p % 2 == 1:
            c = c * 2
            if c > 9:
                c = c - 9
        somme = somme + c
    return somme


def est_valide(numero):
    if numero == "" or not numero.isdigit():
        return False
    return somme_luhn(numero) % 10 == 0


assert somme_luhn("79927398713") == 70
assert est_valide("79927398713") == True     # cas normal valide
assert est_valide("79927398710") == False    # mauvaise clé
assert est_valide("") == False               # cas limite : vide
assert est_valide("7992-7398") == False      # caractère interdit
assert est_valide("0") == True               # cas limite : un seul chiffre, somme 0
print("Tests réussis")

Le test numero.isdigit() est fait avant tout appel à chiffre, qui lèverait une ValueError sur un tiret. Grâce à l'évaluation partielle, not numero.isdigit() n'est même pas évalué sur une chaîne vide. Le cas "0" est un vrai cas limite : la somme vaut 0, un multiple de 10 ; une règle métier pourrait imposer une longueur minimale.

Tu avais trouvé ?

Exercice 7 sur 12 Sujet 2, questions 5 et 6 Réussi À revoir

Écris cle(debut). Calcule la clé de 7992739871 et de 1234567. Puis teste une erreur sur un chiffre et une inversion de chiffres voisins.

Voir la réponseMasquer la réponse de l'exercice 7

La clé est le chiffre k de 0 à 9 tel que debut + k soit valide. Au lieu de chercher une formule, on réutilise est_valide en essayant les dix chiffres : une recherche séquentielle sur dix candidats.

python
def chiffre(numero, position):
    return int(numero[len(numero) - 1 - position])


def somme_luhn(numero):
    somme = 0
    for p in range(len(numero)):
        c = chiffre(numero, p)
        if p % 2 == 1:
            c = c * 2
            if c > 9:
                c = c - 9
        somme = somme + c
    return somme


def est_valide(numero):
    if numero == "" or not numero.isdigit():
        return False
    return somme_luhn(numero) % 10 == 0


def cle(debut):
    for k in range(10):
        if est_valide(debut + str(k)):
            return k
    return -1   # impossible si debut ne contient que des chiffres


print(cle("7992739871"), cle("1234567"))
print(est_valide("79927398713"), est_valide("79927398723"), est_valide("79927398731"))
text
3 4
True False False

La clé de 7992739871 est 3 : on retrouve le numéro de la question 1. Changer un seul chiffre (…713 en …723) modifie la somme d'une valeur comprise entre 1 et 9 : elle ne peut pas rester un multiple de 10, l'erreur est toujours détectée. L'inversion de 13 en 31 est détectée aussi. L'algorithme de Luhn ne détecte pas toutes les inversions : celle de 09 et 90 passe inaperçue, car 0 et 9 donnent la même contribution qu'ils soient doublés ou non (0 doublé vaut 0 ; 9 doublé vaut 18, ramené à 9).

Tu avais trouvé ?

Exercice 8 sur 12 Sujet 2, entretien Réussi À revoir

  1. « Pourquoi utiliser le composant chiffre plutôt que d'écrire int(numero[i]) ? »
  2. « Votre fonction cle essaie dix valeurs. Est-ce efficace ? »
  3. « Cette clé protège-t-elle contre un fraudeur ? »
Voir la réponseMasquer la réponse de l'exercice 8
  1. « Le composant gère le sens de lecture de droite à gauche, source d'erreurs d'indices. En l'appelant, je m'appuie sur une fonction déjà validée et je respecte le sujet. Si sa convention changeait, mon code suivrait sans modification. »
  2. « Au pire dix appels à est_valide, chacun proportionnel à la longueur du numéro : pour un numéro de 16 chiffres, quelques centaines d'opérations. C'est négligeable, et le code réutilise une fonction testée au lieu d'introduire une formule de plus à vérifier. »
  3. « Non. La clé détecte les erreurs de saisie involontaires, mais l'algorithme est public : n'importe qui peut fabriquer un numéro valide. Pour contrôler l'accès, il faut vérifier que le numéro existe dans la base des badges actifs, et protéger cette vérification. La clé est une redondance contre les erreurs, pas une sécurité contre la fraude. »

Tu avais trouvé ?

Sujet 3 : le stock du service informatique

Contexte. Le service informatique d'un lycée suit son stock de petit matériel dans un tableau à deux dimensions. Chaque ligne décrit un article : sa référence (chaîne), son libellé (chaîne), la quantité en stock (entier) et le prix unitaire en euros (réel).

python
stock = [
    ["CLV-01", "Clavier USB", 14, 19.90],
    ["SOU-02", "Souris optique", 3, 12.50],
    ["ECR-24", "Écran 24 pouces", 6, 139.00],
    ["HDMI-2", "Câble HDMI 2 m", 0, 8.90],
    ["CASQ-1", "Casque audio", 9, 34.00],
]
REF, LIBELLE, QTE, PRIX = 0, 1, 2, 3   # numéros des colonnes
SEUIL_COMMANDE = 5

Sur table.

  1. Écris l'algorithme de valeur_stock(stock), la valeur totale du stock (somme des quantités × prix).
  2. Écris l'algorithme de a_commander(stock, seuil), qui renvoie la liste des références dont la quantité est strictement inférieure au seuil.
  3. Écris l'algorithme de indice_article(stock, ref), qui renvoie l'indice de la ligne de l'article, ou −1.

Sur machine.

  1. Programme ces fonctions et vérifie-les.
  2. Écris sortir(stock, ref, quantite), qui enregistre la sortie de matériel : elle renvoie un message et ne modifie le stock que si l'article existe et que la quantité disponible suffit.
  3. Affiche les articles par valeur en stock décroissante, sans utiliser sort ni sorted.

Exercice 9 sur 12 Sujet 3, questions 1 à 4 Réussi À revoir

Écris et teste valeur_stock, a_commander et indice_article.

Voir la réponseMasquer la réponse de l'exercice 9

Les constantes REF, QTE, PRIX nomment les colonnes : article[QTE] se lit mieux que article[2]. Chaque ligne a des colonnes de types différents, comme dans le chapitre 8.

text
Fonction ValeurStock(stock : tableau de lignes) : réel
    total ← 0
    Pour i de 0 à longueur(stock) - 1 Faire
        total ← total + stock[i][QTE] × stock[i][PRIX]
    FinPour
    Retourner total
FinFonction

Fonction IndiceArticle(stock : tableau de lignes, ref : chaîne) : entier
    i ← 0
    TantQue i < longueur(stock) ET stock[i][REF] ≠ ref Faire
        i ← i + 1
    FinTantQue
    Si i < longueur(stock) Alors
        Retourner i
    Sinon
        Retourner -1
    FinSi
FinFonction
python
REF, LIBELLE, QTE, PRIX = 0, 1, 2, 3


def valeur_stock(stock):
    total = 0
    for article in stock:
        total = total + article[QTE] * article[PRIX]
    return total


def a_commander(stock, seuil):
    refs = []
    for article in stock:
        if article[QTE] < seuil:
            refs.append(article[REF])
    return refs


def indice_article(stock, ref):
    for i in range(len(stock)):
        if stock[i][REF] == ref:
            return i
    return -1


stock = [
    ["CLV-01", "Clavier USB", 14, 19.90],
    ["SOU-02", "Souris optique", 3, 12.50],
    ["ECR-24", "Écran 24 pouces", 6, 139.00],
    ["HDMI-2", "Câble HDMI 2 m", 0, 8.90],
    ["CASQ-1", "Casque audio", 9, 34.00],
]
print(round(valeur_stock(stock), 2))
print(a_commander(stock, 5))
print(indice_article(stock, "ECR-24"), indice_article(stock, "WEB-00"))
text
1456.1
['SOU-02', 'HDMI-2']
2 -1

Détail de la valeur : 14 × 19,90 = 278,60 ; 3 × 12,50 = 37,50 ; 6 × 139 = 834 ; 0 × 8,90 = 0 ; 9 × 34 = 306 ; total 1 456,10 €. Le round corrige l'affichage des réels (chapitre 2). Dans le TantQue du pseudo-code, le test i < longueur(stock) vient en premier : quand i atteint la fin, stock[i] n'est pas évalué.

Tu avais trouvé ?

Exercice 10 sur 12 Sujet 3, question 5 Réussi À revoir

Écris sortir(stock, ref, quantite) et un jeu d'essai qui couvre tous les cas.

Voir la réponseMasquer la réponse de l'exercice 10

Trois cas d'échec à traiter avant de modifier quoi que ce soit : référence inconnue, quantité demandée non positive, stock insuffisant. La fonction réutilise indice_article.

python
REF, LIBELLE, QTE, PRIX = 0, 1, 2, 3


def indice_article(stock, ref):
    for i in range(len(stock)):
        if stock[i][REF] == ref:
            return i
    return -1


def sortir(stock, ref, quantite):
    """Retire quantite unités de l'article ref si c'est possible ; renvoie un message."""
    i = indice_article(stock, ref)
    if i == -1:
        return f"Référence {ref} inconnue"
    if quantite <= 0:
        return "La quantité doit être positive"
    if stock[i][QTE] < quantite:
        return f"Stock insuffisant : {stock[i][QTE]} disponible(s)"
    stock[i][QTE] = stock[i][QTE] - quantite
    return f"Sortie enregistrée, reste {stock[i][QTE]}"


stock = [["CLV-01", "Clavier USB", 14, 19.90], ["SOU-02", "Souris optique", 3, 12.50]]
print(sortir(stock, "CLV-01", 4))
print(sortir(stock, "SOU-02", 3))
print(sortir(stock, "SOU-02", 1))
print(sortir(stock, "XXX-99", 1))
print(sortir(stock, "CLV-01", 0))
print(stock)
text
Sortie enregistrée, reste 10
Sortie enregistrée, reste 0
Stock insuffisant : 0 disponible(s)
Référence XXX-99 inconnue
La quantité doit être positive
[['CLV-01', 'Clavier USB', 10, 19.9], ['SOU-02', 'Souris optique', 0, 12.5]]
Cas testéPourquoi
Sortie normale (4 claviers sur 14)Cas nominal
Sortie de tout le stock (3 souris sur 3)Frontière : < et pas <= dans le test d'insuffisance
Sortie sur un stock à 0Le refus ne doit rien modifier
Référence inconnueLe −1 de la recherche est bien traité
Quantité nulleContrôle de saisie

Le stock est modifié sur place : la liste passée en paramètre est en entrée-sortie (chapitre 6). La dernière ligne affichée le vérifie.

Tu avais trouvé ?

Exercice 11 sur 12 Sujet 3, question 6 Réussi À revoir

Affiche les articles par valeur en stock décroissante, sans sort ni sorted, et sans modifier l'ordre de stock.

Voir la réponseMasquer la réponse de l'exercice 11

On construit d'abord une liste de couples (valeur, libellé), puis on la trie par sélection, en cherchant le maximum à chaque étape (chapitre 10). stock n'est pas touché : on trie une nouvelle liste.

python
REF, LIBELLE, QTE, PRIX = 0, 1, 2, 3
stock = [
    ["CLV-01", "Clavier USB", 14, 19.90],
    ["SOU-02", "Souris optique", 3, 12.50],
    ["ECR-24", "Écran 24 pouces", 6, 139.00],
    ["HDMI-2", "Câble HDMI 2 m", 0, 8.90],
    ["CASQ-1", "Casque audio", 9, 34.00],
]

valeurs = []
for article in stock:
    valeurs.append((round(article[QTE] * article[PRIX], 2), article[LIBELLE]))

n = len(valeurs)
for i in range(n - 1):
    i_max = i
    for j in range(i + 1, n):
        if valeurs[j][0] > valeurs[i_max][0]:
            i_max = j
    valeurs[i], valeurs[i_max] = valeurs[i_max], valeurs[i]

for valeur, libelle in valeurs:
    print(f"{libelle:<16} {valeur:>8.2f} €")
text
Écran 24 pouces    834.00 €
Casque audio       306.00 €
Clavier USB        278.60 €
Souris optique      37.50 €
Câble HDMI 2 m       0.00 €

Le tri compare la première composante des couples (valeurs[j][0]) et déplace le couple entier : le libellé suit sa valeur. Avec sorted, on écrirait sorted(valeurs, reverse=True), qui compare aussi les couples sur leur premier élément.

Tu avais trouvé ?

Exercice 12 sur 12 Sujet 3, entretien Réussi À revoir

  1. « Pourquoi sortir vérifie-t-elle tout avant de modifier le stock ? »
  2. « Deux techniciens enregistrent une sortie du dernier écran au même moment, sur deux postes. Que peut-il se passer ? »
  3. « Comment passeriez-vous de ce tableau en mémoire à une vraie application ? »
Voir la réponseMasquer la réponse de l'exercice 12
  1. « Pour ne jamais laisser le stock dans un état faux : si l'on retirait d'abord la quantité, puis qu'on découvrait qu'elle dépasse le disponible, le stock serait négatif. Toutes les vérifications passent, ou rien n'est modifié. »
  2. « Chacun lit “1 écran disponible”, chacun valide sa sortie, et le stock passe à −1. Ce problème d'accès concurrents ne se règle pas dans cet algorithme : une application réelle stocke les données dans une base, qui gère les transactions et les verrous. »
  3. « Le tableau deviendrait une table SQL article ; indice_article serait une requête SELECT … WHERE ref = ? et sortir une transaction avec un UPDATE. La logique de contrôle reste la même. » Le cours de SQL traite exactement ce cas.

Tu avais trouvé ?

Chapitre terminé !

Fais les 12 exercices avant de passer à la suite : c'est en t'entraînant que tout se fixe.

chapitres
–
de série
–
du cours
–
Cours suivant : HTML et CSSRevoir le sommaire du cours