TD/TP 1 en C : 20 exercices et 3 questions de cours corrigés

Rappel des notions utiles

Une chaîne entre guillemets est affichée littéralement, sauf les séquences comme \n. Une entrée au clavier n’est pas connue avant l’exécution : les programmes c à f n’ont donc pas une sortie numérique unique. Un if choisit un seul de ses deux blocs.

À revoir dans les cours : Structure d’un programme C · Entrées et sorties : printf et scanf · Types de données · Structures de contrôle : if et else · Constantes et littéraux.

Pour a et b, l’affichage est entièrement déterminé. Pour d, la sortie originale commence par Enter thre numbers puis sum=... sans nouvelle ligne imposée entre les deux. Pour e, elle commence par Enter the average puis Echec ou Succès. Pour f, elle commence par Enter the radius puis result=.... Les versions corrigées séparent proprement les invites et les résultats.

Version plus générale : 1a, Triangle d’étoiles

1a : Triangle d’étoiles : programme complet

#include <stdio.h>
int main(void) {
    printf("*****\n");
    printf("****\n");
    printf("***\n");
    printf("**\n");
    printf("*\n");
    return 0;
}

Sorties écran : 1a, Triangle d’étoiles

Exécution 1. L’affichage a cinq lignes de longueurs décroissantes ; aucune variable ne change.

*****
****
***
**
*

Version plus générale : 1b, Cadre tel qu’écrit

1b : Cadre tel qu’écrit : programme complet

#include <stdio.h>
int main(void) {
    printf("*****\n");
    printf("*      *\n");
    printf("*      *\n");
    printf("*      *\n");
    printf("*****\n");
    return 0;
}

Sorties écran : 1b, Cadre tel qu’écrit

Exécution 1. Les deux bordures ne couvrent pas la largeur intérieure. Pour un carré de largeur 5, il faudrait trois espaces entre les étoiles.

*****
*      *
*      *
*      *
*****

Version simple (naïve) : 1c, Maximum, version corrigée

#include <stdio.h>
#include <math.h>

int main(void) {
    float a, b, max;
    puts("Entrer a b :");
    scanf("%f %f", &a, &b);
    if (a < b) {
        max = b;
    } else {
        max = a;
    }
    printf("maximum =%f\n", max);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : 1c, Maximum, version corrigée - version simple

Exécution 1. Le deuxième nombre est le plus grand.

Entrer a b :
2.5 7.25
maximum =7.250000

Exécution 2. Le bloc else affecte a à max.

Entrer a b :
8 3
maximum =8.000000

Exécution 3. L’égalité suit else sans changer la réponse.

Entrer a b :
4 4
maximum =4.000000

Version plus générale : 1c, Maximum, version corrigée

1c : Maximum, version corrigée : programme complet

#include <stdio.h>
#include <math.h>

int main(void) {
    float a, b, max;
    puts("Entrer a b :");
    if (scanf("%f %f", &a, &b) != 2) {
        puts("Saisie invalide.");
        return 1;
    }
    if (!isfinite(a) || fabs(a) > 1000000.0 || !isfinite(b) || fabs(b) > 1000000.0) {
        puts("Valeur hors domaine.");
        return 1;
    }
    if (a < b) {
        max = b;
    } else {
        max = a;
    }
    printf("maximum =%f\n", max);
    return 0;
}

Sorties écran : 1c, Maximum, version corrigée

Exécution 1. Le deuxième nombre est le plus grand.

Entrer a b :
2.5 7.25
maximum =7.250000

Exécution 2. Le bloc else affecte a à max.

Entrer a b :
8 3
maximum =8.000000

Exécution 3. L’égalité suit else sans changer la réponse.

Entrer a b :
4 4
maximum =4.000000

Exécution 4. Aucune conversion numérique n’a réussi.

Entrer a b :
abc
Saisie invalide.

Version simple (naïve) : 1d, Somme de trois réels

#include <stdio.h>
#include <math.h>

int main(void) {
    float a, b, c, sum;
    puts("Entrer a b c :");
    scanf("%f %f %f", &a, &b, &c);
    sum = a + b + c;
    printf("sum=%f\n", sum);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : 1d, Somme de trois réels - version simple

Exécution 1. 1.5 + 2.25 + 3 = 6.75.

Entrer a b c :
1.5 2.25 3
sum=6.750000

Exécution 2. Les termes se compensent.

Entrer a b c :
-2 1 1
sum=0.000000

Version plus générale : 1d, Somme de trois réels

1d : Somme de trois réels : programme complet

#include <stdio.h>
#include <math.h>

int main(void) {
    float a, b, c, sum;
    puts("Entrer a b c :");
    if (scanf("%f %f %f", &a, &b, &c) != 3) {
        puts("Saisie invalide.");
        return 1;
    }
    if (!isfinite(a) || fabs(a) > 1000000.0 || !isfinite(b) || fabs(b) > 1000000.0 || !isfinite(c) || fabs(c) > 1000000.0) {
        puts("Valeur hors domaine.");
        return 1;
    }
    sum = a + b + c;
    printf("sum=%f\n", sum);
    return 0;
}

Sorties écran : 1d, Somme de trois réels

Exécution 1. 1.5 + 2.25 + 3 = 6.75.

Entrer a b c :
1.5 2.25 3
sum=6.750000

Exécution 2. Les termes se compensent.

Entrer a b c :
-2 1 1
sum=0.000000

Version simple (naïve) : 1e, Réussite et seuil

#include <stdio.h>
#include <math.h>
#define TEN 10

int main(void) {
    float moyenne;
    puts("Entrer moyenne :");
    scanf("%f", &moyenne);
    if (moyenne < TEN) {
        puts("Echec");
    } else {
        puts("Succes");
    }
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : 1e, Réussite et seuil - version simple

Exécution 1. 9.5 < 10 est vrai.

Entrer moyenne :
9.5
Echec

Exécution 2. 10 < 10 est faux : le seuil est inclus dans le succès.

Entrer moyenne :
10
Succes

Exécution 3. Le bloc else est exécuté.

Entrer moyenne :
15
Succes

Version plus générale : 1e, Réussite et seuil

1e : Réussite et seuil : programme complet

#include <stdio.h>
#include <math.h>
#define TEN 10

int main(void) {
    float moyenne;
    puts("Entrer moyenne :");
    if (scanf("%f", &moyenne) != 1) {
        puts("Saisie invalide.");
        return 1;
    }
    if (!isfinite(moyenne) || fabs(moyenne) > 1000000.0) {
        puts("Valeur hors domaine.");
        return 1;
    }
    if (moyenne < TEN) {
        puts("Echec");
    } else {
        puts("Succes");
    }
    return 0;
}

Sorties écran : 1e, Réussite et seuil

Exécution 1. 9.5 < 10 est vrai.

Entrer moyenne :
9.5
Echec

Exécution 2. 10 < 10 est faux : le seuil est inclus dans le succès.

Entrer moyenne :
10
Succes

Exécution 3. Le bloc else est exécuté.

Entrer moyenne :
15
Succes

Version simple (naïve) : 1f, Aire d’un disque

#include <stdio.h>
#include <math.h>
#define PI 3.14

int main(void) {
    float r, s;
    puts("Entrer r :");
    scanf("%f", &r);
    s = r * r * PI;
    printf("result=%f\n", s);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : 1f, Aire d’un disque - version simple

Exécution 1. Aire = 3.14 × 2 × 2, arrondie à six décimales.

Entrer r :
2
result=12.560000

Exécution 2. Un rayon nul donne une aire nulle.

Entrer r :
0
result=0.000000

Version plus générale : 1f, Aire d’un disque

1f : Aire d’un disque : programme complet

#include <stdio.h>
#include <math.h>
#define PI 3.14

int main(void) {
    float r, s;
    puts("Entrer r :");
    if (scanf("%f", &r) != 1) {
        puts("Saisie invalide.");
        return 1;
    }
    if (!isfinite(r) || fabs(r) > 1000000.0) {
        puts("Valeur hors domaine.");
        return 1;
    }
    if (r < 0.0f) {
        puts("Rayon invalide.");
        return 1;
    }
    s = r * r * PI;
    printf("result=%f\n", s);
    return 0;
}

Sorties écran : 1f, Aire d’un disque

Exécution 1. Aire = 3.14 × 2 × 2, arrondie à six décimales.

Entrer r :
2
result=12.560000

Exécution 2. Un rayon nul donne une aire nulle.

Entrer r :
0
result=0.000000

Exécution 3. La garde arrête le programme.

Entrer r :
-1
Rayon invalide.

Rappel des notions utiles

La valeur absolue mesure la distance à zéro : |n| = n si n ≥ 0 et |n| = −n si n < 0. Toutefois, sur les machines usuelles, INT_MIN n’a pas d’opposé représentable dans int. Une correction complète doit traiter ce cas sans faire déborder le type signé.

À revoir dans les cours : Types de données · Structures de contrôle : if et else · Variables et affectation.

Le schéma naïf if (n < 0) n = -n; suffit sur de petites valeurs, mais ne couvre pas tout le domaine de int. Ne pas supposer que abs(INT_MIN) résout le problème : l’opposé reste non représentable. La valeur numérique d’INT_MIN dépend de l’implémentation ; le programme ci-dessous ne la code pas en dur.

Version simple (naïve) : Valeur absolue sans débordement signé

#include <stdio.h>

int main(void) {
    int n;
    puts("Entrer n :");
    scanf("%d", &n);
    if (n < 0) { n = -n; }
    printf("Valeur absolue = %d\n", n);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Valeur absolue sans débordement signé - version simple

Exécution 1. La branche négative construit 7.

Entrer n :
-7
Valeur absolue = 7

Exécution 2. Zéro est déjà positif ou nul.

Entrer n :
0
Valeur absolue = 0

Exécution 3. La branche else recopie 12.

Entrer n :
12
Valeur absolue = 12

Version plus générale : Valeur absolue sans débordement signé

Valeur absolue sans débordement signé : programme complet

#include <stdio.h>

int main(void) {
    int n;
    unsigned int magnitude;
    puts("Entrer n :");
    if (scanf("%d", &n) != 1) {
        puts("Saisie invalide.");
        return 1;
    }
    if (n < 0) {
        magnitude = (unsigned int)(-(n + 1)) + 1U;
    } else {
        magnitude = (unsigned int)n;
    }
    printf("Valeur absolue = %u\n", magnitude);
    return 0;
}

Sorties écran : Valeur absolue sans débordement signé

Exécution 1. La branche négative construit 7.

Entrer n :
-7
Valeur absolue = 7

Exécution 2. Zéro est déjà positif ou nul.

Entrer n :
0
Valeur absolue = 0

Exécution 3. La branche else recopie 12.

Entrer n :
12
Valeur absolue = 12

Exécution 4. Cas INT_MIN sur l’environnement testé à int 32 bits ; le résultat dépasse INT_MAX.

Entrer n :
-2147483648
Valeur absolue = 2147483648

Rappel des notions utiles

Une formule mathématique doit être traduite avec des opérandes de types adaptés. En C, 4 / 3 divise deux entiers et donne 1. 4.0 / 3.0 effectue la division réelle attendue. La multiplication s’écrit explicitement *.

À revoir dans les cours : Types de données · Entrées et sorties : printf et scanf · Constantes et littéraux.

L’unité est celle du rayon au cube : un rayon en centimètres donne un volume en cm³. On écrit r*r*r, et non r^3 : ^ est un opérateur binaire de ou exclusif sur les entiers, pas une puissance.

Version simple (naïve) : Volume de la sphère

#include <stdio.h>
#include <math.h>

int main(void) {
    double r, volume;
    const double pi = 3.141592653589793;
    puts("Entrer r :");
    scanf("%lf", &r);
    volume = (4.0 / 3.0) * pi * r * r * r;
    printf("Volume = %.6f\n", volume);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Volume de la sphère - version simple

Exécution 1. Le cube de 2 vaut 8 ; le volume vaut 32π/3.

Entrer r :
2
Volume = 33.510322

Exécution 2. Le produit contient un facteur nul.

Entrer r :
0
Volume = 0.000000

Version plus générale : Volume de la sphère

Volume de la sphère : programme complet

#include <stdio.h>
#include <math.h>

int main(void) {
    double r, volume;
    const double pi = 3.141592653589793;
    puts("Entrer r :");
    if (scanf("%lf", &r) != 1) {
        puts("Saisie invalide.");
        return 1;
    }
    if (!isfinite(r) || fabs(r) > 1000000.0) {
        puts("Valeur hors domaine.");
        return 1;
    }
    if (r < 0.0) {
        puts("Rayon invalide.");
        return 1;
    }
    volume = (4.0 / 3.0) * pi * r * r * r;
    printf("Volume = %.6f\n", volume);
    return 0;
}

Sorties écran : Volume de la sphère

Exécution 1. Le cube de 2 vaut 8 ; le volume vaut 32π/3.

Entrer r :
2
Volume = 33.510322

Exécution 2. Le produit contient un facteur nul.

Entrer r :
0
Volume = 0.000000

Exécution 3. Le rayon géométrique est refusé.

Entrer r :
-2
Rayon invalide.

Rappel des notions utiles

Les parenthèses doivent conserver la soustraction avant le changement d’échelle. Ici aussi, 5/9 entre entiers donne 0 : toute conversion serait alors fausse. On emploie 5.0/9.0. Une température négative est une donnée normale.

À revoir dans les cours : Types de données · Variables et affectation · Entrées et sorties : printf et scanf.

Un test qui n’utilise que TF=32 ne détecterait pas l’erreur 5/9, puisque le bon résultat est également zéro. TF=212 est donc un meilleur cas de vérification complémentaire.

Version simple (naïve) : Conversion de température

#include <stdio.h>
#include <math.h>

int main(void) {
    double tf, tc;
    puts("Entrer tf :");
    scanf("%lf", &tf);
    tc = (5.0 / 9.0) * (tf - 32.0);
    printf("Celsius = %.6f\n", tc);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Conversion de température - version simple

Exécution 1. 212−32=180 puis 180×5/9=100.

Entrer tf :
212
Celsius = 100.000000

Exécution 2. C’est le point où la différence vaut zéro.

Entrer tf :
32
Celsius = 0.000000

Exécution 3. −72×5/9=−40.

Entrer tf :
-40
Celsius = -40.000000

Version plus générale : Conversion de température

Conversion de température : programme complet

#include <stdio.h>
#include <math.h>

int main(void) {
    double tf, tc;
    puts("Entrer tf :");
    if (scanf("%lf", &tf) != 1) {
        puts("Saisie invalide.");
        return 1;
    }
    if (!isfinite(tf) || fabs(tf) > 1000000.0) {
        puts("Valeur hors domaine.");
        return 1;
    }
    tc = (5.0 / 9.0) * (tf - 32.0);
    printf("Celsius = %.6f\n", tc);
    return 0;
}

Sorties écran : Conversion de température

Exécution 1. 212−32=180 puis 180×5/9=100.

Entrer tf :
212
Celsius = 100.000000

Exécution 2. C’est le point où la différence vaut zéro.

Entrer tf :
32
Celsius = 0.000000

Exécution 3. −72×5/9=−40.

Entrer tf :
-40
Celsius = -40.000000

Rappel des notions utiles

Une fonction mathématique associe une valeur à chaque entrée de son domaine. Il n’est pas nécessaire d’écrire une fonction C distincte pour calculer ici son image : une expression puis une affectation suffisent.

À revoir dans les cours : Variables et affectation · Types de données · Les bases du langage C.

On peut vérifier l’algèbre avec f(x)=(x+1)². Les deux expressions sont mathématiquement égales ; des calculs flottants peuvent néanmoins arrondir différemment. Le programme conserve la forme demandée par le sujet.

Version simple (naïve) : Calcul de f(x)

#include <stdio.h>
#include <math.h>

int main(void) {
    double x, image;
    puts("Entrer x :");
    scanf("%lf", &x);
    image = x * x + 2.0 * x + 1.0;
    printf("f(x) = %.6f\n", image);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Calcul de f(x) - version simple

Exécution 1. 9−6+1=4.

Entrer x :
-3
f(x) = 4.000000

Exécution 2. 0+0+1=1.

Entrer x :
0
f(x) = 1.000000

Exécution 3. 1−2+1=0.

Entrer x :
-1
f(x) = 0.000000

Version plus générale : Calcul de f(x)

Calcul de f(x) : programme complet

#include <stdio.h>
#include <math.h>

int main(void) {
    double x, image;
    puts("Entrer x :");
    if (scanf("%lf", &x) != 1) {
        puts("Saisie invalide.");
        return 1;
    }
    if (!isfinite(x) || fabs(x) > 1000000.0) {
        puts("Valeur hors domaine.");
        return 1;
    }
    image = x * x + 2.0 * x + 1.0;
    printf("f(x) = %.6f\n", image);
    return 0;
}

Sorties écran : Calcul de f(x)

Exécution 1. 9−6+1=4.

Entrer x :
-3
f(x) = 4.000000

Exécution 2. 0+0+1=1.

Entrer x :
0
f(x) = 1.000000

Exécution 3. 1−2+1=0.

Entrer x :
-1
f(x) = 0.000000

Rappel des notions utiles

Les trois domaines sont disjoints et couvrent tous les réels. Un enchaînement if / else if / else garantit qu’un seul calcul sera exécuté. Les valeurs de frontière 4 et 40 doivent suivre le morceau central.

À revoir dans les cours : Structures de contrôle : if et else · Les bases du langage C · Types de données.

Version simple (naïve) : Évaluer h(x)

#include <stdio.h>
#include <math.h>

int main(void) {
    double x, image;
    puts("Entrer x :");
    scanf("%lf", &x);
    if (x < 4.0) {
        image = x * x + 2.0 * x + 1.0;
    } else if (x <= 40.0) {
        image = x * x;
    } else {
        image = x + 1.0;
    }
    printf("h(x) = %.6f\n", image);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Évaluer h(x) - version simple

Exécution 1. Premier morceau.

Entrer x :
3
h(x) = 16.000000

Exécution 2. Borne inférieure incluse dans le deuxième morceau.

Entrer x :
4
h(x) = 16.000000

Exécution 3. Borne supérieure également incluse.

Entrer x :
40
h(x) = 1600.000000

Exécution 4. Troisième morceau.

Entrer x :
41
h(x) = 42.000000

Version plus générale : Évaluer h(x)

Évaluer h(x) : programme complet

#include <stdio.h>
#include <math.h>

int main(void) {
    double x, image;
    puts("Entrer x :");
    if (scanf("%lf", &x) != 1) {
        puts("Saisie invalide.");
        return 1;
    }
    if (!isfinite(x) || fabs(x) > 1000000.0) {
        puts("Valeur hors domaine.");
        return 1;
    }
    if (x < 4.0) {
        image = x * x + 2.0 * x + 1.0;
    } else if (x <= 40.0) {
        image = x * x;
    } else {
        image = x + 1.0;
    }
    printf("h(x) = %.6f\n", image);
    return 0;
}

Sorties écran : Évaluer h(x)

Exécution 1. Premier morceau.

Entrer x :
3
h(x) = 16.000000

Exécution 2. Borne inférieure incluse dans le deuxième morceau.

Entrer x :
4
h(x) = 16.000000

Exécution 3. Borne supérieure également incluse.

Entrer x :
40
h(x) = 1600.000000

Exécution 4. Troisième morceau.

Entrer x :
41
h(x) = 42.000000

Rappel des notions utiles

Deux variables doivent être lues et leur lecture doit réussir avant le calcul. Les produits implicites de l’écriture mathématique deviennent des * explicites. La valeur de g est scalaire : on affiche un résultat, même si l’entrée contient deux nombres.

À revoir dans les cours : Entrées et sorties : printf et scanf · Variables et affectation · Types de données.

Le signe du terme croisé dépend des signes de x et y. Par exemple x=2 et y=−2 ne donnent pas 17 : le produit 2xy vaut −8. Ce cas vérifie que l’on n’a pas oublié le terme croisé.

Version simple (naïve) : Calcul de g(x,y)

#include <stdio.h>
#include <math.h>

int main(void) {
    double x, y, image;
    puts("Entrer x y :");
    scanf("%lf %lf", &x, &y);
    image = x * x + y * y + 2.0 * x * y + 1.0;
    printf("g(x,y) = %.6f\n", image);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Calcul de g(x,y) - version simple

Exécution 1. 4+9+12+1=26.

Entrer x y :
2 3
g(x,y) = 26.000000

Exécution 2. 4+4−8+1=1.

Entrer x y :
2 -2
g(x,y) = 1.000000

Exécution 3. Seul le terme constant reste.

Entrer x y :
0 0
g(x,y) = 1.000000

Version plus générale : Calcul de g(x,y)

Calcul de g(x,y) : programme complet

#include <stdio.h>
#include <math.h>

int main(void) {
    double x, y, image;
    puts("Entrer x y :");
    if (scanf("%lf %lf", &x, &y) != 2) {
        puts("Saisie invalide.");
        return 1;
    }
    if (!isfinite(x) || fabs(x) > 1000000.0 || !isfinite(y) || fabs(y) > 1000000.0) {
        puts("Valeur hors domaine.");
        return 1;
    }
    image = x * x + y * y + 2.0 * x * y + 1.0;
    printf("g(x,y) = %.6f\n", image);
    return 0;
}

Sorties écran : Calcul de g(x,y)

Exécution 1. 4+9+12+1=26.

Entrer x y :
2 3
g(x,y) = 26.000000

Exécution 2. 4+4−8+1=1.

Entrer x y :
2 -2
g(x,y) = 1.000000

Exécution 3. Seul le terme constant reste.

Entrer x y :
0 0
g(x,y) = 1.000000

Rappel des notions utiles

Un prix unitaire multiplié par une quantité donne un prix total. Les unités se simplifient : (FCFA/km) × km = FCFA. Le prix et la distance peuvent être décimaux ; on choisit donc double. Une distance ou un prix négatif est refusé.

À revoir dans les cours : Types de données · Entrées et sorties : printf et scanf · Structures de contrôle : if et else.

Version simple (naïve) : Coût total

#include <stdio.h>
#include <math.h>

int main(void) {
    double prix_km, distance, cout;
    puts("Entrer prix_km distance :");
    scanf("%lf %lf", &prix_km, &distance);
    cout = prix_km * distance;
    printf("Cout total = %.2f FCFA\n", cout);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Coût total - version simple

Exécution 1. Le résultat correct de l’exemple est 30 000, pas 3 000.

Entrer prix_km distance :
150 200
Cout total = 30000.00 FCFA

Exécution 2. 3 000 correspondrait à 20 km.

Entrer prix_km distance :
150 20
Cout total = 3000.00 FCFA

Exécution 3. Aucune distance parcourue.

Entrer prix_km distance :
150 0
Cout total = 0.00 FCFA

Version plus générale : Coût total

Coût total : programme complet

#include <stdio.h>
#include <math.h>

int main(void) {
    double prix_km, distance, cout;
    puts("Entrer prix_km distance :");
    if (scanf("%lf %lf", &prix_km, &distance) != 2) {
        puts("Saisie invalide.");
        return 1;
    }
    if (!isfinite(prix_km) || fabs(prix_km) > 1000000.0 || !isfinite(distance) || fabs(distance) > 1000000.0) {
        puts("Valeur hors domaine.");
        return 1;
    }
    if (prix_km < 0.0 || distance < 0.0) {
        puts("Prix ou distance invalide.");
        return 1;
    }
    cout = prix_km * distance;
    printf("Cout total = %.2f FCFA\n", cout);
    return 0;
}

Sorties écran : Coût total

Exécution 1. Le résultat correct de l’exemple est 30 000, pas 3 000.

Entrer prix_km distance :
150 200
Cout total = 30000.00 FCFA

Exécution 2. 3 000 correspondrait à 20 km.

Entrer prix_km distance :
150 20
Cout total = 3000.00 FCFA

Exécution 3. Aucune distance parcourue.

Entrer prix_km distance :
150 0
Cout total = 0.00 FCFA

Exécution 4. Le prix est négatif.

Entrer prix_km distance :
-1 200
Prix ou distance invalide.

Rappel des notions utiles

Le maximum provisoire doit commencer par une valeur réellement lue, pas par zéro. Sinon trois valeurs négatives pourraient donner à tort un maximum nul. Le même principe vaut pour le minimum. La moyenne arithmétique est la somme divisée par le nombre de valeurs.

À revoir dans les cours : Variables et affectation · Structures de contrôle : if et else · Types de données.

L’invariant utile est le suivant : après chaque comparaison, maximum est le plus grand des nombres déjà examinés et minimum le plus petit. C’est la même idée que l’on retrouvera plus tard pour parcourir un tableau.

Version simple (naïve) : Trois statistiques

#include <stdio.h>
#include <math.h>

int main(void) {
    double a, b, c, maximum, minimum, moyenne;
    puts("Entrer a b c :");
    scanf("%lf %lf %lf", &a, &b, &c);
    maximum = a;
    minimum = a;
    if (b > maximum) { maximum = b; }
    if (c > maximum) { maximum = c; }
    if (b < minimum) { minimum = b; }
    if (c < minimum) { minimum = c; }
    moyenne = (a + b + c) / 3.0;
    printf("Maximum = %.6f\n", maximum);
    printf("Minimum = %.6f\n", minimum);
    printf("Moyenne = %.6f\n", moyenne);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Trois statistiques - version simple

Exécution 1. Trace détaillée : maximum reste 8 ; minimum devient −2.

Entrer a b c :
8 -2 5
Maximum = 8.000000
Minimum = -2.000000
Moyenne = 3.666667

Exécution 2. Trois entrées négatives : initialiser à zéro aurait été incorrect.

Entrer a b c :
-7 -2 -9
Maximum = -2.000000
Minimum = -9.000000
Moyenne = -6.000000

Exécution 3. Les égalités ne nécessitent aucune mise à jour.

Entrer a b c :
4 4 4
Maximum = 4.000000
Minimum = 4.000000
Moyenne = 4.000000

Version plus générale : Trois statistiques

Trois statistiques : programme complet

#include <stdio.h>
#include <math.h>

int main(void) {
    double a, b, c, maximum, minimum, moyenne;
    puts("Entrer a b c :");
    if (scanf("%lf %lf %lf", &a, &b, &c) != 3) {
        puts("Saisie invalide.");
        return 1;
    }
    if (!isfinite(a) || fabs(a) > 1000000.0 || !isfinite(b) || fabs(b) > 1000000.0 || !isfinite(c) || fabs(c) > 1000000.0) {
        puts("Valeur hors domaine.");
        return 1;
    }
    maximum = a;
    minimum = a;
    if (b > maximum) { maximum = b; }
    if (c > maximum) { maximum = c; }
    if (b < minimum) { minimum = b; }
    if (c < minimum) { minimum = c; }
    moyenne = (a + b + c) / 3.0;
    printf("Maximum = %.6f\n", maximum);
    printf("Minimum = %.6f\n", minimum);
    printf("Moyenne = %.6f\n", moyenne);
    return 0;
}

Sorties écran : Trois statistiques

Exécution 1. Trace détaillée : maximum reste 8 ; minimum devient −2.

Entrer a b c :
8 -2 5
Maximum = 8.000000
Minimum = -2.000000
Moyenne = 3.666667

Exécution 2. Trois entrées négatives : initialiser à zéro aurait été incorrect.

Entrer a b c :
-7 -2 -9
Maximum = -2.000000
Minimum = -9.000000
Moyenne = -6.000000

Exécution 3. Les égalités ne nécessitent aucune mise à jour.

Entrer a b c :
4 4 4
Maximum = 4.000000
Minimum = 4.000000
Moyenne = 4.000000

Rappel des notions utiles

Un entier est pair s’il est divisible par 2, donc si son reste modulo 2 vaut zéro. L’opérateur C % calcule un reste entier. Il ne faut pas le confondre avec le signe de pourcentage dans un format printf.

À revoir dans les cours : Structures de contrôle : if et else · Types de données · Les bases du langage C.

Ce programme accepte tout entier représentable dans int, y compris le plus petit. Il ne prend pas l’opposé de n et ne risque donc pas le débordement rencontré dans une valeur absolue naïve.

Version simple (naïve) : Pair ou impair

#include <stdio.h>

int main(void) {
    int n;
    puts("Entrer n :");
    scanf("%d", &n);
    if (n % 2 == 0) {
        puts("Pair");
    } else {
        puts("Impair");
    }
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Pair ou impair - version simple

Exécution 1. 14=2×7.

Entrer n :
14
Pair

Exécution 2. Le reste est 1.

Entrer n :
15
Impair

Exécution 3. Le reste vaut −1 et n’est pas nul.

Entrer n :
-3
Impair

Exécution 4. 0=2×0.

Entrer n :
0
Pair

Version plus générale : Pair ou impair

Pair ou impair : programme complet

#include <stdio.h>

int main(void) {
    int n;
    puts("Entrer n :");
    if (scanf("%d", &n) != 1) {
        puts("Saisie invalide.");
        return 1;
    }
    if (n % 2 == 0) {
        puts("Pair");
    } else {
        puts("Impair");
    }
    return 0;
}

Sorties écran : Pair ou impair

Exécution 1. 14=2×7.

Entrer n :
14
Pair

Exécution 2. Le reste est 1.

Entrer n :
15
Impair

Exécution 3. Le reste vaut −1 et n’est pas nul.

Entrer n :
-3
Impair

Exécution 4. 0=2×0.

Entrer n :
0
Pair

Rappel des notions utiles

La notation [a,b[ inclut a et exclut b. Une chaîne de tests croissants permet de représenter ces intervalles sans répéter les deux bornes. On considère une moyenne sur 20, donc les valeurs hors de [0,20] sont refusées.

À revoir dans les cours : Structures de contrôle : if et else · Entrées et sorties : printf et scanf · Types de données.

Une suite de six if indépendants utilisant seulement moyenne < seuil pourrait afficher plusieurs mentions. La chaîne else if s’arrête après la première catégorie satisfaite.

Version simple (naïve) : Mention sur 20

#include <stdio.h>
#include <math.h>

int main(void) {
    double moyenne;
    puts("Entrer moyenne :");
    scanf("%lf", &moyenne);
    if (moyenne < 10.0) {
        puts("Mediocre");
    } else if (moyenne < 12.0) {
        puts("Passable");
    } else if (moyenne < 14.0) {
        puts("Assez bien");
    } else if (moyenne < 16.0) {
        puts("Bien");
    } else if (moyenne < 18.0) {
        puts("Tres bien");
    } else {
        puts("Excellent");
    }
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Mention sur 20 - version simple

Exécution 1. 9.5 < 10.

Entrer moyenne :
9.5
Mediocre

Exécution 2. 10 est inclus dans [10,12[.

Entrer moyenne :
10
Passable

Exécution 3. 12 n’appartient plus à l’intervalle précédent.

Entrer moyenne :
12
Assez bien

Exécution 4. Début de [14,16[.

Entrer moyenne :
14
Bien

Exécution 5. Début de [16,18[.

Entrer moyenne :
16
Tres bien

Exécution 6. Début de [18,20].

Entrer moyenne :
18
Excellent

Exécution 7. 20 est inclus dans la dernière mention.

Entrer moyenne :
20
Excellent

Version plus générale : Mention sur 20

Mention sur 20 : programme complet

#include <stdio.h>
#include <math.h>

int main(void) {
    double moyenne;
    puts("Entrer moyenne :");
    if (scanf("%lf", &moyenne) != 1) {
        puts("Saisie invalide.");
        return 1;
    }
    if (!isfinite(moyenne) || fabs(moyenne) > 1000000.0) {
        puts("Valeur hors domaine.");
        return 1;
    }
    if (moyenne < 0.0 || moyenne > 20.0) {
        puts("Moyenne invalide.");
        return 1;
    }
    if (moyenne < 10.0) {
        puts("Mediocre");
    } else if (moyenne < 12.0) {
        puts("Passable");
    } else if (moyenne < 14.0) {
        puts("Assez bien");
    } else if (moyenne < 16.0) {
        puts("Bien");
    } else if (moyenne < 18.0) {
        puts("Tres bien");
    } else {
        puts("Excellent");
    }
    return 0;
}

Sorties écran : Mention sur 20

Exécution 1. 9.5 < 10.

Entrer moyenne :
9.5
Mediocre

Exécution 2. 10 est inclus dans [10,12[.

Entrer moyenne :
10
Passable

Exécution 3. 12 n’appartient plus à l’intervalle précédent.

Entrer moyenne :
12
Assez bien

Exécution 4. Début de [14,16[.

Entrer moyenne :
14
Bien

Exécution 5. Début de [16,18[.

Entrer moyenne :
16
Tres bien

Exécution 6. Début de [18,20].

Entrer moyenne :
18
Excellent

Exécution 7. 20 est inclus dans la dernière mention.

Entrer moyenne :
20
Excellent

Exécution 8. Hors de l’échelle sur 20.

Entrer moyenne :
20.1
Moyenne invalide.

Exécution 9. La moyenne ne peut pas être négative.

Entrer moyenne :
-1
Moyenne invalide.

Rappel des notions utiles

La divisibilité se teste avec le reste : annee % 4 == 0. && signifie et, || signifie ou, != signifie différent. Les parenthèses rendent la règle lisible. Le programme applique la règle grégorienne fournie à une année entière strictement positive.

À revoir dans les cours : Structures de contrôle : if et else · Les bases du langage C · Types de données.

Écrire seulement annee % 4 == 0 donne une mauvaise réponse pour 2100. La branche des siècles est donc indispensable.

Version simple (naïve) : Année bissextile

#include <stdio.h>

int main(void) {
    int annee;
    puts("Entrer annee :");
    scanf("%d", &annee);
    if (annee % 400 == 0 ||
        (annee % 4 == 0 && annee % 100 != 0)) {
        puts("Bissextile");
    } else {
        puts("Non bissextile");
    }
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Année bissextile - version simple

Exécution 1. 1901 % 4 = 1.

Entrer annee :
1901
Non bissextile

Exécution 2. Divisible par 4, pas par 100.

Entrer annee :
2004
Bissextile

Exécution 3. Divisible par 100 mais pas par 400.

Entrer annee :
2100
Non bissextile

Exécution 4. Divisible par 400.

Entrer annee :
2000
Bissextile

Version plus générale : Année bissextile

Année bissextile : programme complet

#include <stdio.h>

int main(void) {
    int annee;
    puts("Entrer annee :");
    if (scanf("%d", &annee) != 1) {
        puts("Saisie invalide.");
        return 1;
    }
    if (annee <= 0) {
        puts("Annee invalide.");
        return 1;
    }
    if (annee % 400 == 0 ||
        (annee % 4 == 0 && annee % 100 != 0)) {
        puts("Bissextile");
    } else {
        puts("Non bissextile");
    }
    return 0;
}

Sorties écran : Année bissextile

Exécution 1. 1901 % 4 = 1.

Entrer annee :
1901
Non bissextile

Exécution 2. Divisible par 4, pas par 100.

Entrer annee :
2004
Bissextile

Exécution 3. Divisible par 100 mais pas par 400.

Entrer annee :
2100
Non bissextile

Exécution 4. Divisible par 400.

Entrer annee :
2000
Bissextile

Exécution 5. Le domaine choisi exclut zéro.

Entrer annee :
0
Annee invalide.

Rappel des notions utiles

Un switch choisit un bloc à partir de la valeur d’une expression entière. Chaque case correspond à une constante entière. break termine le switch ; sans lui, l’exécution continuerait dans les cases suivants.

À revoir dans les cours : Structures de contrôle : if et else · Constantes et littéraux · Types de données.

Une chaîne de if / else if conviendrait également. Ici, le switch exprime clairement une correspondance entre un petit ensemble de valeurs exactes et leurs libellés.

Version simple (naïve) : Un chiffre, un mot

#include <stdio.h>

int main(void) {
    int chiffre;
    puts("Entrer chiffre :");
    scanf("%d", &chiffre);
    switch (chiffre) {
        case 0: puts("zero"); break;
        case 1: puts("un"); break;
        case 2: puts("deux"); break;
        case 3: puts("trois"); break;
        case 4: puts("quatre"); break;
        case 5: puts("cinq"); break;
        case 6: puts("six"); break;
        case 7: puts("sept"); break;
        case 8: puts("huit"); break;
        case 9: puts("neuf"); break;
        default:
            puts("Chiffre invalide.");
            return 1;
    }
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Un chiffre, un mot - version simple

Exécution 1. case 9 est sélectionné.

Entrer chiffre :
9
neuf

Exécution 2. Le chiffre zéro fait bien partie du domaine.

Entrer chiffre :
0
zero

Version plus générale : Un chiffre, un mot

Un chiffre, un mot : programme complet

#include <stdio.h>

int main(void) {
    int chiffre;
    puts("Entrer chiffre :");
    if (scanf("%d", &chiffre) != 1) {
        puts("Saisie invalide.");
        return 1;
    }
    switch (chiffre) {
        case 0: puts("zero"); break;
        case 1: puts("un"); break;
        case 2: puts("deux"); break;
        case 3: puts("trois"); break;
        case 4: puts("quatre"); break;
        case 5: puts("cinq"); break;
        case 6: puts("six"); break;
        case 7: puts("sept"); break;
        case 8: puts("huit"); break;
        case 9: puts("neuf"); break;
        default:
            puts("Chiffre invalide.");
            return 1;
    }
    return 0;
}

Sorties écran : Un chiffre, un mot

Exécution 1. case 9 est sélectionné.

Entrer chiffre :
9
neuf

Exécution 2. Le chiffre zéro fait bien partie du domaine.

Entrer chiffre :
0
zero

Exécution 3. Aucun case ne correspond.

Entrer chiffre :
10
Chiffre invalide.

Rappel des notions utiles

On sépare la validation de la sélection. Les tests niveau < 1 et niveau > 9 éliminent les valeurs hors domaine ; le switch ne traite ensuite que les neuf niveaux autorisés.

À revoir dans les cours : Structures de contrôle : if et else · Entrées et sorties : printf et scanf · Constantes et littéraux.

Version simple (naïve) : Table de descriptions du sujet

#include <stdio.h>

int main(void) {
    int niveau;
    puts("Entrer niveau :");
    scanf("%d", &niveau);
    switch (niveau) {
        case 1: puts("Micro tremblement de terre, non ressenti"); break;
        case 2: puts("Tres mineur, non ressenti mais detecte"); break;
        case 3: puts("Mineur, causant rarement des dommages"); break;
        case 4: puts("Leger, secousses notables d'objets a l'interieur des maisons"); break;
        case 5: puts("Modere, legers dommages aux edifices bien construits"); break;
        case 6: puts("Fort, destructeur jusqu'a 180 kilometres a la ronde si les zones sont peuplees"); break;
        case 7: puts("Majeur, dommages moderes a severes dans des zones plus vastes"); break;
        case 8: puts("Important, dommages serieux a des centaines de kilometres a la ronde"); break;
        case 9: puts("Devastateur, dommages sur des milliers de kilometres a la ronde"); break;
    }
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Table de descriptions du sujet - version simple

Exécution 1. Premier niveau du tableau.

Entrer niveau :
1
Micro tremblement de terre, non ressenti

Exécution 2. Le case 6 est le seul exécuté.

Entrer niveau :
6
Fort, destructeur jusqu'a 180 kilometres a la ronde si les zones sont peuplees

Exécution 3. Dernier niveau autorisé.

Entrer niveau :
9
Devastateur, dommages sur des milliers de kilometres a la ronde

Version plus générale : Table de descriptions du sujet

Table de descriptions du sujet : programme complet

#include <stdio.h>

int main(void) {
    int niveau;
    puts("Entrer niveau :");
    if (scanf("%d", &niveau) != 1) {
        puts("Saisie invalide.");
        return 1;
    }
    if (niveau < 1) {
        puts("Erreur de saisie : niveau inferieur a 1.");
        return 1;
    }
    if (niveau > 9) {
        puts("Apocalypse (libelle du TD) : niveau superieur a 9.");
        return 1;
    }
    switch (niveau) {
        case 1: puts("Micro tremblement de terre, non ressenti"); break;
        case 2: puts("Tres mineur, non ressenti mais detecte"); break;
        case 3: puts("Mineur, causant rarement des dommages"); break;
        case 4: puts("Leger, secousses notables d'objets a l'interieur des maisons"); break;
        case 5: puts("Modere, legers dommages aux edifices bien construits"); break;
        case 6: puts("Fort, destructeur jusqu'a 180 kilometres a la ronde si les zones sont peuplees"); break;
        case 7: puts("Majeur, dommages moderes a severes dans des zones plus vastes"); break;
        case 8: puts("Important, dommages serieux a des centaines de kilometres a la ronde"); break;
        case 9: puts("Devastateur, dommages sur des milliers de kilometres a la ronde"); break;
    }
    return 0;
}

Sorties écran : Table de descriptions du sujet

Exécution 1. Premier niveau du tableau.

Entrer niveau :
1
Micro tremblement de terre, non ressenti

Exécution 2. Le case 6 est le seul exécuté.

Entrer niveau :
6
Fort, destructeur jusqu'a 180 kilometres a la ronde si les zones sont peuplees

Exécution 3. Dernier niveau autorisé.

Entrer niveau :
9
Devastateur, dommages sur des milliers de kilometres a la ronde

Exécution 4. Première garde.

Entrer niveau :
0
Erreur de saisie : niveau inferieur a 1.

Exécution 5. Deuxième garde ; libellé de l’exercice.

Entrer niveau :
10
Apocalypse (libelle du TD) : niveau superieur a 9.

Rappel des notions utiles

Une affectation copie une valeur vers la variable située à gauche. Elle n’établit pas une égalité permanente entre deux variables. Pour échanger deux contenus, il faut conserver l’ancien a avant de l’écraser. Une variable temporaire est le moyen le plus lisible.

À revoir dans les cours : Variables et affectation · Types de données · Les bases du langage C.

Version simple (naïve) : Échange avec une variable temporaire

#include <stdio.h>

int main(void) {
    int a, b, temporaire;
    puts("Entrer a b :");
    scanf("%d %d", &a, &b);
    temporaire = a;
    a = b;
    b = temporaire;
    printf("a = %d, b = %d\n", a, b);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Échange avec une variable temporaire - version simple

Exécution 1. Trois copies conservent les deux valeurs initiales.

Entrer a b :
3 8
a = 8, b = 3

Exécution 2. Les signes n’affectent pas la méthode.

Entrer a b :
-2 5
a = 5, b = -2

Exécution 3. L’échange de deux valeurs égales ne produit aucun changement visible.

Entrer a b :
4 4
a = 4, b = 4

Version plus générale : Échange avec une variable temporaire

Échange avec une variable temporaire : programme complet

#include <stdio.h>

int main(void) {
    int a, b, temporaire;
    puts("Entrer a b :");
    if (scanf("%d %d", &a, &b) != 2) {
        puts("Saisie invalide.");
        return 1;
    }
    temporaire = a;
    a = b;
    b = temporaire;
    printf("a = %d, b = %d\n", a, b);
    return 0;
}

Sorties écran : Échange avec une variable temporaire

Exécution 1. Trois copies conservent les deux valeurs initiales.

Entrer a b :
3 8
a = 8, b = 3

Exécution 2. Les signes n’affectent pas la méthode.

Entrer a b :
-2 5
a = 5, b = -2

Exécution 3. L’échange de deux valeurs égales ne produit aucun changement visible.

Entrer a b :
4 4
a = 4, b = 4

Rappel des notions utiles

On doit examiner le coefficient de x avant de diviser. Si a vaut zéro, l’équation ne dépend plus de x : elle devient b=0. La solution est recherchée dans les réels.

À revoir dans les cours : Structures de contrôle : if et else · Types de données · Entrées et sorties : printf et scanf.

Le test exact à zéro est adapté ici aux coefficients explicitement saisis comme zéro. Une application numérique alimentée par des mesures ou des calculs devrait choisir une stratégie de tolérance et d’échelle ; remplacer arbitrairement tout petit coefficient par zéro changerait le problème posé. Les exemples visent des coefficients courants et non des valeurs proches des limites du type double.

Version simple (naïve) : Équation du premier degré

#include <stdio.h>

int main(void) {
    double a, b, x;
    puts("Entrer a b :");
    scanf("%lf %lf", &a, &b);
    x = -b / a;
    printf("x = %.6f\n", x);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Équation du premier degré - version simple

Exécution 1. La seule solution est 3.

Entrer a b :
2 -6
x = 3.000000

Exécution 2. Le seul réel vérifiant −4x=0 est zéro.

Entrer a b :
-4 0
x = 0.000000

Version plus générale : Équation du premier degré

Équation du premier degré : programme complet

#include <stdio.h>
#include <math.h>

int main(void) {
    double a, b, x;
    puts("Entrer a b :");
    if (scanf("%lf %lf", &a, &b) != 2) {
        puts("Saisie invalide.");
        return 1;
    }
    if (!isfinite(a) || fabs(a) > 1000000.0 || !isfinite(b) || fabs(b) > 1000000.0) {
        puts("Valeur hors domaine.");
        return 1;
    }
    if (a == 0.0) {
        if (b == 0.0) {
            puts("Infinite de solutions reelles.");
        } else {
            puts("Aucune solution reelle.");
        }
    } else {
        x = -b / a;
        printf("x = %.6f\n", x);
    }
    return 0;
}

Sorties écran : Équation du premier degré

Exécution 1. La seule solution est 3.

Entrer a b :
2 -6
x = 3.000000

Exécution 2. L’équation est toujours vraie.

Entrer a b :
0 0
Infinite de solutions reelles.

Exécution 3. L’équation est toujours fausse.

Entrer a b :
0 5
Aucune solution reelle.

Exécution 4. Le seul réel vérifiant −4x=0 est zéro.

Entrer a b :
-4 0
x = 0.000000

Rappel des notions utiles

Les formules quadratiques supposent a≠0. Si a=0, on retombe sur bx+c=0, même si le titre dit « deuxième degré ». Pour a≠0 et Δ≥0, la racine carrée est définie dans les réels ; sqrt est déclarée dans math.h.

À revoir dans les cours : Structures de contrôle : if et else · Types de données · Structure d’un programme C.

Version simple (naïve) : Tous les cas de l’équation

#include <stdio.h>
#include <math.h>

int main(void) {
    double a, b, c, delta, x1, x2;
    puts("Entrer a b c :");
    scanf("%lf %lf %lf", &a, &b, &c);
    delta = b * b - 4.0 * a * c;
    printf("Delta = %.6f\n", delta);
    if (delta < 0.0) {
        puts("Aucune solution reelle.");
    } else if (delta == 0.0) {
        x1 = -b / (2.0 * a);
        printf("Racine double = %.6f\n", x1);
    } else {
        x1 = (-b - sqrt(delta)) / (2.0 * a);
        x2 = (-b + sqrt(delta)) / (2.0 * a);
        printf("x1 = %.6f\nx2 = %.6f\n", x1, x2);
    }
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Tous les cas de l’équation - version simple

Exécution 1. Cas D, Δ<0 : pas de solution dans R.

Entrer a b c :
1 0 1
Delta = -4.000000
Aucune solution reelle.

Exécution 2. Cas D, Δ=0.

Entrer a b c :
1 -2 1
Delta = 0.000000
Racine double = 1.000000

Exécution 3. Cas D, Δ>0.

Entrer a b c :
1 -3 2
Delta = 1.000000
x1 = 1.000000
x2 = 2.000000

Version plus générale : Tous les cas de l’équation

Tous les cas de l’équation : programme complet

#include <stdio.h>
#include <math.h>

int main(void) {
    double a, b, c, delta, x1, x2;
    puts("Entrer a b c :");
    if (scanf("%lf %lf %lf", &a, &b, &c) != 3) {
        puts("Saisie invalide.");
        return 1;
    }
    if (!isfinite(a) || fabs(a) > 1000000.0 || !isfinite(b) || fabs(b) > 1000000.0 || !isfinite(c) || fabs(c) > 1000000.0) {
        puts("Valeur hors domaine.");
        return 1;
    }
    if (a == 0.0) {
        if (b == 0.0) {
            if (c == 0.0) {
                puts("Infinite de solutions reelles.");
            } else {
                puts("Aucune solution reelle.");
            }
        } else {
            x1 = -c / b;
            printf("x = %.6f\n", x1);
        }
    } else {
        delta = b * b - 4.0 * a * c;
        printf("Delta = %.6f\n", delta);
        if (delta < 0.0) {
            puts("Aucune solution reelle.");
        } else if (delta == 0.0) {
            x1 = -b / (2.0 * a);
            printf("Racine double = %.6f\n", x1);
        } else {
            x1 = (-b - sqrt(delta)) / (2.0 * a);
            x2 = (-b + sqrt(delta)) / (2.0 * a);
            printf("x1 = %.6f\nx2 = %.6f\n", x1, x2);
        }
    }
    return 0;
}

Sorties écran : Tous les cas de l’équation

Exécution 1. Cas A : tout réel convient.

Entrer a b c :
0 0 0
Infinite de solutions reelles.

Exécution 2. Cas B : 2=0 est impossible.

Entrer a b c :
0 0 2
Aucune solution reelle.

Exécution 3. Cas C : 2x−6=0.

Entrer a b c :
0 2 -6
x = 3.000000

Exécution 4. Cas D, Δ<0 : pas de solution dans R.

Entrer a b c :
1 0 1
Delta = -4.000000
Aucune solution reelle.

Exécution 5. Cas D, Δ=0.

Entrer a b c :
1 -2 1
Delta = 0.000000
Racine double = 1.000000

Exécution 6. Cas D, Δ>0.

Entrer a b c :
1 -3 2
Delta = 1.000000
x1 = 1.000000
x2 = 2.000000

Rappel des notions utiles

Un opérateur lu au clavier est stocké dans un char. On peut l’utiliser dans un switch avec des constantes caractères comme '+'. Le caractère est lu après les nombres : le retour à la ligne restant dans le flux doit être ignoré.

À revoir dans les cours : Entrées et sorties : printf et scanf · Structures de contrôle : if et else · Constantes et littéraux.

Le signe * doit être tapé pendant l’exécution. Si l’on transmet des entrées par un terminal ou un script, attention aux caractères spéciaux du shell : une entrée standard contenant 14 10 * évite d’interpréter l’étoile comme un motif de fichiers. Le programme attend un seul caractère opérateur et n’est pas un analyseur d’expressions complètes comme 2+3*4.

Version simple (naïve) : Calculatrice à quatre opérations

#include <stdio.h>
#include <math.h>

int main(void) {
    double a, b, resultat;
    char op;
    puts("Entrer a b :");
    scanf("%lf %lf", &a, &b);
    puts("Entrer un operateur :");
    scanf(" %c", &op);
    switch (op) {
        case '+': resultat = a + b; break;
        case '-': resultat = a - b; break;
        case '*': resultat = a * b; break;
        case '/':
            resultat = a / b;
            break;
        default:
            puts("Operateur invalide.");
            return 1;
    }
    printf("Resultat = %.6f\n", resultat);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Calculatrice à quatre opérations - version simple

Exécution 1. Produit de l’exemple du sujet.

Entrer a b :
14 10
Entrer un operateur :
*
Resultat = 140.000000

Exécution 2. Somme de l’exemple.

Entrer a b :
14 20
Entrer un operateur :
+
Resultat = 34.000000

Exécution 3. La soustraction conserve l’ordre a−b.

Entrer a b :
14 20
Entrer un operateur :
-
Resultat = -6.000000

Exécution 4. Division réelle, pas division entière.

Entrer a b :
5 2
Entrer un operateur :
/
Resultat = 2.500000

Version plus générale : Calculatrice à quatre opérations

Calculatrice à quatre opérations : programme complet

#include <stdio.h>
#include <math.h>

int main(void) {
    double a, b, resultat;
    char op;
    puts("Entrer a b :");
    if (scanf("%lf %lf", &a, &b) != 2) {
        puts("Saisie invalide.");
        return 1;
    }
    if (!isfinite(a) || fabs(a) > 1000000.0 || !isfinite(b) || fabs(b) > 1000000.0) {
        puts("Valeur hors domaine.");
        return 1;
    }
    puts("Entrer un operateur :");
    if (scanf(" %c", &op) != 1) {
        puts("Saisie invalide.");
        return 1;
    }
    switch (op) {
        case '+': resultat = a + b; break;
        case '-': resultat = a - b; break;
        case '*': resultat = a * b; break;
        case '/':
            if (b == 0.0) {
                puts("Division par zero interdite.");
                return 1;
            }
            resultat = a / b;
            break;
        default:
            puts("Operateur invalide.");
            return 1;
    }
    printf("Resultat = %.6f\n", resultat);
    return 0;
}

Sorties écran : Calculatrice à quatre opérations

Exécution 1. Produit de l’exemple du sujet.

Entrer a b :
14 10
Entrer un operateur :
*
Resultat = 140.000000

Exécution 2. Somme de l’exemple.

Entrer a b :
14 20
Entrer un operateur :
+
Resultat = 34.000000

Exécution 3. La soustraction conserve l’ordre a−b.

Entrer a b :
14 20
Entrer un operateur :
-
Resultat = -6.000000

Exécution 4. Division réelle, pas division entière.

Entrer a b :
5 2
Entrer un operateur :
/
Resultat = 2.500000

Exécution 5. La garde est exécutée avant a/b.

Entrer a b :
5 0
Entrer un operateur :
/
Division par zero interdite.

Exécution 6. Aucun case n’accepte %.

Entrer a b :
2 3
Entrer un operateur :
%
Operateur invalide.

Rappel des notions utiles

Avant de programmer une règle, son domaine et ses frontières doivent être définis. Le texte ne dit pas ce qui arrive exactement à 1 000 points et ne précise pas si les tarifs s’appliquent à tous les points ou seulement par tranches. Il n’existe donc pas de réponse unique sans une hypothèse explicite.

À revoir dans les cours : Structures de contrôle : if et else · Types de données · Variables et affectation.

Version simple (naïve) : Hypothèse A, un tarif pour tous les points

#include <stdio.h>

int main(void) {
    long long points, salaire;
    puts("Entrer points :");
    scanf("%lld", &points);
    if (points <= 1000) {
        salaire = points * 3000LL;
    } else {
        salaire = points * 2500LL;
    }
    printf("Salaire = %lld F\n", salaire);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Hypothèse A, un tarif pour tous les points - version simple

Exécution 1. 800 points au tarif global de 3 000 F.

Entrer points :
800
Salaire = 2400000 F

Exécution 2. Le seuil est inclus dans le premier tarif par convention.

Entrer points :
1000
Salaire = 3000000 F

Exécution 3. Tous les points passent à 2 500 F : cette règle crée une baisse au seuil.

Entrer points :
1001
Salaire = 2502500 F

Exécution 4. 1 200×2 500.

Entrer points :
1200
Salaire = 3000000 F

Version plus générale : Hypothèse A, un tarif pour tous les points

Hypothèse A : un tarif pour tous les points : programme complet

#include <stdio.h>

int main(void) {
    long long points, salaire;
    puts("Entrer points :");
    if (scanf("%lld", &points) != 1) {
        puts("Saisie invalide.");
        return 1;
    }
    if (points < 0 || points > 1000000) {
        puts("Nombre de points invalide.");
        return 1;
    }
    if (points <= 1000) {
        salaire = points * 3000LL;
    } else {
        salaire = points * 2500LL;
    }
    printf("Salaire = %lld F\n", salaire);
    return 0;
}

Sorties écran : Hypothèse A, un tarif pour tous les points

Exécution 1. 800 points au tarif global de 3 000 F.

Entrer points :
800
Salaire = 2400000 F

Exécution 2. Le seuil est inclus dans le premier tarif par convention.

Entrer points :
1000
Salaire = 3000000 F

Exécution 3. Tous les points passent à 2 500 F : cette règle crée une baisse au seuil.

Entrer points :
1001
Salaire = 2502500 F

Exécution 4. 1 200×2 500.

Entrer points :
1200
Salaire = 3000000 F

Exécution 5. Les points négatifs sont refusés.

Entrer points :
-1
Nombre de points invalide.

Version simple (naïve) : Hypothèse B, tarification par tranches

#include <stdio.h>

int main(void) {
    long long points, salaire;
    puts("Entrer points :");
    scanf("%lld", &points);
    if (points <= 1000) {
        salaire = points * 3000LL;
    } else {
        salaire = 1000LL * 3000LL + (points - 1000LL) * 2500LL;
    }
    printf("Salaire = %lld F\n", salaire);
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Hypothèse B, tarification par tranches - version simple

Exécution 1. Première tranche uniquement.

Entrer points :
800
Salaire = 2400000 F

Exécution 2. La première tranche est pleine.

Entrer points :
1000
Salaire = 3000000 F

Exécution 3. Un seul point supplémentaire à 2 500 F.

Entrer points :
1001
Salaire = 3002500 F

Exécution 4. 3 000 000 pour la première tranche +500 000 pour la seconde.

Entrer points :
1200
Salaire = 3500000 F

Version plus générale : Hypothèse B, tarification par tranches

Hypothèse B : tarification par tranches : programme complet

#include <stdio.h>

int main(void) {
    long long points, salaire;
    puts("Entrer points :");
    if (scanf("%lld", &points) != 1) {
        puts("Saisie invalide.");
        return 1;
    }
    if (points < 0 || points > 1000000) {
        puts("Nombre de points invalide.");
        return 1;
    }
    if (points <= 1000) {
        salaire = points * 3000LL;
    } else {
        salaire = 1000LL * 3000LL + (points - 1000LL) * 2500LL;
    }
    printf("Salaire = %lld F\n", salaire);
    return 0;
}

Sorties écran : Hypothèse B, tarification par tranches

Exécution 1. Première tranche uniquement.

Entrer points :
800
Salaire = 2400000 F

Exécution 2. La première tranche est pleine.

Entrer points :
1000
Salaire = 3000000 F

Exécution 3. Un seul point supplémentaire à 2 500 F.

Entrer points :
1001
Salaire = 3002500 F

Exécution 4. 3 000 000 pour la première tranche +500 000 pour la seconde.

Entrer points :
1200
Salaire = 3500000 F

Rappel des notions utiles

Un réel x appartient aux deux intervalles si A≤x≤B et C≤x≤D. Il doit donc être au moins égal à max(A,C) et au plus égal à min(B,D). Les intervalles sont fermés : leurs extrémités sont incluses.

À revoir dans les cours : Structures de contrôle : if et else · Variables et affectation · Les bases du langage C.

L’opérateur ?: n’est pas obligatoire : on peut obtenir gauche avec gauche=A; if(C>gauche) gauche=C; et droite avec droite=B; if(D<droite) droite=D;. Les deux méthodes comparent des valeurs ; elles n’ont pas besoin d’additionner les bornes, donc évitent un débordement arithmétique inutile.

Version simple (naïve) : Intersection d’intervalles fermés

#include <stdio.h>

int main(void) {
    int A, B, C, D, gauche, droite;
    puts("Entrer A B C D :");
    scanf("%d %d %d %d", &A, &B, &C, &D);
    gauche = (A > C) ? A : C;
    droite = (B < D) ? B : D;
    if (gauche < droite) {
        printf("Intersection = [%d, %d]\n", gauche, droite);
    } else if (gauche == droite) {
        printf("Intersection = {%d}\n", gauche);
    } else {
        puts("Intersection vide.");
    }
    return 0;
}

Lecture du code simple : les déclarations donnent les variables nécessaires ; scanf remplit ces variables sans vérifier son résultat ; les instructions suivantes effectuent le calcul ou choisissent la branche. Les tableaux de la version générale, plus bas, détaillent le même coeur de calcul et les évolutions des valeurs. Les cas exclus par les hypothèses ne doivent pas etre testes avec cette version.

Sorties écran : Intersection d’intervalles fermés - version simple

Exécution 1. max(1,3)=3 ; min(5,8)=5.

Entrer A B C D :
1 5 3 8
Intersection = [3, 5]

Exécution 2. Les deux intervalles se touchent en 3, qui est inclus.

Entrer A B C D :
1 3 3 7
Intersection = {3}

Exécution 3. gauche=3 > droite=2.

Entrer A B C D :
1 2 3 4
Intersection vide.

Exécution 4. Le deuxième intervalle est inclus dans le premier.

Entrer A B C D :
2 8 3 4
Intersection = [3, 4]

Exécution 5. Deux singletons identiques.

Entrer A B C D :
2 2 2 2
Intersection = {2}

Version plus générale : Intersection d’intervalles fermés

Intersection d’intervalles fermés : programme complet

#include <stdio.h>

int main(void) {
    int A, B, C, D, gauche, droite;
    puts("Entrer A B C D :");
    if (scanf("%d %d %d %d", &A, &B, &C, &D) != 4) {
        puts("Saisie invalide.");
        return 1;
    }
    if (A > B || C > D) {
        puts("Intervalle invalide.");
        return 1;
    }
    gauche = (A > C) ? A : C;
    droite = (B < D) ? B : D;
    if (gauche < droite) {
        printf("Intersection = [%d, %d]\n", gauche, droite);
    } else if (gauche == droite) {
        printf("Intersection = {%d}\n", gauche);
    } else {
        puts("Intersection vide.");
    }
    return 0;
}

Sorties écran : Intersection d’intervalles fermés

Exécution 1. max(1,3)=3 ; min(5,8)=5.

Entrer A B C D :
1 5 3 8
Intersection = [3, 5]

Exécution 2. Les deux intervalles se touchent en 3, qui est inclus.

Entrer A B C D :
1 3 3 7
Intersection = {3}

Exécution 3. gauche=3 > droite=2.

Entrer A B C D :
1 2 3 4
Intersection vide.

Exécution 4. Le deuxième intervalle est inclus dans le premier.

Entrer A B C D :
2 8 3 4
Intersection = [3, 4]

Exécution 5. Deux singletons identiques.

Entrer A B C D :
2 2 2 2
Intersection = {2}

Exécution 6. Les bornes A et B sont inversées.

Entrer A B C D :
5 1 2 8
Intervalle invalide.

Rappel des notions utiles

En C, l’apparence d’un symbole ne suffit pas à déterminer son type. Les délimiteurs font partie de la syntaxe. Une constante caractère ordinaire telle que '1' a le type int en C, même si elle sert souvent à initialiser un char. Une chaîne littérale ordinaire a un type tableau de char, avec un élément nul final.

À revoir dans les cours : Types de données · Constantes et littéraux.

Dans beaucoup d’expressions, un tableau est converti en pointeur vers son premier élément. Cela n’en fait pas le type initial du littéral : "jean" a bien le type char[5], même si son utilisation dans un appel fournit souvent un char *. L’opérateur sizeof fait partie des cas où cette conversion n’a pas lieu.

Le code du caractère '1' est souvent 49 dans un environnement ASCII, mais on n’a pas besoin de supposer ASCII pour répondre : il faut distinguer le caractère chiffre et l’entier 1. Une chaîne littérale ne doit pas être modifiée, même si son type en C n’est pas un tableau de const char.

Observer les tailles sans supposer la taille d’int : programme complet

#include <stdio.h>

int main(void) {
    printf("'1' a la taille de int : %d\n",
           sizeof('1') == sizeof(int));
    printf("Taille de \"1\" = %zu\n", sizeof("1"));
    printf("Taille de \"1234\" = %zu\n", sizeof("1234"));
    printf("Taille de \"jean\" = %zu\n", sizeof("jean"));
    return 0;
}

Sorties écran : Observer les tailles sans supposer la taille d’int

Exécution 1. sizeof sur un littéral chaîne mesure le tableau complet, y compris son nul final.

'1' a la taille de int : 1
Taille de "1" = 2
Taille de "1234" = 5
Taille de "jean" = 5

Rappel des notions utiles

Les apostrophes simples délimitent une constante caractère ; les guillemets doubles délimitent une chaîne. Il faut distinguer une constante, son type et la variable qui la reçoit. char lettre = 'j'; déclare une variable char initialisée à partir d’une constante de type int.

À revoir dans les cours : Constantes et littéraux · Types de données · Variables et affectation.

Pour stocker une chaîne modifiable, écrire par exemple char nom[] = "jean"; : le tableau possède cinq éléments et reçoit une copie des lettres et du nul final. Pour pointer vers le littéral sans chercher à le modifier, écrire const char *nom = "jean";. Un unique char ne peut pas contenir les quatre lettres et le terminateur.

Les exemples de syntaxe ci-dessus sont des déclarations isolées pour comparer les notions ; le programme complet de la question 1 permet de vérifier les tailles. On n’exécute pas une valeur multicaractère pour la présenter comme universelle.

Rappel des notions utiles

++i augmente i puis produit la nouvelle valeur ; i++ produit l’ancienne valeur et augmente i comme effet de bord. Quand ces expressions se trouvent seules dans des instructions successives, leur effet est simple à suivre. Cela ne permet pas de modifier i plusieurs fois sans séquencement dans une même expression.

À revoir dans les cours : Les bases du langage C · Variables et affectation · Types de données.

Le tableau de préfixe décrit les instructions bien définies considérées sans la dernière ligne. Si l’on conserve la ligne au comportement indéfini dans le programme complet, le langage ne garantit pas son comportement global. La bonne correction consiste à signaler ce défaut, puis à proposer une autre suite d’instructions qui impose l’intention souhaitée. Les deux programmes ci-dessous ne contiennent aucune expression indéfinie.

Préfixe bien défini, sans la dernière instruction : programme complet

#include <stdio.h>

int main(void) {
    int i = 4;
    int x, y;
    x = 4 + ++i;
    y = 4 + i++;
    printf("x = %d, y = %d, i = %d\n", x, y, i);
    return 0;
}

Sorties écran : Préfixe bien défini, sans la dernière instruction

Exécution 1. Ce résultat appartient au préfixe isolé, qui ne contient pas l’expression indéfinie.

x = 9, y = 9, i = 6

Une réécriture explicitement séquencée : programme complet

#include <stdio.h>

int main(void) {
    int i = 4;
    int x, y, z, gauche, droite;
    x = 4 + ++i;
    y = 4 + i++;
    ++i;
    gauche = i;
    droite = i;
    ++i;
    z = gauche + droite;
    printf("x = %d, y = %d, z = %d, i = %d\n", x, y, z, i);
    return 0;
}

Sorties écran : Une réécriture explicitement séquencée

Exécution 1. La réécriture impose un séquencement ; son résultat est défini.

x = 9, y = 9, z = 14, i = 8