Entraînement au bac : polynômes et nutrition

Comment utiliser cette page

Cette page reprend un sujet d'entraînement complet, avec deux exercices : les polynômes (représentés avec des listes chaînées) et la nutrition (représentée avec des objets et des classes). Pour chaque exercice, l'énoncé est d'abord reformulé de façon très explicite, puis chaque question est corrigée en détail, avec le raisonnement complet, une trace sur un exemple concret, et le code Python.

Exercice 1 — Les polynômes : énoncé

1. Questions 1 à 3 — corrigé détaillé

1.1 — Question 1 : construire la liste p1

p1 = creer_liste()
p1 = ajouter_en_tete((2, 0), p1)     # on ajoute d'abord le terme constant
p1 = ajouter_en_tete((-1, 1), p1)    # puis le terme en x
p1 = ajouter_en_tete((2, 3), p1)     # puis le terme en x³, qui devient la tête

Trace détaillée de la construction, étape par étape :

1.2 — Question 2 : tete(p1) et queue(p1)

1.3 — Question 3 : l'algorithme valuation

1. Cas 1 — la liste est vide : il ne reste plus aucun monôme à ajouter, donc on renvoie 0.
2. Cas 2 — la liste n'est pas vide : on lit le monôme de tête (son coefficient et son exposant), on calcule sa contribution coefficient × xexposant, et on y ajoute le résultat de valuation appliqué au reste de la liste (queue).

def valuation(liste, x):
    if est_vide(liste):
        return 0
    temp = tete(liste)
    return temp[0] * x ** temp[1] + valuation(queue(liste), x)

Trace détaillée de valuation(p1, 2) :

En remontant les appels : 2 + 0 = 2, puis -2 + 2 = 0, puis 16 + 0 = 16. On retrouve bien valuation(p1, 2) = 16, comme annoncé dans l'énoncé.

2. Question 4 — additionner deux polynômes

On découpe donc le problème en deux algorithmes : addition_monome_polynome, qui insère un seul monôme dans un polynôme, et addition_polynome, qui utilise le premier pour insérer tous les monômes d'un polynôme dans un autre, un par un.

2.1 — Insérer un monôme dans un polynôme : les 3 cas possibles

Pour insérer un monôme element = (coefficient, exposant) en tête d'une liste non vide dont la tête s'appelle premier, il faut comparer l'exposant de element à celui de premier. Il y a exactement 3 cas :

1. Cas 1 — l'exposant de element est plus grand que celui de premier : element n'a pas d'équivalent dans le polynôme à cet endroit, donc on l'insère directement, avant premier.
2. Cas 2 — les deux exposants sont égaux : les deux monômes portent sur la même puissance de x, donc on additionne leurs coefficients.
   • Si la somme des coefficients est différente de 0 : on remplace premier par le nouveau monôme, avec ce nouveau coefficient (même exposant).
   • Si la somme des coefficients vaut 0 : le monôme disparaît complètement du polynôme (un coefficient nul ne s'écrit pas).
3. Cas 3 — l'exposant de element est plus petit que celui de premier : ce n'est pas encore le bon endroit pour insérer element ; on garde premier en tête, et on recommence la même recherche dans le reste de la liste (queue).

def addition_monome_polynome(element, liste):    if est_vide(liste):        L = creer_liste()        L = ajouter_en_tete(element, L)        return L    premier = tete(liste)    if element[1] > premier[1]:        return ajouter_en_tete(element, liste)    elif element[1] == premier[1]:        nouveau_coeff = premier[0] + element[0]        reste = queue(liste)        if nouveau_coeff == 0:            return reste        else:            return ajouter_en_tete((nouveau_coeff, element[1]), reste)    else:        L = addition_monome_polynome(element, queue(liste))        return ajouter_en_tete(premier, L)

2.2 — Additionner deux polynômes complets

def addition_polynome(liste1, liste2):
    if est_vide(liste1):
        return liste2
    L = addition_polynome(queue(liste1), liste2)
    return addition_monome_polynome(tete(liste1), L)

Cet algorithme insère d'abord les monômes les plus profonds de liste1 (ceux de plus petit exposant), puis remonte vers la tête : le tout dernier monôme inséré est donc tete(liste1), celui de plus grand exposant.

2.3 — Trace détaillée sur l'exemple : p1 + p2

On applique addition_polynome(p1, p2) avec p1 = (2,3) → (-1,1) → (2,0) → ∅ et p2 = (5,4) → (3,2) → (1,0) → ∅. D'après le principe ci-dessus, cela revient à insérer, un par un dans p2, les monômes de p1 en commençant par le dernier : d'abord (2,0), puis (-1,1), puis (2,3).

p1 + p2 = 5x⁴ + 2x³ + 3x² − x + 3

Exercice 2 — Nutrition : énoncé

class aliment:
    def __init__(self, nom, energie, lipide, glucide, fibre, proteine, sel):
        self.nom = nom
        self.energie = energie
        self.lipide = lipide
        self.glucide = glucide
        self.fibre = fibre
        self.proteine = proteine
        self.sel = sel

3. Questions 1 à 3 — corrigé détaillé

3.1 — Question 1 : instancier riz

riz = aliment('riz blanc', 1532, 0.6, 81, 1.3, 7.2, 0.01)

Les 7 valeurs sont données exactement dans l'ordre des paramètres du constructeur __init__ : nom, energie, lipide, glucide, fibre, proteine, sel.

3.2 — Question 2 : la méthode __repr__

def __repr__(self):
    return (f"Intitulé : {self.nom}\n"
            f"Énergie : {self.energie} kJ\n"
            f"Lipides : {self.lipide} g\n"
            f"Glucides : {self.glucide} g\n"
            f"Fibres : {self.fibre} g\n"
            f"Proteines : {self.proteine} g\n"
            f"Sel : {self.sel}g")

Trace de l'affichage dans une console Python :

3.3 — Question 3 : quantité de glucides dans n grammes

n * riz.glucide / 100

Trace avec n = 75 :

En une seule instruction Python : 75 * riz.glucide / 100 renvoie bien 60.75.

4. Question 4 — composer et analyser un plat

4.1 — Question 4a : masse_plat

def masse_plat(plat):
    masse_totale = 0
    for un_aliment, masse in plat:
        masse_totale += masse
    return masse_totale

Trace détaillée sur salade_de_riz :

masse_plat(salade_de_riz) = 1310 g, exactement la valeur donnée par le sujet.

4.2 — Question 4b : energie_plat (et les fonctions semblables)

Il faut donc, pour chaque aliment du plat, calculer sa contribution réelle (en fonction de sa masse dans le plat), les additionner, puis ramener ce total à une base de 100 g du plat entier :

1. Pour un aliment de masse masse dans le plat, sa contribution en énergie est masse * aliment.energie / 100 (même principe qu'à la question 3 : on ramène la valeur « pour 100 g » à la masse réellement utilisée).
2. On additionne ces contributions pour tous les aliments du plat : on obtient l'énergie totale du plat entier.
3. On ramène ce total à 100 g du plat, avec la règle de trois énergie_totale / masse_totale × 100.

def energie_plat(plat):
    masse_totale = masse_plat(plat)
    energie_totale = 0
    for un_aliment, masse in plat:
        energie_totale += masse * un_aliment.energie / 100
    return energie_totale / masse_totale * 100

Les fonctions lipide_plat, glucide_plat, fibre_plat, proteine_plat et sel_plat se construisent exactement sur le même modèle, en remplaçant energie par l'attribut correspondant.

Dans les deux cas, on retrouve bien 1532, la valeur du tableau du riz : la formule ne dépend pas de la masse choisie, comme attendu.

Ces deux vérifications, ainsi que celle sur masse_plat, sont exécutées automatiquement dans le fichier téléchargeable de cette page.

4.3 — Question 4c : fiche_info_nutrition

def fiche_info_nutrition(plat):
    return {'Energie': energie_plat(plat),
            'Lipides': lipide_plat(plat),
            'Glucides': glucide_plat(plat),
            'Fibres': fibre_plat(plat),
            'Proteines': proteine_plat(plat),
            'Sel': sel_plat(plat)}

Sur le plat fictif [(A, 100), (B, 100)] de la vérification précédente (A : 1000 kJ, 10 g de lipides, 20 g de glucides, 1 g de fibres, 5 g de protéines, 0,1 g de sel pour 100 g ; B : le double de chaque valeur), fiche_info_nutrition renvoie :

{'Energie': 1500.0, 'Lipides': 15.0, 'Glucides': 30.0, 'Fibres': 1.5, 'Proteines': 7.5, 'Sel': 0.15}

Ce sont bien les moyennes simples de A et B pour chaque information, cohérentes avec un plat composé pour moitié de A et pour moitié de B.

5. Points clés à retenir

• Un polynôme se représente par une liste chaînée de couples (coefficient, exposant), triée par exposants décroissants.
• Insérer un monôme dans un polynôme demande de distinguer 3 cas selon les exposants : plus grand (insertion directe), égal (addition des coefficients, avec disparition si la somme vaut 0), plus petit (on continue de chercher dans le reste de la liste).
• Additionner deux polynômes revient à insérer, un par un, tous les monômes du premier dans le second.
• Dans la classe aliment, chaque valeur nutritionnelle est donnée pour 100 g : pour toute autre quantité, il faut diviser par 100 puis multiplier par la quantité réelle (ou l'inverse).
• Pour un plat composé de plusieurs aliments, calculer une valeur « pour 100 g du plat » demande de pondérer chaque aliment par sa masse réelle dans le plat, additionner, puis ramener le total à 100 g du plat entier — jamais une simple somme des valeurs affichées sur chaque aliment.