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

Photo en By-Nc-Sa par MatStace
, par
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
Corrigés
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 :
- double x;
- /* trichons un peu */
- x = 2.718281828459045235360287;
À 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 :
Pouvez-vous en donner l’expression mathématique ?
Définir une fonction :
- 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
- #include <stdlib.h>
- #include <stdio.h>
- #include <time.h>
- /* Declarations de types et fonctions utilisateur */
- #define TRUE 1
- #define FALSE 0
- #define JOUEUR 1
- #define OPPOSANT 0
- struct tablette_s
- {
- int l; /* largeur */
- int h; /* hauteur */
- };
- /* Declaration de fonction utilisateur */
- int nombre_aleatoire(int n);
- int choix_utilisateur(int a, int b);
- void afficher_tablette(struct tablette_s choco);
- int partie_perdue(struct tablette_s choco);
- struct tablette_s joueur(struct tablette_s choco);
- struct tablette_s opposant(struct tablette_s choco);
- int main()
- {
- struct tablette_s choco = {8, 5}; /* miam */
- int tour = JOUEUR;
- /* Initialisation */
- /* Tour de jeu */
- while (!partie_perdue(choco))
- {
- afficher_tablette(choco);
- if (tour == JOUEUR) /* Au joueur de jouer */
- {
- choco = joueur(choco);
- tour = OPPOSANT;
- }
- else /* A l'opposant de jouer */
- {
- choco = opposant(choco);
- tour = JOUEUR;
- }
- }
- /* La partie est finie, le gagnant est ... */
- if (tour == JOUEUR) /* L'opposant gagne */
- {
- }
- else /* le joueur gagne */
- {
- }
- return EXIT_SUCCESS;
- }
- int nombre_aleatoire(int n)
- {
- /* tirage du nombre secret */
- }
- void afficher_tablette(struct tablette_s choco)
- {
- int i;
- int j;
- for (i = 0; i < choco.h; i = i + 1)
- {
- for (j = 0; j < choco.l; j = j + 1)
- {
- if ( (i == choco.h - 1) && (j == 0) )
- {
- }
- else
- {
- }
- }
- }
- }
- int partie_perdue(struct tablette_s choco)
- {
- return (choco.l == 1)
- && (choco.h == 1);
- }
- struct tablette_s joueur(struct tablette_s choco)
- {
- char c = ' '; /* colonne ou ligne */
- int n; /* croque croque */
- /* Choix entre colonnes et lignes */
- if ( (choco.l > 1) && (choco.h > 1) )
- {
- while ( ! ((c == 'c') || (c == 'C') || (c == 'l') || (c == 'L')) )
- {
- }
- }
- if (choco.l == 1)
- {
- c = 'l';
- }
- if (choco.h == 1)
- {
- c = 'c';
- }
- /* Croquer */
- if ( (c == 'c') || (c == 'C') ) /* croquer des colonnes */
- {
- n = choix_utilisateur(1, choco.l - 1);
- choco.l = choco.l - n;
- }
- if ( (c == 'l') || (c == 'L') ) /* croquer des lignes */
- {
- n = choix_utilisateur(1, choco.h - 1);
- choco.h = choco.h - n;
- }
- return choco;
- }
- struct tablette_s opposant(struct tablette_s choco)
- {
- int cote; /* 1 ligne, 0 colonne */
- /* Cet opposant choisit au hasard le côté */
- if ((choco.h > 1) && (choco.l > 1))
- {
- cote = nombre_aleatoire(1);
- }
- if (choco.h == 1)
- {
- cote = 1;
- }
- if (choco.l == 1)
- {
- cote = 0;
- }
- /* Mais il joue intelligement son coup ensuite, lorsque c'est possible */
- if (cote == 1) /* croquer ligne */
- {
- if (choco.h > choco.l)
- { /* on peut rendre une tablette carrée */
- choco.h = choco.l;
- }
- else
- { /* sinon on joue au hasard */
- choco.h = nombre_aleatoire(choco.h - 2) + 1;
- }
- }
- if (cote == 0) /* croquer colonne */
- {
- if (choco.l > choco.h)
- { /* on peut rendre une tablette carrée */
- choco.l = choco.h;
- }
- else
- { /* sinon on joue au hasard */
- choco.l = nombre_aleatoire(choco.l - 2) + 2;
- }
- }
- return choco;
- }
- int choix_utilisateur(int a, int b)
- {
- int compteur = 5; /* compteur du nombre d'essais */
- int choix; /* choix de l'utilisateur */
- while ((compteur > 0) && ((choix < a) || (choix > b)))
- {
- compteur = compteur - 1;
- }
- if (compteur == 0)
- {
- choix = a;
- }
- return choix;
- }