Exercice langage C : Programme conversion et calcule Équation

Travail à Faire :

1. Ecrivez un programme qui lit au clavier un prix en euros avec des centimes puis l’affiche :

a) arrondi à l’euro inférieur ;

b) arrondi à l’euro le plus proche ;

c) arrondi au quart d’euro le plus proche.


2. Ecrivez un programme qui calcule et affiche les solutions d’une équation du second degré

ax2 +  bx + c=0

où a, b et c sont trois nombres lus au clavier.


Exercice 1

La version la plus simple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include 

float prix, arrInf, arrProche, arrQuart;
int i;

main() {
   printf("prix à arrondir      ? ");
    scanf("%f", &prix);

    i = prix;
    arrInf = i;
   printf("euro inferieur       : %f\n", arrInf);

    i = prix + 0.5; 
    arrProche = i;
   printf("euro le plus proche  : %f\n", arrProche);

    i = 4 * prix + 0.5; 
    arrQuart = i / 4.0;
   printf("quart le plus proche : %f\n", arrQuart);
}

 



Exemple d'exécution :

prix à arrondir      ? 100.83
euro inferieur       : 100.000000
euro le plus proche  : 101.000000
quart le plus proche : 100.750000

[1] La première question est comment « tronquer » un flottant (c.-à-d. lui enlever les chiffres après la virgule) pour en faire l'entier immédiatement en-dessous. Or, c'est exactement l'opération qui est faite automatiquement lorsqu'un flottant est affecté à un entier, d'où le programme proposé. Les deux autres questions se ramènent chacune à sa précédente :

  • l'entier le plus proche de p est l'entier inférieur à p0.5 (remarque cryptée : cela marche ici, mais ce n'est pas la meilleure manière de trouver la borne téléphonique la plus proche quand on est en panne sur l'autoroute!)
  • le quart d'entier le plus proche serait l'entier le plus proche dans un monde où tous les nombres seraient quatre fois plus grands (bonjour la métaphore...)

La conversion qui est faite lors d'une affectation à un entier est la même que celle que fait l'opérateur (int). Une écriture plus légère de notre programme :

    ...
    arrInf = (int) prix;
    printf("euro inferieur       : %f\n", arrInf);
    
    arrProche = (int)(prix + 0.5);
    printf("euro le plus proche  : %f\n", arrProche);
    
    arrQuart = (int)(4 * prix + 0.5) / 4.0;
    printf("quart le plus proche : %f\n", arrQuart);
    ...

[2] Notez qu'il n'est pas possible (faites des essais) d'obtenir le travail souhaité en agissant au niveau de printf (en essayant de « tromper » printf on n'obtient jamais rien de sensé) :

printf("euro inferieur : %d\n", prix); Résultat imprévisible

[3] Remarquez l'expression

arrQuart = i / 4.0;

Il est indispensable que le dénominateur soit un nombre flottant. Si on avait écrit cette expression sous la forme

arrQuart = i / 4; Attention, erreur !

le membre droit de l'affectation aurait exprimé un quotient par défaut (cf. exercice 3), ce qui ne nous arrange pas car on aurait perdu les deux chiffres après la virgule (002550 ou 75).

Exercice 2

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
30
31
32
33
#include 
#include    /* à cause de sqrt */

float a, b, c, delta, x1, x2;

main() {
   printf("a b c ?\n");
    scanf("%f%f%f", &a, &b, &c);

    if (a != 0) {
        delta = b * b - 4 * a * c;
        if (delta > 0) {
            x1 = ( - b + sqrt(delta) ) / (2 * a);
            x2 = - b / a - x1;
           printf("deux solutions : %f et %f\n", x1, x2);
        } 
        else
            if (delta == 0)
               printf("solution double : %f\n", - b / (2 * a));
            else
               printf("pas de solution réelle\n");
    }
    else
        if (b != 0)
           printf("solution unique : %f\n", -c / b);
        else
            if (c != 0)
               printf("equation impossible\n");
            else
               printf("equation vide\n");
}
Un grand classique des exercices pour débutant. Sans commentaire.