You are on page 1of 24

Universit´ Paris 13 e Institut Galil´e e Ann´e universitaire 2008–2009 e

L1 Informatique Exercices corrig´s e

Exercices corrig´s e
17 f´vrier 2009 e
Dans chaque exercice nous proposons un programme toujours structur´ de e la mˆme mani`re (cependant certains ´l´ments ne sont pas toujours pr´sents) : e e ee e #include, #define, d´finitions de types, prototypes de fonctions ,variables gloe bales, fonction principale, et enfin d´finitions de fonctions. Cet ordre doit ˆtre e e consid´r´ comme obligatoire. De plus le programme contient des commentaires ee (/* ... */) et ` la fin un exemple d’ex´cution sous la forme ´galement d’un a e e commentaire (ici chaque ligne commence par //). Exercice 1 (Simple et double boucle.) 1. Ecrire un programme qui affiche la sortie suivante :
affiche affiche affiche affiche affiche affiche affiche affiche affiche affiche affiche 10 10 10 10 10 10 10 10 10 10 10 fois fois fois fois fois fois fois fois fois fois fois 1 2 3 4 5 6 7 8 9 10 11

2. Ajouter a ce programme les instructions n´cessaires pour que celui-ci af` e fiche les lignes suppl´mentaires suivantes : e
1 1 1 2 2 2 3 3 3 4 4 4 5 5 5 6 6 6 7 7 7 8 8 8 9 9 9 10 10 11 11 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5 6 6 6 7 7 7 8 8 8 9 9 9 10 10 11 11 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5 6 6 6 7 7 7 8 8 8 9 9 9 10 10 11 11 1 2 3 4 5 6 7 8 9 10 10 10 10 11 11 11 11

1

Exercice 2 (Sommes.) 1. Ecrire une programme qui affiche la somme des n premiers entiers naturels. La valeur de n est saisie au clavier lors de l’ex´cution. e 2. Ecrire un programme qui affiche la somme des entiers compris entre les entiers d et f . Les valeurs de d et f sont saisies au clavier lors de l’ex´cution. e 3. Ecrire une programme qui affiche la somme des valeurs absolues des entiers compris entre les entiers relatifs d et f . Les valeurs de d et f sont saisies au clavier lors de l’ex´cution. e 4. Ecrire une programme qui affiche la somme des valeurs absolues des entiers pairs compris entre les entiers relatifs d et f . Les valeurs de d et f sont saisies au clavier lors de l’ex´cution. e e Note : n%2 est l’expression C dont le r´sultat est le reste de la division par 2 de n.

Exercice 3 (Affichage d’un triangle isoc`le d’´toiles.) e e ´ Ecrire un programme qui, ´tant donn´ un entier naturel impair base, affiche e e un triangle isoc`le d’´toiles, ayant pour base, base ´toiles. La valeur de la base e e e sera saisie par l’utilisateur et on consid´rera qu’il saisit bien un nombre impair. e Trois exemples d’ex´cution sont les suivants : e
Nombre d’´toiles ` la base du triangle (impair) ? e a 5 * *** ***** Nombre d’´toiles ` la base du triangle (impair) ? e a 3 * *** Nombre d’´toiles ` la base du triangle (impair) ? e a 1 *

Exercice 4 (Equation du second degr´.) e Ecrire un programme qui prend en entr´e les coefficients d’une ´quation du e e second degr´ et affiche les racines r´elles s’il y en a. e e Exercice 5 (Saisie et affichage d’un tableau.) Ecrire un programme qui saisit un tableau d’entiers de taille N (constante symbolique) et qui l’affiche de telle sorte que tous les entiers pairs se retrouvent 2

int p) qui renvoie le nombre de combinaisons de p elements parmi n – une fonction estDivisible( a. ´ 2. Exercice 6 (Fonctions qui renvoient ou affichent un r´sultat. Ecrire un programme qui calcule les valeurs approch´es de I pour a = 1 e et b = 2 et n = 5. Ecrire une fonction premier d’un param`tre entier m et retournant TRUE e si le nombre est premier et FALSE dans le cas contraire. 10. 20.) e ´ Ecrire un programme qui d´finit et utilise : e – une fonction fact(n) qui renvoie la factorielle du nombre n.. b et n qui calcule une valeur e approch´e de l’int´grale de la fonction f entre a et b en utilisant la m´thode e e e des trap`zes : e I= b − a f(x0 ) f(xn ) +f(x1 )+· · ·+f(xn−1 )+ n 2 2 avec xi = a+(b−a)× i n ´ 3. Exercice 8 (Premier nombre premier plus grand que n) . Ecrire une fonction prochain premier prenant un param`tre entier n et e retournant le plus petit nombre premier plus grand ou ´gal ` n. ´ Ecrire une fonction f qui calcule l’inverse 1/x de son argument. – une fonction comb (int n . – un nombre entier n est dit ”premier” s’il n’existe aucun entier d dans l’intervalle [2.1. Exercice 7 (Calcul d’une int´grale par la m´thode des trap`zes) e e e 1.h. 100 et compare ces valeurs avec la valeur th´orique (ln 2). Par exemple.) 3 . b) qui renvoie 1 si a est divisible par b – une fonction estPremier(n) qui renvoie 1 si a est premier Rappels : – factorielle(n) = n ! = n (n-1) (n-2) .avant les entiers impairs. ´ 1. le programme affichera pour un tableau contenant 7 4 7 8 4 6 3 9 6 ses valeurs de la mani`re suivante : 4 8 4 6 6 7 7 e 3 9. e Note : Pour obtenir ln x il faut appeler log(x) dont le prototype se trouve dans math. – une fonction affiche fact(n) qui ne renvoie rien et affiche la factorielle du nombre n. ´ Ecrire une fonction I de trois param`tres a.n ?1] tel que n soit divisible par d. e a Exercice 9 (Ecriture d’un entier dans une base. 2. 50.. Ecrire un programme qui demande un entier n ` l’utilisateur et affiche le a premier nombre premier plus grand ou ´gal ` n. e a ´ 3.

2. int puissance=1. } for ( j=0.1. } return (exposant). if ( n == 0 ) { t[0]=’0’ . exposant = exposant + 1. Exemple d’ex´cution : e 4 . return 1. (a) Ecrivez une fonction imprime(t. (b) A l’aide des fonctions decimale(t. q=q/10. } } (a) Quels sont les arguments de la fonction ? Identifiez leurs rˆles. int n) { int exposant=0. puissance o et exposant. Son prototype est : e int imprime ( char t[]. } else { while ( puissance <= n ) { puissance = puissance ∗ 10. (c) Quel est le r´sultat de la fonction ? Quelle est la signification du e contenu du tableau t ? (d) Donnez la signification et le rˆle des variables suivantes : q . int q = n.i) qui affiche sur une mˆme ligne e les i premiers caract`res du tableau t.n) et imprime(t. concevez un programme C qui demande ` l’utilisateur de saisir un entier positif a et qui affiche ses chiffres (dans son ´criture d´cimale) dans l’ordre e e inverse. (e) Compl´tez l’´criture de la fonction avec des commentaires afin de la e e rendre claire.i). o (b) Quelle est la sp´cificit´ du passage de tableau comme param`tre d’une e e e fonction. j<exposant. int i). j = j + 1) { t [ j ] = ’0’ + (q % 10). int j . Soit la fonction C suivante : int decimale( char t [10].

n) pour ´crire une fonction e hexadecimale(t. ’1’. Ses arguments sont t.Entrez un entier positif : 12345 54321 (c) Modifiez la fonction decimale(t. ’9’. Son prototype est : int hexadecimale ( char t[]. //[Session started at 2006−11−14 15:45:21 +0100. les types pr´d´finis float et double permettent de manipuler e e des nombres ` virgule flottante en simple et double pr´cision mais il n’y a pas a e de type pr´d´fini permettant de manipuler des nombres complexes. ’B’ (11). et l’expression calcul´e dans l’ordre c1 op1 c2 d’abord puis son e r´sultat utilis´ comme argument gauche de op2 et ainsi de suite. . ’6’. somme c(c1. Ecrire une fonction pi_rat(n) qui utilise la formule d’Euler π = 4 + ∞ 8 i=1 1−16i2 ) et renvoie l’approximation rationnelle de π pour une valeur donn´e de n. ’D’ (13). Elle place dans t les caract`res chiffres de son ´criture en e e base 16 et retourne le nombre de chiffres dans son ´criture en base e 16. affiche c(c). Rappel : Les caract`res chiffres en base 16 sont : e ’0’. ’3’.c2) et produit c(c1. . 2. On d´finira e e e un type cmplx1 en utilisant une structure et deux champs de type double qui repr´sentent la partie r´elle et la partie imaginaire.. ’A’ (10). int i). . ’C’ (12). Exemple d’ex´cution : e Entrez un entier positif : 3081 90C Exercice 10 (Pi ) 1.] //gauche ? (deux r´els a et b pour le complexe a+ ib) e //1 1 1 Il serait plus judicieux de nommer ce type cmplx t. ’2’. . L’affichage a e e ` l’ex´cution sera par exemple : e //((a op b) op c)op d ) etc . ’E’ (14). 5 . c2 .. et un entier positif n. e Exercice 11 (Mini calculette et complexes) En langage C. Ecrire une fonction cons_rat(n.c2) e que l’on utilisera dans un programme permettant de calculer des expressions de la forme ((c1 op1 c2 )op2 c3 )op3 c4 ) . un tableau de char de taille 10.n). opn−1 cn ) o` les complexes sont rentr´s dans u e l’ordre c1 . ’F’ (15).d) qui renvoie le rationnel n/d (sous forme d’un struct rat). ’5’. . ’8’. e e On ´crira des fonctions lit c(). ’7’. ’4’.

000000) //op? (+ ou ∗ ou r ( esultat ) ) //+ //droit ? (deux r´els a et b pour le complexe a+ ib) e //3 3 //(interm´diaire) ==>(4. ´ 2.000000) e //op? (+ ou ∗ ou r ( esultat ) ) //∗ //droit ? (deux r´els a et b pour le complexe a+ ib) e //2 1 //(interm´diaire) ==>(4. Ecrire d’abord une fonction qui recherche la position du minimum d’une portion d’un tableau (` partir d’une certain indice courant jusqu’` un a a indice dernier ). Ecrire un programme qui lit une taille taille.//(1. parmi e a e lesquels les tris par s´lection et les tris par insertion.000000) Exercice 12 (Tri par s´lection) e Tous les types simples comme les entiers ou les caract`res sont munis d’un e ordre total permettant de comparer deux ´l´ments. Dans ces algorithmes de e tri. e a ´ 3. Il y a plusieurs m´thodes de tri. e La m´thode de tri par s´lection “ordinaire” consiste ` s´lectionner la position e e a e du plus petit ´l´ment du tableau. puis les taille ´l´ments ee d’un tableau d’entier ` trier. et enfin affiche le tableau tri´. Trier un tableau d’´l´ments ee ee d’un ensemble totalement ordonn´ consiste ` ranger les ´l´ments du tableau de e a ee mani`re croissante par rapport ` cet ordre. ` placer cet ´l´ment ` la premi`re place par ee a ee a e ´change puis ` recommencer sur le reste du tableau.12. Exemple : e a tableau : | 12 60 10 25 5 s´lection : e | 12 60 10 25 <5> placement : 5| 60 10 25 12 s´lection : e 5| 60 <10> 25 12 placement : 5 10| 60 25 12 s´lection : e 5 10| 60 25 <12> placement : 5 10 12| 25 60 s´lection : e 5 10 12|<25> 60 placement : 5 10 12 25| 60 s´lection : e 5 10 12 25|<60> placement : 5 10 12 25 60| ´ 1. e 6 . Ecrire ensuite une fonction de tri par s´lection qui trie le tableau donn´ e e en param`tre jusqu’` l’indice taille-1. Le tableau comportera e des entiers positifs avec une valeur n´gative marquant la fin du tableau.000000) e //op? (+ ou ∗ ou r ( esultat ) ) //r //==>(4.000000. il est exig´ de ne pas utiliser de tableau auxiliaire.000000. La taille maxia e male du tableau est fix´e par une constante NMAX dans le programme.000000.1.000000.4.12.

compteur <= 10.i).i).i = i + 1) { printf (” affiche 10 fois %d\n”.i <= 11.h> /∗ affiche une table de 11 lignes dont la ieme ligne contient iiiiiiiiii (la valeur de i 10 fois ). } return EXIT SUCCESS.1 Correction Exercice 1 #include <stdlib. } printf (”\n”).i <= 11.h> /∗ printf ∗/ /∗ d´claration constantes et types utilisateurs ∗/ e /∗ d´claration de fonctions utilisateurs ∗/ e /∗ fonction principale ∗/ int main() { 7 . } Exercice 2 /∗ d´claration de fonctionalit´s suppl´mentaires ∗/ e e e #include <stdlib.compteur = compteur + 1) { printf (”%d ”.h> /∗ EXIT SUCCESS ∗/ #include <stdio. ` ` Dans un second temps on remplace cet affichage par une boucle ∗/ int main () { int i .i = i + 1) { for(compteur = 1.h> #include <stdio. int compteur. Dans un premier temps on se contente d’afficher ” affiche 10 fois i ” en passant a la ligne a chaque fois . } /∗ version 2 (avec une double boucle) ∗/ for(i = 1. /∗ version 1 (simple) ∗/ for(i = 1.

scanf(”%d”. /∗ somme ` calculer ∗/ a int n.f. &f). /∗ 2 somme des entiers compris entre d et f ∗/ printf (”entrez deux entiers relatifs d et f (avec d <= f) \n”). somme = 0.i = i + 1) /∗ i allant de d ` f ∗/ a { /∗ ajoute i a la somme partielle ∗/ ` somme = somme + i. 3 et 4 ∗/ int d. somme). scanf(”%d”. scanf(”%d”. int f . } /∗ i > f ∗/ printf (”la somme des entiers compris entre %d et %d est %d \n”. } 8 . /∗ ´l´ment neutre pour l’addition ∗/ ee for(i = 1. &n). n. &f).i = i + 1) /∗ i allant de d ` f ∗/ a { if ( i < 0) { somme = somme − i. &d). /∗ 3 somme des valeurs absolues des entiers compris entre d et f ∗/ printf (”entrez deux entiers relatifs d et f (avec d <= f) \n”). somme = 0. somme = 0. /∗ ´l´ment neutre pour l’addition ∗/ ee for(i = d.i <= n. } /∗ i > n ∗/ printf (”la somme de %d premiers entiers est %d \n”.i <= f. /∗ var. /∗ entier a saisir ∗/ ` int i . d. &d). /∗ 1 : somme des n premiers entiers ∗/ printf (”entrez un entier naturel \n”).i = i + 1) /∗ i allant de 1 a n ∗/ ` { /∗ ajoute i a la somme partielle ∗/ ` somme = somme + i. /∗ ´l´ment neutre pour l’addition ∗/ ee for(i = d. scanf(”%d”.i <= f./∗ d´claration et initialisation variables ∗/ e /∗ question 1 ∗/ int somme. somme). scanf(”%d”. de boucle ∗/ /∗ ajout pour questions 2.

] //entrez un entier naturel //3 //la somme de 3 premiers entiers est 6 //entrez deux entiers relatifs d et f (avec d <= f) //−3 7 //la somme des entiers compris entre −3 et 7 est 22 //entrez deux entiers relatifs d et f (avec d <= f) //−3 7 //la somme des valeurs absolues des entiers compris entre −3 et 7 est 34 //entrez deux entiers relatifs d et f (avec d <= f) //la somme des valeurs absolues des entiers pairs compris entre −3 et 7 est 14 9 . /∗ 4 somme des valeurs absolues des entiers pairs compris entre d et f ∗/ printf (”entrez deux entiers relatifs d et f (avec d <= f) \n”). } } /∗ i > f ∗/ printf (”la somme des valeurs absolues des entiers compris entre %d et %d est %d \n”. &d). } else { somme = somme + i. somme = 0.f. d. scanf(”%d”. d. /∗ ´l´ment neutre pour l’addition ∗/ ee for(i = d. &f). } /∗ implantation de fonctions utilisateurs ∗/ //td2 L1 06 3 has exited with status 0.i <= f.i = i + 1) /∗ i allant de d ` f ∗/ a { if ( i % 2 == 0) /∗ pair ∗/ { if ( i < 0) { somme = somme − i. scanf(”%d”.f. } } } /∗ i > f ∗/ printf (”la somme des valeurs absolues des entiers pairs compris entre %d et %d est %d \n”. return EXIT SUCCESS.else { somme = somme + i. //[Session started at 2006−09−28 11:19:26 +0200. somme). somme).

/∗ var. /∗ affichage triangle isoc`le d’ ´toiles ∗/ e e for(i = 1.h> /∗ EXIT SUCCESS ∗/ #include <stdio.// //td2 L1 06 3 has exited with status 0. de boucle ∗/ /∗ saisie base (impair) ∗/ printf (”Nombre d’etoiles a la base du triangle (impair) ?\n”). } /∗ j >= (base − i) /2 ∗/ /∗ affiche les ´toiles ∗/ e for(j = 0. j = j + 1) /∗ i fois ∗/ { /∗ affiche une ´toile ∗/ e printf (”∗”). ` scanf(”%d”.h> /∗ printf.j < (base − i) / 2.&base). } /∗ j >= i ∗/ /∗ passe ` la ligne suivante ∗/ a printf (”\n”). /∗ un nombre impair d’´toiles ` la base du triangle . } 10 . /∗ var.j < i.i = i + 2) /∗ chaque nombre d’´toiles a afficher (base impaire)∗/ e ` { /∗ affiche les blancs ∗/ for(j = 0. de boucle ∗/ int j . scanf ∗/ /∗ d´claration constantes et types utilisateurs ∗/ e /∗ d´claration de fonctions utilisateurs ∗/ e int main() { int base. } /∗ i >= base ∗/ return EXIT SUCCESS. Exercice 3 #include <stdlib.i <= base. saisi par l ’ utilisateur ∗/ e a int i . j = j + 1) /∗ (base − i) / 2 fois ∗/ { /∗ affiche un blanc ∗/ printf (” ”).

h> /∗ printf.000000 //l ’´quation 1. } else { printf (” a comme racines x1 =%f et x2=%f\n”. delta= (b∗b − 4∗a∗c).000000 =0 a comme racines x1 =−1.&c).000000 et x2=1.&b).c.b. printf (”delta = %f\n”. scanf(”%lf”.000000 //l ’´quation 1.000000 e // //td4 3 L1 06 has exited with status 0.] //entrez les coefficients de l ’´quation du second degr´ a r´soudre e e` e //1 0 −1 //delta = 4. } else { if (delta==0) { printf (” a comme racine unique x = %f\n”.a. delta).000000x +−1.] //entrez les coefficients de l ’´quation du second degr´ a r´soudre e e` e //1 2 1 //delta = 0. } //[Session started at 2006−10−16 22:56:40 +0200. scanf ∗/ #include <math.b. //[Session started at 2006−10−16 22:56:56 +0200./∗ implantation de fonctions utilisateurs ∗/ Exercice 4 #include <stdlib.000000∗xˆ2 + 0. (−b −sqrt(delta))/(2∗a).delta. } } return EXIT SUCCESS.000000∗xˆ2 + 2. (−b +sqrt(delta))/(2∗a) ).000000 e 11 . −b/(2∗a)).&a). e e` e scanf(”%lf”. /∗ question 1∗/ printf (”l ’´quation %f∗xˆ2 + %fx +%f =0”.c). scanf(”%lf”.000000x +1. e if (delta < 0 ) { printf (” n’a pas de racines\n”).h> /∗ sqrt ∗/ /∗ Equations du second degr´ ∗/ e int main () { double a.h> /∗ EXIT SUCCESS ∗/ #include <stdio. printf (”entrez les coefficients de l ’´quation du second degr´ a r´soudre\n”).000000 =0 a comme racine unique x = −1.

/∗ lecture ∗/ for ( i = 0. i< N. scanf(”%d”.] //entrez les coefficients de l ’´quation du second degr´ a r´soudre e e` e //1 2 3 //delta = −8.i = i + 1) { printf (”%d ”. for ( i =0.// //td4 3 L1 06 has exited with status 0.000000x +3. //[Session started at 2006−10−16 22:57:05 +0200. } /∗ affichage du tableau dans l ’ordre ∗/ printf (”tab = \n{”). for ( i = 0.h> #define N 4 /∗ lecture d’un tableau et affichage les pairs d’abord. } } for ( i =0.000000 //l ’´quation 1. } printf (”} \n”). tab[i ]). i). int i . Exercice 5 #include <stdlib.000000∗xˆ2 + 2. i = i + 1) { if (tab[ i]%2 == 0) { printf (”%d ”. i< N.i = i + 1) { printf (”lecture de l ’ entier numero %d :”. i< N. les impairs ensuite ∗/ int main() { int tab[N]. tab[i ]). /∗ affichage du tableau dans l ’ordre pairs d’abord ∗/ /∗ Attention : une seule instruction dans chacun des for ∗/ /∗ donc on peut ne pas utiliser de { } ∗/ printf (”le tableau dans l ’ordre <pairs d’abord> = \n{”). i = i + 1) 12 .h> #include <stdio. &tab[i]). i < N.000000 =0 n’a pas de racines e // //td4 3 L1 06 has exited with status 0.

1 ex4 has exited with status 0. } //td5. &n). /∗ lectures de n et p ∗/ printf (”entrez un entier\n”).int y).h> /∗ Ecriture et utilisation de fonctions ∗/ /∗ prototypes de fonctions ∗/ int somme (int x. return EXIT SUCCESS. int b) . tab[i ]).p.somme(n. //[Session started at 2006−11−15 11:19:43 +0100. /∗ affichage de n! ∗/ int comb (int n . &p). /∗ renvoie 1 si a est premier ∗/ /∗fonction principale ) ∗/ int main () { int n. /∗ renvoie le nombre de combinaisons de p elements parmi n∗/ int estDivisible (int a.p. /∗ calcul de la somme de n et p rangement dans r et affichage∗/ 13 . /∗ n! ∗/ void affiche fact (int n). int p).p)). } } printf (”} \n”). scanf(”%d”. printf (”entrez un entier inf´rieur au precedent\n”).] // lecture de l ’ entier numero 0 :1 // lecture de l ’ entier numero 1 :2 // lecture de l ’ entier numero 2 :3 // lecture de l ’ entier numero 3 :4 //tab = //{1 2 3 4 } //le tableau dans l ’ordre <pairs d’abord> = //{2 4 1 3 } Exercice 6 #include <stdlib.{ if (tab[ i]%2 != 0) { printf (”%d ”. n. /∗ renvoie 1 si a est divisible par b ∗/ int estPremier(int n) .r . /∗ renvoie la somme de 2 ´l´ments ∗/ ee int fact (int n). /∗ affichage de la somme de n et p sans la ranger dans une variable ∗/ printf (”la somme de %d et %d est %d\n”. e scanf(”%d”.h> #include <stdio.

for ( i = 1. int p) { return ( fact(n) / ( ( fact (p) ∗ fact (n−p)) ) ).r=somme(n.n). } void affiche fact (int n) { int i .p). res = 1. /∗affichage de fact (n) en appellant fact (n) et en rangeant le r´sultat ∗/ e r=fact(n). i <=n. for ( i = 1.int y) { return x + y. else printf (”ce nombre n’est pas premier\n”). printf (” %d ! = %d\n”. } int fact (int n) { int i . return . } /∗ d´finitions des fonctions) ∗/ e int somme (int x. printf (”la somme de %d et %d est toujours %d\n”. n.r).p) ) ) printf (”ce nombre est premier\n”). i = i + 1) res = res ∗i . i = i + 1) res = res ∗i . } int comb (int n .p)). n . printf (”la factorielle de %d est %d \n”. /∗ le nombre de combinaisons de p objets parmi n est il premier ? ∗/ if (estPremier( comb(n.n. return res. } 14 . /∗ affichage du nombre de combinaisons de p objets parmi n ∗/ printf ( ”le nombre de fa¸ons de prendre %d valeurs (non ordonn´es) parmi %d \n”. p. res). return EXIT SUCCESS. res = 1. comb(n.r). c e printf (”est %d \n”. /∗ affichage de fact (n) en utilisant la fonction d’ affichage ∗/ affiche fact (n).p. i <=n.

15 . } int estPremier(int n) { int i . } //entrez un entier inf´rieur au precedent e //4 //la somme de 5 et 4 est 9 //la somme de 5 et 4 est toujours 9 // 5 ! = 120 //la factorielle de 5 est 120 //le nombre de fa¸ons de prendre 4 valeurs (non ordonn´es) parmi 5 c e //est 5 //ce nombre est premier // //td5. Exercice 7 /∗ Programme 3 : int´gration avec la m´thode des trapezes ∗/ e e #include <stdlib. int i .h> /∗ Fonction ` int´grer ∗/ a e double f(double x) { return 1/x. i < n. for ( i =2. for(i = 1.2 ex1 2 3 has exited with status 0.h> /∗ Comme on utilise la fonction log . il faut inclure math. else return 0.h ∗/ #include <math. } /∗ Calcul de l ’ integrale de f de a ` b ∗/ a double I(double a. i = i + 1) if ( estDivisible (n. i = i + 1) s = s + f(a + (b−a)∗i/n).h> #include <stdio. double b.int estDivisible (int a. int n) { double s. s = (f(a) + f(b))/2. i < n−1. int b) { if (a%b == 0) return 1. return 1. i )) return 0.

h> #include <stdio. return TRUE. return n.h> #define TRUE 1 #define FALSE 0 /∗ Fonction testant si un nombre est premier ∗/ int premier(int m) { int i . i = i + 1) if ((m % i) == 0) /∗ divisible ∗/ return FALSE. approcheLn2(100). } /∗ Calcul de I pour un n particulier ∗/ void approcheLn2(int n) { double x. n). return EXIT SUCCESS. /∗ La valeur approch´e pour n ∗/ e y = log(2). 2. x. erreur = (erreur >= 0) ? erreur : − erreur. erreur. approcheLn2(20). } /∗ Fonction principale ∗/ void main(void) { approcheLn2(5). erreur). y. } /∗ Fonction cherchant le premier nb premier plus grand que n ∗/ int prochain premier(int n) { while(! premier(n)) n = n + 1. x = I(1. } Exercice 8 /∗ Programme : le prochain premier ∗/ #include <stdlib. n. i < m. /∗ La valeur r´elle ∗/ e erreur = (x−y) / y ∗ 100. printf (” Pour N = %d : I = %g L’erreur avec ln2 est de %g%%\n”. approcheLn2(50). } 16 .return s∗(b−a)/n. approcheLn2(10). for(i = 2.

} Exercice 9 La sp´cificit´ du tableau lorsqu’il est pass´ en argument est que le tableau e e e peut-ˆtre modifi´ dans la fonction et que la modification persiste au retour de e e la fonction (ce qui est pass´ n’est pas une copie du tableau mais une indication e de sa position dans la m´moire : son adresse). + a (e−1) ∗10ˆ(e−1) ∗/ printf (” nombre \n”).h> #include <stdio. char ch[10]. \n”). Ci-dessous cela est utilis´ dans la e e fonction d´cimale qui renvoie une r´sultat mais modifie ´galement le tableau t e e e pass´ en argument. printf (”repr´sentation hexad´cimale de %d en a 0∗16ˆ10 + a 1∗16ˆ1 + . int n.. printf (”Le prcohain nombre premier de %d est %d\n”.n). tels que n= t 0∗10ˆ0 + a 1∗10ˆ1 + . e e 17 . e e imprime(ch.. n./∗ La fonction principale ∗/ void main(void) { int k. t [e−1] e et renvoie e. t [e−1]∗/ scanf(”%d”. printf (”premier exposant e tel que 10ˆe > %d est %d\n”. k. printf (”repr´sentation d´cimale de %d en a 0∗10ˆ10 + a 1∗10ˆ1 + . . t [e−1] e et renvoie e. e=decimale(ch. e #include <stdlib.n).. tels que n= t 0∗16ˆ0 + a 1∗16ˆ1 + . \n”). ... int k). return EXIT SUCCESS. e On a ainsi n= t 0∗10ˆ0 + a 1∗10ˆ1 + .. int n).. t [1].. prochain premier(k)).. + a (e−1) ∗10ˆ(e−1) ∗/ int decimale( char t [10]. t [1]. printf (”premier exposant e tel que 16ˆe > %d est %d\n”...n) remplit le tableau de caract`res t en t [0]. t [1]. int n). + a (e−1) ∗16ˆ(e−1) ∗/ int hexadecimale( char t[10].e...&n). int main () { // insert code here . &k). e=hexadecimale(ch.h> /∗ decimale( t . /∗ hexadecimale( t. e /∗ rang´e dans le tableau t . /∗ saisit un entier n et affiche sa representation d´cimale t [0].. /∗ affiche sur une mˆme ligne les k premiers caract`res du tableau t ∗/ e e int imprime (char t[10].. printf (”Entrez un entier positif ”). n. e). e).n) remplit le tableau de caract`res t en t [0].e). scanf(”%d”..

.. + a (e−1) ∗10ˆ(e−1) ∗/ int decimale( char t [10]. } } int imprime (char t[10]. t [e−1] e et renvoie e. j = j + 1) { t [ j ] = ’0’ + (q % 10). exposant = exposant + 1. . } return (exposant). } /∗ decimale( t . } e /∗ On ´crit les a j de la repr´sentation dans t e (entre 0 et exposant−1) : ∗/ /∗ par exemple : 153 % 10 = 3 et 153 / 10 = 15 puis 15 % 10 = 5 et 15 /10 = 1 puis 1 % 10 = 1 et 1 / 10 = 0 ===> t= 3 5 1∗/ for ( j=0.. t [1]. + a (e−1) ∗10ˆ(e−1) )∗/ /∗ on ´crit les coeeficients a 0. int n) { /∗ On cherche le plus petit exposant e tel que puissance = 10ˆe > n ∗/ /∗ Dans ce cas on peut ´crire e n= t 0∗10ˆ0 + a 1∗10ˆ1 + . . .n) remplit le tableau de caract`res t en t [0]. int k){ int j . j<k.. for ( j=0. a (e−1) e dans le tableau de caract`res t [0]. return EXIT SUCCESS. int puissance=1. /∗ 0= 0∗10ˆ0 ∗/ return 1.. int q = n. t [e−1] ∗/ e int exposant=0. j<exposant. .imprime(ch. if ( n == 0 ) { t[0]=’0’ ... q=q/10. /∗ 10ˆ0 = 1 > 0 ∗/ } else { /∗ on cherche puissance et exposant tels que puissance=10ˆexposant > n ∗/ while ( puissance <= n ) { puissance = puissance ∗ 10. int j .. } 18 .e). j = j + 1) { printf (”%c ”.... tels que n= t 0∗10ˆ0 + a 1∗10ˆ1 + . t[ j ]).

.. } return (exposant). j = j + 1) { t [ j ] = tab[q % 16]...... t [e−1] ∗/ e int exposant=0. /∗ valeur de retour ` ignorer ∗/ a } /∗ hexadecimale( t. exposant = exposant + 1... if ( n == 0 ) { t[0]=’0’ . j<exposant. tels que n= t 0∗16ˆ0 + a 1∗16ˆ1 + . e e //9 0 C 19 . t [e−1] e et renvoie e. q=q/16. int j . return 0. int n) { /∗ On cherche le plus petit exposant e tel que puissance = 16ˆe > n ∗/ /∗ Dans ce cas on peut ´crire e n= t 0∗16ˆ0 + a 1∗16ˆ1 + .n) remplit le tableau de caract`res t en t [0].. char tab[16] =”0123456789ABCDEF” . + a (e−1) ∗16ˆ(e−1) ∗/ int hexadecimale( char t[10].. .. /∗ 16ˆ0 = 1 > 0 ∗/ } else { /∗ on cherche puissance et exposant tels que puissance=16ˆexposant > n ∗/ while ( puissance <= n ) { puissance = puissance ∗ 16. int puissance=1. } } //nombre //3081 //premier exposant e tel que 10ˆe > 3081 est 4 //repr´sentation d´cimale de 0 en a 0∗10ˆ10 + a 1∗10ˆ1 + . + a (e−1) ∗16ˆ(e−1) )∗/ /∗ on ´crit les coeeficients a 0. a (e−1) e dans le tableau de caract`res t [0].printf (”\n”).. .... t [1]. e e //1 8 0 3 //premier exposant e tel que 16ˆe > 3081 est 3 //repr´sentation hexad´cimale de 0 en a 0∗16ˆ10 + a 1∗16ˆ1 + . int q = n. . } e /∗ On ´crit les a j de la repr´sentation dans t e (entre 0 et exposant−1) : ∗/ for ( j=0. /∗ 0= 0∗16ˆ0 ∗/ return 1.

num∗c2.i<=n.1−16i∗i) res = somme rat(res.1). c. c. } /∗ on utilise une fonction struct rat cons rat(int n.num =n. Il appellera pi_rat(n) e e qui renvoie le rationnel et l’affichera. struct rat res .den=c1. struct rat c2) qui renvoie la somme des deux ration struct rat somme rat(struct rat c1. res =cons rat(4. } struct rat pri rat (int n){ int i . ri . i = i + 1) { ri = cons rat(8. } return res.den∗c2. for ( i=1. } Exercice 11 #include <stdlib.den + c2.num∗c1.den .Exercice 10 Il faut un programme avec toutes les fonctions pr´c´dentes.den =d. r .h> #include <stdio. struct rat { int num.den. ri).int d) qui renvoie le rationnel n/d∗/ struct rat cons rat(int n. return r. return c. } /∗ on utilise une fonction struct rat somme rat(struct rat c1.num=c1.int d) { struct rat r . int den. r . struct rat c2) { struct rat c.h> #define N 5 /∗ type ∗/ struct cmplx 20 .

scanf(”%s”. void affiche c (struct cmplx c).d. affiche c (resg ).rep). e resg=lit c (). double im. printf (”gauche ? (deux r´els a et b pour le complexe a+ ib)\n”). char rep[10]. scanf(”%s”. e affiche c (resg ). if (rep[0]==’+’) { resg=somme c(resg. printf (”op? (+ ou ∗ ou r ( esultat ) ) \n”). struct cmplx c2). printf (”op? (+ ou ∗ ou r ( esultat ) ) \n”). } printf (”==>”). } } printf (”(interm´diaire) ==>”).break. struct cmplx produit c(struct cmplx c1. } else { printf (”erreur\n”). affiche c (resg ).{ double re. while (rep[0] !=’r ’ ) { printf (”droit ? (deux r´els a et b pour le complexe a+ ib)\n”). } /∗fonctions ∗/ 21 .d). e d=lit c (). }. struct cmplx somme c(struct cmplx c1. /∗ prototypes ∗/ struct cmplx lit c(void).rep). return EXIT SUCCESS. } else { if (rep[0]==’∗’) { resg=produit c(resg. /∗ principale ∗/ int main() { struct cmplx resg. struct cmplx c2).d).

re=(c1.12.struct cmplx lit c(void) { struct cmplx c.h> #define NMAX 1000 22 . re .000000. } //((a op b) op c)op d ) etc .re)−(c1.re+c2.. c.000000.re. c.im).h> #include <stdio.] //gauche ? (deux r´els a et b pour le complexe a+ ib) e //1 1 //(1.. return (c).im=(c1.1. } void affiche c (struct cmplx c) { printf (”(%lf. struct cmplx c2) { struct cmplx c.re). scanf(”%lf”.im).im+c2.im∗c2.im).re).im∗c2. re=c1. } struct cmplx produit c(struct cmplx c1.im. //[Session started at 2006−11−14 15:45:21 +0100. c. return (c).000000.000000) Exercice 12 #include <stdlib.&c.12. struct cmplx c2) { struct cmplx c. return (c).c.%lf)\n”.c.im)+(c1.000000) //op? (+ ou ∗ ou r ( esultat ) ) //+ //droit ? (deux r´els a et b pour le complexe a+ ib) e //3 3 //(interm´diaire) ==>(4. return .000000) e //op? (+ ou ∗ ou r ( esultat ) ) //∗ //droit ? (deux r´els a et b pour le complexe a+ ib) e //2 1 //(interm´diaire) ==>(4.re∗c2.&c.re∗c2. } struct cmplx somme c(struct cmplx c1.4. scanf(”%lf”. c.000000.000000) e //op? (+ ou ∗ ou r ( esultat ) ) //r //==>(4.im=c1.

. int main () { int i . /∗ tab est ordonn´ jusqu’` la position i incluse et contient entre 0 et i e a les plus petits ´l´ments du tableau ∗/ ee } /∗ tab est ordonn´ jusqu’` la position taille −1 ∗/ e a 23 . int taille ) { int i . int pmin=courant.. /∗ pmin est la position du plus petit ´l´ment entre courant et i ∗/ ee } /∗ pmin est la position du plus petit ´l´ment entre courant et taille −1 ∗/ ee return pmin. tab[ i]=tab[p]. int courant. int posMin(int tab[]. for ( i=courant+1. return EXIT SUCCESS. i< taille . taille ).&t[i]). i=i+1) { scanf(”%d”. } triParSelection (t . aux=tab[i]. } printf (”\n”). i=i+1){ if (tab[ i ] < tab[pmin]) pmin=i.p. for ( i=0. taille ). i< taille . int taille ). printf (” taille ? ”). i=i+1){ p=posMin(tab. int aux. // insert code here . int courant. for ( i=0. int taille ). int taille ) { int i . i< taille . taille . int t [NMAX].i. i=i+1) { printf (”%d ”.void triParSelection( int tab []. tab[p]=aux. for ( i=0. } void triParSelection( int tab [].&taille). scanf(”%d”.t[i ]). i< taille. } int posMin(int tab[].

] //taille ? 4 //1 //3 //2 //0 //0 1 2 3 24 ./∗ on peut ´viter une it´ration . comment ?∗/ e e } //[Session started at 2009-02-14 13 :00 :14 +0100.