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

PDF - 204.6 ko
TD 07 TP 07 EI
PDF - 146.8 ko
TD 09 (et TP 09) EI
PDF - 279 ko
TD 10 TP 10 EI

Corrigés

PDF - 203.5 ko
Corrigé du TD7 EI
PDF - 252.5 ko
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]