Corrigé de l’algorithme du bac S septembre 2014

samedi 27 septembre 2014
par  Alain BUSSER

Cet article est dédié à tous les collègues, anciens collègues, amis, membres de la famille, et surtout anciens élèves qui ont subi à un moment où un autre (mais surtout trop tôt, particulièrement les élèves) une chimiothérapie. En effet c’est sur ce sujet que porte l’exercice 3 du bac S session de septembre 2014 :

On administre à un patient un médicament par injection intraveineuse. La quantité
de médicament dans le sang diminue en fonction du temps.
Le but de l’exercice est d’étudier pour différentes hypothèses, l’évolution de cette
quantité minute par minute.

Premier protocole

On effectue à l’instant 0 une injection de 10 mL de médicament. On estime
que 20% du médicament est éliminé par minute. Pour tout entier naturel n,
on note un la quantité de médicament, en mL, restant dans le sang au bout de n
minutes. Ainsi u0=10.

En fait, puisque diminuer de 20 % revient à multiplier par la raison 0,8, la suite est géométrique et tend vers 0 :

image/svg+xml 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10

Pour programmer cette suite en Sophus, pas besoin de parler de multiplication ou de raison :

Le script à copier-coller

On peut tester dans l’interpréteur sophus (en ligne ou hors ligne)

médicament = new Variable 10
minutes = new Variable 0
(0.01).tantQuePlusPetitQue médicament, ->
    diminuer médicament, de, 20, pourcents
    incrémenter minutes
montrer minutes

Ci-dessous un mini interpréteur en ligne pour tester sur place.

Pour savoir combien de temps il faut pour que la quantité de médicament descende en-dessous de 0,01 mL, cliquer sur le bouton ci-dessous :

Deuxième protocole

Une machine effectue à l’instant 0 une injection de 10 mL de médicament.
On estime que 20% du médicament est éliminé par minute. Lorsque la quantité de médicament tombe en-dessous de 5 mL, la machine réinjecte 4 mL de produit.
Au bout de 15 minutes, on arrête la machine.

Maintenant la suite oscille :

image/svg+xml 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10

Le script Sophus est une petite modification du précédent, avec un test dans la boucle :

Le script à copier-coller

Pour tester soit dans l’interpréteur sophus, soit dans un des interpréteurs de cet article (au choix !) :

médicament = nouvelle Variable 10
15 fois faire
    diminuer médicament de 20 pourcents
    Si médicament.valeur < 5
        augmenter médicament  de  4
    montrer médicament

Et voici la variante proposée ci-dessous, avec un tableau :

médicament = nouvelle Variable 10
tableau = [10]

15 fois faire
    diminuer médicament de 20 pourcents
    Si médicament.valeur < 5
        augmenter médicament de 4
    tableau.empiler médicament.valeur
montrer tableau

Le problème est que l’instruction « montrer médicament » est effectuée 15 fois ce qui fatigue un peu sur la fin. Alors on peut compliquer légèrement le script, en créant un tableau contenant initialement le nombre 10, et en empilant au fur et à mesures les valeurs successives prises par la variable médicament :

Voici la version en ligne, à tester :

On constate que sophus affiche ses variables en « locale », soit, en français, avec une virgule au lieu du point décimal, et arrondi systématiquement à trois décimales. Néanmoins, on continuera dans la suite de l’article à manipuler des tableaux, ne serait-ce que lorsqu’il y a 30 valeurs à afficher (voir ci-dessous) !

Pour connaître la quantité totale de médicament injecté, on crée une variable somme que l’on augmente à chaque passage dans la boucle, de la quantité de médicament présente :

le script à copier-coller

médicament = new Variable 10
somme = new Variable 10
15.foisFaire ->
    diminuer médicament, de, 20, pourcents
    si médicament.valeur < 5, ->
        augmenter médicament, de, 4
    augmenter somme, de, médicament
montrer somme

Pour tester en ligne, encore un interpréteur sophus ; il n’y a plus qu’à cliquer, merci qui ? Merci Sophus !

Troisième protocole

On souhaite programmer la machine afin qu’elle injecte 2 mL de produit
lorsque la quantité de médicament dans le sang est inférieure ou égale à
6 mL et qu’elle s’arrête au bout de 30 minutes.

En fait il ne s’agit que de tester la capacité des élèves à modifier un algorithme pour l’adapter à ses besoins. Il suffit donc de modifier l’un des scripts précédents pour avoir la réponse. Cependant, la représentation graphique montre que les oscillations de la suite sont plus chaotiques maintenant :

image/svg+xml 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 0 1 2 3 4 5 6 7 8 9 10

Le script devient celui-ci :

Pour les paresseux

médicament = nouvelle Variable 10
tableau = [10]

30 fois faire
    diminuer médicament de 20 pourcents
    Si médicament.valeur < 6
        augmenter médicament de 2
    tableau.empiler médicament.valeur
montrer tableau

Quatrième protocole

On programme la machine de façon que :
— à l’instant 0, elle injecte 10 mL de médicament,
— toutes les minutes, elle injecte 1 mL de médicament.
On estime que 20% du médicament présent dans le sang est éliminé par mi-
nute.

Ce protocole est donc plus simple que les précédents puisqu’il ne comporte plus de test, les injections étant systématiques. Du coup, la suite converge :

image/svg+xml 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10

On peut donc rédiger le nouveau script en enlevant les tests des scripts précédents :

Mais puisque l’augmentation est toujours de 1 mL, et que tous les nombres (pas seulement les entiers) peuvent être incrémentés, on peut encore simplifier le script :

Pour copier-coller

médicament = nouvelle Variable 10
tableau = [10]

15 fois faire
    diminuer médicament de 20 pourcents
    augmenter médicament de 1
    tableau.empiler médicament.valeur
montrer tableau

et la version simplifiée :

médicament = nouvelle Variable 10
tableau = [10]

15 fois faire
    diminuer médicament de 20 pourcents
    incrémenter médicament
    tableau.empiler médicament.valeur
montrer tableau

Pour tester en ligne, voici un quatrième interpréteur sophus :

Les scripts des figures

Les figures de l’article ont été faite avec alcoffeethmique ; les voici, en CoffeeScript :

  • représentation graphique de la suite géométrique :
u = [10]
for n in [1..15]
    med = u[n-1]*.8
    u.push med
    
dessineSuite u, 15, 0, 10, 3, 'red'
  • représentation graphique de la suite donnée algorithmiquement :
u = [10]
for n in [1..15]
    med = u[n-1]*.8
    med += 4 if med < 5
    u.push med
    
dessineSuite u, 15, 0, 10, 3, 'red'
  • représentation graphique de la variante de cette suite :
u = [10]
for n in [1..30]
    med = u[n-1]*.8
    med += 2 if med < 6
    u.push med

dessineSuite u, 30, 0, 10, 3, 'blue'
  • représentation graphique de la suite arithmético-géométrique :
u = [10]
for n in [1..15]
    med = u[n-1]*.8
    med++
    u.push med

dessineSuite u, 15, 0, 10, 3, 'magenta'

Commentaires