Exercices 07, (08), 09, 10 (TD et TP)

Photo en By-Nc-Sa par MatStace

, par Pierre

Sujets d’exercices de travaux dirigés et travaux pratiques en éléments d’informatique, semaines 07 à 10. Pas de sujet semaine 08 (correction du partiel). Corrigés des TD 07 et 09.

Sujets

TD 07 TP 07 EI
TD 09 (et TP 09) EI
TD 10 TP 10 EI

Corrigés

Corrigé du TD7 EI
Corrigé TD/TP 9 EI

Exercices complémentaires (à essayer en travaux pratiques

- Nombres parfaits.
On dit d’un entier n qu’il est parfait lorsque la somme de ses diviseurs (1 et n inclus) est égale à 2n. Par exemple, 8 n’est pas parfait car la somme de ses diviseurs 1+2+4+8 = 15 et non 16. Quel nombre plus petit que 10 est parfait ?

Ajouter à votre menu une entrée sur le modèle de 1) Tester si un nombre est premier qui demande à l’utilisateur d’entrer un nombre et détermine s’il est parfait (écrire une fonction est_parfait).

- Constante de Néper
La constante de Néper e vérifie l’égalité :
$$ e = \sum^\infty_0 \frac{1}{i!}. $$

En vous limitant à quelques premiers termes de cette somme, il est possible d’obtenir une bonne valeur approchée de e.
ècrire un programme qui demande à l’utilisateur d’entrer un entier n et calcule une valeur approchée de e en effectuant la somme des n premiers termes de la suite.
Pour afficher un double x avec une précision plus importante, au lieu de "%g" utiliser le format "%.17g" (qui signifie que l’on souhaite afficher x avec 16 chiffres décimaux après la virgule — n’oubliez pas le point avant 17 !).

Exemple :

  1. double x;
  2. /* trichons un peu */
  3. x = 2.718281828459045235360287;
  4. printf("%.17g", x); /* faux a la 16e decimale */

Télécharger

À partir de quelle valeur de n atteignez vous la précision maximale que l’on peut obtenir avec un double ?

- Intégration par la méthode des rectangle.
Soit la fonction f suivante, utilisant la bibliothèque math :

  1. double f(double x)
  2. {
  3.     return exp(-pow(x,2.0));
  4. }

Télécharger

Pouvez-vous en donner l’expression mathématique ?

Définir une fonction :

  1. double integration_rectangles(double a, double b, int n);

qui calcule une valeur approchée de l’intégrale :
$$ \int^b_a e^{-x^2} dx $$
par la méthode des rectangles, en utilisant n rectangles. La tester sur l’intervalle [-1000, 1000], avec un million de rectangles. Le résultat doit être proche de racine carrée de pi (sqrt(M_PI)).

Corrigé du TP 10

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <time.h>
  4.  
  5. /* Declarations de types et fonctions utilisateur */
  6. #define TRUE 1
  7. #define FALSE 0
  8.  
  9. #define JOUEUR 1
  10. #define OPPOSANT 0
  11.  
  12. struct tablette_s
  13. {
  14.     int l; /* largeur */
  15.     int h; /* hauteur */
  16. };
  17.  
  18. /* Declaration de fonction utilisateur */
  19. int nombre_aleatoire(int n);
  20. int choix_utilisateur(int a, int b);
  21. void afficher_tablette(struct tablette_s choco);
  22. int partie_perdue(struct tablette_s choco);
  23. struct tablette_s joueur(struct tablette_s choco);
  24. struct tablette_s opposant(struct tablette_s choco);
  25.  
  26.  
  27. int main()
  28. {
  29.     struct tablette_s choco = {8, 5}; /* miam */
  30.     int tour = JOUEUR;
  31.  
  32.     /* Initialisation */
  33.     srand(time(NULL)); /* à ne faire qu'une fois */
  34.  
  35.     /* Tour de jeu */
  36.     while (!partie_perdue(choco))
  37.     {
  38.         afficher_tablette(choco);
  39.         if (tour == JOUEUR) /* Au joueur de jouer */
  40.         {
  41.             choco = joueur(choco);
  42.             tour = OPPOSANT;
  43.         }
  44.         else /* A l'opposant de jouer */
  45.         {
  46.             printf("Opposant joue\n");
  47.             choco = opposant(choco);
  48.             tour = JOUEUR;
  49.         }
  50.     }
  51.     /* La partie est finie, le gagnant est ... */
  52.     if (tour == JOUEUR) /* L'opposant gagne */
  53.     {
  54.         printf("Perdu !\n");
  55.     }
  56.     else /* le joueur gagne */    
  57.     {
  58.         printf("Arghh, vous avez gagné\n");
  59.     }
  60.      
  61.     return EXIT_SUCCESS;
  62. }
  63.  
  64.  
  65.  
  66. int nombre_aleatoire(int n)
  67. {
  68.     /* tirage du nombre secret */
  69.     return rand() % (n + 1); /* entre 0 et n inclus */
  70. }
  71.  
  72. void afficher_tablette(struct tablette_s choco)
  73. {
  74.     int i;
  75.     int j;
  76.  
  77.     for (i = 0; i < choco.h; i = i + 1)
  78.     {
  79.         for (j = 0; j < choco.l; j = j + 1)
  80.         {
  81.             if ( (i == choco.h - 1) &&  (j == 0) )
  82.             {
  83.                 printf("X ");
  84.             }
  85.             else
  86.             {              
  87.                 printf("M ");
  88.             }
  89.         }
  90.         printf("\n");
  91.     }
  92. }
  93.  
  94. int partie_perdue(struct tablette_s choco)
  95. {
  96.     return (choco.l == 1)
  97.         && (choco.h == 1);
  98. }
  99.  
  100. struct tablette_s joueur(struct tablette_s choco)
  101. {
  102.     char c = ' '; /* colonne ou ligne */
  103.     int n; /* croque croque */
  104.  
  105.     /* Choix entre colonnes et lignes */
  106.     if ( (choco.l > 1) && (choco.h > 1) )
  107.     {
  108.         while ( ! ((c == 'c') || (c == 'C') || (c == 'l') || (c == 'L')) )
  109.         {
  110.             printf("Croquer des _C_olonnes ou des _L_ignes ? (entrer C ou L) : ");
  111.             scanf(" %c", &c); /* ne pas oublier l'espace avant %c */
  112.         }
  113.     }
  114.     if (choco.l == 1)
  115.     {
  116.         c = 'l';
  117.     }
  118.     if (choco.h == 1)
  119.     {
  120.         c = 'c';
  121.     }
  122.     /* Croquer */
  123.     if ( (c == 'c') || (c == 'C') ) /* croquer des colonnes */
  124.     {
  125.         printf("Combien de colonnes voulez vous croquer [1, %d] : ", choco.l - 1);
  126.         n = choix_utilisateur(1, choco.l - 1);
  127.         choco.l = choco.l - n;
  128.     }
  129.     if ( (c == 'l') || (c == 'L') ) /* croquer des lignes */
  130.     {
  131.         printf("Combien de lignes voulez vous croquer [1, %d] : ", choco.h - 1);
  132.         n = choix_utilisateur(1, choco.h - 1);
  133.         choco.h = choco.h - n;
  134.     }
  135.     return choco;
  136. }
  137.  
  138. struct tablette_s opposant(struct tablette_s choco)
  139. {
  140.     int cote; /* 1 ligne, 0 colonne */
  141.  
  142.     /* Cet opposant choisit au hasard le côté */
  143.     if ((choco.h > 1) && (choco.l > 1))
  144.     {
  145.         cote = nombre_aleatoire(1);
  146.     }
  147.     if (choco.h == 1)
  148.     {
  149.         cote = 1;
  150.     }
  151.     if (choco.l == 1)
  152.     {
  153.         cote = 0;
  154.     }
  155.  
  156.     /* Mais il joue intelligement son coup ensuite, lorsque c'est possible */
  157.     if (cote == 1) /* croquer ligne */
  158.     {
  159.         if (choco.h > choco.l)
  160.         { /* on peut rendre une tablette carrée */
  161.             choco.h = choco.l;
  162.         }
  163.         else
  164.         { /* sinon on joue au hasard */
  165.             choco.h = nombre_aleatoire(choco.h - 2) + 1;
  166.         }
  167.     }
  168.     if (cote == 0) /* croquer colonne */
  169.     {
  170.         if (choco.l > choco.h)
  171.         { /* on peut rendre une tablette carrée */
  172.             choco.l = choco.h;
  173.         }
  174.         else
  175.         { /* sinon on joue au hasard */
  176.             choco.l = nombre_aleatoire(choco.l - 2) + 2;
  177.         }
  178.     }
  179.     return choco;
  180. }
  181.  
  182. int choix_utilisateur(int a, int b)
  183. {
  184.    int compteur = 5; /* compteur du nombre d'essais */
  185.    int choix; /* choix de l'utilisateur */
  186.  
  187.    scanf("%d", &choix);
  188.    while ((compteur > 0) &&  ((choix < a) || (choix > b)))
  189.    {
  190.        printf("Le nombre doit etre entre %d et %d (inclus) : ", a, b);
  191.        scanf("%d", &choix);
  192.        compteur = compteur - 1;
  193.    }
  194.    if (compteur == 0)
  195.    {
  196.        choix = a;
  197.    }
  198.    return choix;
  199. }

Télécharger

Revenu et logement, Je livre ici quelques éléments de comparaison concernant mon niveau de vie, pour couper court à quelques idées reçues, et un condensé de nombreuses (...)
Revenu et travail d’un enseignant-chercheur, Cet article complète l'article Revenu et logement, en détaillant un peu le budget de mon ménage, mon parcours d'enseignant-chercheur en terme de (...)
Cybersyn (el systemo synco), Au café, mardi 5 avril 2011, j'ai bien vu que, mis à part Antoine Allombert, personne ne connaissait l'histoire de l'extraordinaire projet chilien (...) [jpg, jpg, png]