Enoncé exercice 6

Ecrire un programme C qui calcule le n^ième terme de la suite de Fibonacci, définie comme suit: U_n=U_n-1+U_n-2 où U₁=U₀=1.

Correction exercice 6

Dans cet exercice il est demandé de calculer le n^ième terme de la suite de Fibonacci. Il est clair que les termes de cette suite ne sont pas exprimés d’une manière explicite en fonction de n, mais plutôt chaque terme est donné en fonction des deux termes qui le précèdent. Et puisque les valeurs des deux premiers termes sont données, le calcul de n’importe quel terme est donc possible.

La première chose à faire est de demander à l’utilisateur d’entrer un entier, qu’on va lire vers la variable entière n (lignes 6-7). Et si la valeur de n est supérieure à 2 on sera donc obligés de calculer tous les termes U₂, U₃, U₄ jusqu’à arriver à U_n-1 puis le terme recherché U_n.

Pour faire ceci, on va faire appel à une boucle qui doit aller de 2 jusqu’à n. Ce qui représente un nombre d’itérations bien déterminé, et qui nous amène à choisir la boucle for qui s’avère la plus appropriée pour ce type de traitements.

Cette boucle aura un compteur i qui s’incrémentera par 1 à la fin de chaque itération, en commençant à 2 (ligne 10). A l’intérieur de cette boucle for, on va calculer le terme U_i en fonction de U_i-1 et de U_i-2. Puisque les variables en C ne peuvent pas avoir des identifiants qui contiennent le signe moins et pour faire plus simple, on va se référer à ces termes respectivement par les variables C, B et A déclarées de type int.

Ainsi, au début de chaque itération, les deux variables B et A représentent les deux derniers termes calculés. et qui seront additionnés, en respect à la définition de la suite de Fibonacci, pour obtenir le terme suivant. Ce dernier sera mis dans la variable C (ligne 12).

Après le calcul de ce nouveau terme, on aura B et C comme les deux derniers termes calculés, qu’on va affecter respectivement à A et B en guise de préparation pour la prochaine itération (ligne 13-14).

Il faut bien remarquer que l’ordre de ces affectations est important. Et que la manière correcte de les faire, et de commencer par affecter B à A puis C à B. Sinon on aura A et B qui ont toutes les deux la même valeur que C.

Après l’achèvement de toutes les itérations on aura alors le n^ième terme, stocké dans la variable C.

Il est important de remarquer que si n est inférieure ou égale à 1 la boucle ne sera pas exécutée, puisque la condition de la boucle for i<=n ne sera pas vérifiée car la valeur initiale de i qui est 2 ne sera pas inférieure à n qui ne dépassera pas 1 dans ce cas. Pour pallier à ce problème, lors de l’affichage, on va faire un test sur la valeur de n. Et on affichera 1 si n est inférieur ou égale à 1 et C dans le cas contraire (lignes 16-17).

Solution exercice 6

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int n,i,A,B,C;
    printf("Entrez un entier:\n");
    scanf("%d",&n);
    A=1;
    B=1;
    for(i=2;i<=n;i++)
    {
       C=B+A;
       A=B;
       B=C;
    }
    if(n<=1) printf("U(%d) = 1.\n",n);
    else printf("U(%d) = %d.\n",n,C);
    system("pause");
    return 0;
}

Enoncé exercice 7

Ecrire un programme C qui utilise le principe de dichotomie pour trouver la solution de l’équation x³+12x²+1=0 dans l’intervalle [-15,-10] avec une précision de 0,00001.

Correction exercice 7

La dichotomie est une méthode numérique qui permet de trouver le point dans lequel s’annule une fonction croissante ou décroissante sur un intervalle. Son principe est du plus simple; il s’agit de diviser l’intervalle en deux, puis déterminer la moitié qui contient la solution et qui sera à son tour divisée en deux pour répéter le même processus jusqu’à ce qu’on arrive à un intervalle dont la longueur est inférieure à la précision souhaitée. Et dans ce cas, n’importe quel point de cet intervalle sera une solution.

Pour récapituler, l’objectif est de trouver un intervalle où s’annule la fonction et dont la longueur est inférieure ou égale à la précision. Pour cet effet, on peut utiliser soit une boucle while ou do while. On optera ici pour la boucle while et qui prendra comme condition b-a>0.00001 pour dire que tant que la longueur de l’intervalle est supérieure à la précision on doit encore le réduire.

A l’intérieure de la boucle, on va calculer l’abscisse m du milieu de l’intervalle [a,b], pour déterminer ensuite la moitié qui contient la solution (ligne 11). Pour ce faire, on va commencer par calculer fa, fb et fm qui sont respectivement l’image de l’extrémité a puis b et celle du milieu m (lignes 12-14). Ces images vont permettre de dire si la solution se trouve dans l’intervalle [a,m] ou [m,b]. Pour trancher, il faut justement noter que la solution est dans l’intervalle dont les images des deux extrémités sont de signes différents.

Donc, il suffit de faire un test sur le signe de fa*fm et s’il est négatif alors la solution se trouvera dans l’intervalle [a,m] et dans l’autre cas il sera dans [m,b] (lignes 15-16).

Une fois la moitié qui contient la solution est déterminée, on actualisera l’intervalle [a,b] pour préparer à la prochaine itération et ceci en affectant m à b dans le premier cas, et m à a dans le deuxième.

Une fois qu’on sort de la boucle while, on affichera un des points de cet intervalle qui représentera la solution de l’équation avec la précision demandée. Ici, on a choisi l’extrémité a pour laquelle on calcul l’image puis on l’affiche et on affiche son image avec une précision de cinq chiffres après la virgule (lignes 18-19).

Ce programme va donner comme résultat le point x=-12.00694 dont l’image est -0.00064 qui est assez proche de zéro et qui peut l’être davantage si on augmente la précision.

Solution exercice 7

#include<stdio.h>
#include<stdlib.h>
int main()
{
    float a,b,m,fa,fb,fm;
    a=-15;
    b=-10;
    while(b-a>0.000001)
    {
       m=a+(b-a)/2;
       fa=a*a*a+12*a*a+1;
       fb=b*b*b+12*b*b+1;
       fm=m*m*m+12*m*m+1;
       if(fa*fm<=0) b=m;
       else a=m;
    }
    fa=a*a*a+12*a*a+1;
    printf("%.5f %.5f\n",a,fa);
    system("pause");
    return 0;
}

Enoncé exercice 8

Ecrire un programme C qui permet de reproduire le schéma suivant :

Correction exercice 8

Le programme qu’on va réaliser tout de suite a une particularité qui le distingue ; il n’a pas besoin de données de la part de l’utilisateur. Ceci justifie l’absence de la fonction scanf.

Pour reproduire le schéma d’en haut, on va utiliser une boucle for, car le nombre de lignes à afficher est connu. Pour afficher les lignes du schéma, on remarque qu’il y’a trois nombres qui varient d’une ligne à l’autre. Seulement, celui de droite est calculé en fonction des deux autres. En plus, celui du milieu peut être facilement tiré du compteur de la boucle. Donc la clé de l’exercice réside dans la construction du nombre à gauche.

Pour garder un peu d’optimalité, on va exploiter le fait que chaque nombre dans une ligne donnée, peut être calculé en fonction du nombre de la ligne qui la précède. Pour obtenir par exemple 123456, il suffit de multiplier 12345 par 10 pour avoir 123450 puis ajouter 6. Le nombre à ajouter augmente par 1 d’une ligne à l’autre, donc il sera déduit lui aussi du compteur de la boucle.

En utilisant i comme compteur pour la boucle for, et en le variant de 1 jusqu’à 9, on obtient la formule de construction du nombre à gauche qui est a=a*10+i (ligne 9). Pour que cette formule récurrente marche, il faudra choisir une valeur initiale adéquate pour a. La valeur 0 est convenable, puisque 0*10+1 donne 1 qui est la valeur du nombre à gauche pour la première ligne (ligne 6).

Le nombre du milieu b, est obtenu en ajoutant 1 à i (ligne 10). Et pour le nombre de droite, il est calculé en utilisant la formule montrée sur le schéma c=a*9+b (ligne 11).

Pour l’affichage, le premier nombre est affiché sur 9 espaces (%9d) et le deuxième sur 2 (%2d) (ligne 12).

Solution exercice 8

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int i,a,b,c;
    a=0;
    for(i=1;i<10;i++)
    {
      a=a*10+i;
      b=i+1;
      c=a*9+b;
      printf("%9d . 9 + %2d = %d\n",a,b,c);
    }
    system("pause");
    return 0;
}

Enoncé exercice 9

Ecrire un programme C qui approxime le nombre π à une précision de 0.00001 en utilisant la formule suivante :

Correction exercice 9

Pour calculer l’approximation du nombre π, on doit calculer la somme mentionnée jusqu’à un certain rang i. La contrainte qu’on a, est bien sûr sur la précision et non pas le rang. Donc on va procéder au calcul de cette somme, jusqu’à ce que la différence entre deux résultats consécutifs devienne inférieure à 0.00001.

La somme sera mise à chaque fois dans la variable pi. Cette variable doit évidemment être initialisée par 0 (ligne 8). Le i aussi, doit être initialisé par sa valeur de départ qui est 0 (ligne 9).

Avant de calculer une nouvelle valeur de pi, on va garder sa valeur actuelle dans une variable pi2 pour pouvoir calculer par la suite la différence entre les deux (ligne 11). Le calcul de pi se fait on lui ajoutant à chaque fois le nouveau terme calculé. Ce qui procure à cette somme l’aspect de récurrence observé dans le programme. Le nouveau terme peut être soit positif ou négatif selon la parité de i, et ceci à cause du (-1)ⁱ (lignes 12-13).

La condition de la boucle do while va assurer l’arrêt des calculs lorsque la valeur absolue de la différence pi-pi2 devient inférieure à la précision demandée (ligne 15). Il ne faut pas oublier d’incrémenter le i en passant d’une itération à l’autre (ligne 14).

On termine le programme on affichant la dernière valeur de pi et qui représentera la valeur approchée du nombre π (ligne 16).

Solution exercice 9

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int main()
{
    int i;
    double pi,pi2;
    pi=0;
    i=0;
    do{
       pi2=pi;
       if(i%2==1) pi=pi-4.0/(2*i+1);
       else pi=pi+4.0/(2*i+1);
       i++;
    }while(fabs(pi-pi2)>0.00001);
    printf("pi = %llf (precision 0.00001)\n",pi);
    system("pause");
    return 0;
}

Enoncé exercice 10

Ecrire un programme C qui permet de calculer les nièmes termes des deux suites réelles suivantes :

Correction exercice 10

Les deux suites (a_n) et (b_n) sont deux suites récurrentes caractérisées par le fait que chaque terme de rang n est défini en fonction des deux termes de rang n-1 des deux suites. C’est-à-dire que pour calculer le terme a_n ou b_n il faudra avoir les valeurs des deux termes a_n-1 et b_n-1. Ceci implique qu’il faudra calculer les termes des deux suites en parallèle.

Puisque les deux suites sont récurrentes, il faudra calculer tous les termes des deux suites du premier rang jusqu’au rang n-1 pour pouvoir calculer les termes du rang n. Pour faire ceci, on va utiliser une boucle for de compteur i allant de 2 jusqu’à n (ligne 12). On a commencé par 2 au niveau de ce compteur, car le premier terme est déjà donné pour les deux suites.

A chaque itération i de cette boucle, on doit manipuler deux termes pour chaque suite. Donc, on aura besoin de quatre variables réelles a, a2, b et b2 qui vont représenter respectivement a_i, a_i-1, b_i et b_i-1.

Chaque itération va commencer en affectant les deux termes a et b calculés dans l’itération précédente aux deux variables a2 et b2 (lignes 14-15). Et en fonction de ces deux dernières, en va calculer les termes suivants des deux suites en utilisant leurs définitions (lignes 16-17).

Une fois la boucle aura terminé sa tâche, on aura les n^ièmes termes des deux suites dans les deux variables a et b. On les affiche tous les deux pour terminer le programme (ligne 19).

Solution exercice 10

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int main()
{
    int i,n;
    double a,a2,b,b2;
    printf("Entrez un entier: ");
    scanf("%d",&n);
    a=10;
    b=30;
    for(i=2;i<=n;i++)
    {
       a2=a;
       b2=b;
       a=(a2+b2)/2;
       b=sqrt(a2+b2);
    }
    printf("a(%d)=%.2lf b(%d)=%.2lf\n",n,a,n,b);
    system("pause");
    return 0;
}