Algorithme : Intersection d'une droite avec l'axe des abscisses

Lorsqu'on étudie le signe d'une expression du premier degré, on est souvent amené à se poser la question de savoir à quel moment une droite va toucher l'axe des abscisses.

On a vu que l'équation \(ax+b=0\) avec \(a\neq0\) admettait \(x=\dfrac{-b}{a}\) comme solution.

Question

Écrire un algorithme prenant en entrée deux nombres a et b saisis par l'utilisateur et affichant la solution x0 de l'équation \(ax+b=0\)

Solution

1
Initialisation
2
  Saisir a et b
3
Traitement
4
  x0 prend la valeur -b/a
5
Sortie
6
  Afficher x0

Question

Programmer cet algorithme à l'aide du langage Python en ligne.

Solution

Voici le lien vers la solution et le code correspondant.

1
# Initialisation
2
a=float(input("Saisir la valeur de a"))
3
b=float(input("Saisir la valeur de b"))
4
# Traitement
5
x0=-b/a
6
# Sortie
7
print("La solution est x=",x0)

Question

Tester le programme pour a=0. Que se passe t-il ?

Solution

AttentionDivision par 0 !

a=0 provoque un erreur dans le programme en faisant une division par 0

Nous allons chercher à présent à protéger notre partie "Traitement" contre ce problème. Nous savons que notre formule n'a de sens que pour \(a\neq 0\).

On ne peut pas empêcher l'utilisateur peu scrupuleux de saisir une valeur nulle pour a, par contre, on peut refuser de passer à la suite du programme tant que celui-ci s’obstine à saisir une valeur nulle pour a.

La boucle "Tant Que"

Nous avons déjà rencontré une structure algorithmique permettant de répéter plusieurs fois une même partie d'un programme : la boucle Pour. On utilise cette boucle lorsqu'on connaît à l'avance le nombre de fois que l'on doit exécuter une partie de programme.

Ici, on ne sait pas à l'avance combien de fois l'utilisateur va s'obstiner à rentrer a=0, ni même si il le fera ou non. La boucle Pour n'est pas appropriée. On utilise à la place la structure suivante :

1
Tant que <condition> Faire
2
  <Intructions à répéter>
3
Fin Tant que

Cette nouvelle structure algorithmique va exécuter les Instructions à répéter tant que la condition est satisfaite.

Question

Modifier votre algorithme afin de demander à l'utilisateur de saisir une valeur pour a tant que celui-ci s'obstine à saisir une valeur nulle.

Indice

On pensera à donner une valeur initiale à a astucieusement choisie !

Solution

1
Initialisation
2
  a=0
3
  Tant que a=0 faire
4
    Saisir a
5
  Fin Tant que
6
  Saisir b
7
Traitement
8
  x0 prend la valeur -b/a
9
Sortie
10
  Afficher x0

Comme on le voit sur cet algorithme, l'ordinateur va demander à l'utilisateur une nouvelle valeur de a tant que celui-ci s'obstine à saisir 0.

AttentionPenser à initialiser a

il faut donner une valeur initiale à a avant la boucle Tant que car sinon l'ordinateur va chercher à savoir si a=0 ne connaissant pas a ! ! il sera du coup très embarrassé et le fera savoir par un message d'erreur du genre "la variable a est inconnue".

Pour éviter ce problème, on donne une valeur initiale à a choisie de manière à être sur que le programme aille bien dans la boucle Tant que. Il faut donc que a satisfasse la condition. C'est pourquoi nous avons choisi nécessairement \(a=0\)

Question

Modifier votre programme afin d'intégrer l'algorithme donné ci-dessus.

L'instruction Python pour la boucle Tant que est while. Voici un exemple d'utilisation en Python de cette instruction.

1
i=0
2
while i*i<10 :
3
  i=i+1
4
print(i)

Il n'y a pas de mot Python pour exprimer le Fin Tant que, c'est le décalage de la marge qui permet de délimiter la partie du programme concernée par la boucle Tant que.

Indice

On se rappellera que la condition a=0 s'écrit en python « a==0 » par opposition à l'opération « a=0 » qui affecte la valeur 0 à la variable a.

Solution

Voici le programme répondant à la question et de code correspondant.

1
# Initialisation
2
a=0
3
while (a==0):
4
  a=float(input("Saisir la valeur de a"))
5
b=float(input("Saisir la valeur de b"))
6
# Traitement
7
x0=-b/a
8
# Sortie
9
print("La solution est x=",x0)

En exécutant ce programme et en saisissant plusieurs fois 0 pour a, vous voyez que le programme continue de vous demander une valeur. Dès que \(a\neq 0\), le programme se poursuit. Il est donc impossible de faire une division par 0 dans ces conditions.