Vous êtes sur la page 1sur 3

ALGORITHMIQUE ET LANGAGE C – L1S2–MPI TD 9 – GROUPE D1

ROSELINE DESCOUT-RENIER JEUDI 03 AVRIL 2014

Objectifs de la séance :
• Algorithmes récursifs et arbres d’exécution récursive ;
• Maîtrise des conditions d’arrêt des fonctions récursives.

Exercices étudiés pendant la séance : 4 – 5 – 8 TD6.

Exercice 4 :
1. Arbre d’exécution récursive de prod(8,7) :
prod(8, 7) → 8 + prod(8, 6) → 8 + prod(16, 3) → 8 + 16 + prod(16, 2) → 8 + 16 + prod(32, 1)
→ 8 + 16 + 32 + prod(32, 0) → 8 + 16 + 32 = 56
2. Programme :

Pseudo-code : Code en C :
#include <stdio.h>

int produit(int n, int p);


Programme principal
Début int main(void) {
entier m, n, resultat ; int m, n, resultat;
écrire “ Entrer un nombre entier >= 0 ” ; printf("\nEntrer un nombre entier positif ou nul :");
lire m ; scanf("%d", &m);
écrire “ Entrer un autre nombre entier >= 0 ” ; printf("\nEntrer un autre nombre entier positif ou nul :");
lire n ; scanf("%d", &n);

resultat = produit(m, n) ; resultat = produit(m, n);

écrire “ Le résultat du produit est ” resultat ; printf("\nLe résultat du produit de %d par %d est %d.\n", m,
n, resultat);

Fin return 0;
}
Fonction produit(entier m, entier n)
Début int produit(int m, int n) {
si n = 0 faire if (n == 0) {
retourner 0 ; return 0;
}
sinon si (n modulo 2 = 0) faire else if (n%2 == 0) {
retourner produit(2*m, n/2) ; return produit(2*m, n/2);
}
sinon faire else {
retourner produit(m, n-1) + m ; return produit(m, n - 1) + m;
finsi }
Fin }
Exercice 5 :
1. Arbre d’exécution récursive pour comb(6, 3) :
C63

C 52 C53

C41 C42 C42 C43

C30 C31 C31 C32 C31 C32 C32 C33

1 C20 C21 C20 C21 C21 C22 C20 C21 C21 C22 C21 C22 1

1 C10 C11 1 C10 C11 C10 C11 1 1 C10 C11 C10 C11 1 C10 C11 1

1 1 1 1 1 1 1 1 1 1 1 1

2. Programme :
Pseudo-code : Code en C :
#include <stdio.h>

int combinaison(int n, int p);


Programme principal :
Début int main(void) {
entier n, p, resultat ; int n, p, resultat;
écrire “ Entrer un nombre entier >= 0 ” : printf("\nEntrer un nombre entier positif ou nul :");
lire n ; scanf("%d", &n);
écrire “ Entrer un autre nombre entier >= 0 ” ; printf("\nEntrer un autre nombre entier positif ou nul :");
lire p ; scanf("%d", &p);

resultat = comb(n, p) ; resultat = combinaison(n, p);

écrire “ Le résultat vaut ” resultat ; printf("\nLe résultat du produit de %d par %d est %d.\n", n,
p, resultat);

Fin return 0;
}
Fonction comb(entier n, entier p)
Début int combinaison(int n, int p) {
si p = 0 ou p = n faire if (p == 0 || p == n) {
retourner 1 ; return 1;
}
sinon si p > 0 et p < n faire else if (p > 0 && p < n) {
retourner comb(n-1, p-1) + comb(n-1, p) ; return combinaison(n-1, p-1) + combinaison(n-1,p);
}
sinon faire else {
retourner 0 ; return 0;
finsi }
Fin }
Exercice 8 :
exponentiation classique et indienne :
Pseudo-code : Code en C :
#include <stdio.h>

float expClassique(float x, int n);


float expInd(float x, int n);
Programme principal :
Début int main(void) {
entier n ; int n;
flottant x, classique, indienne ; float x, classique, indienne;
écrire “ Entrer un nombre réel x ” : printf("\nEntrer un nombre réel x :");
lire x ; scanf("%f", &x);
écrire “ Entrer un nombre entier >= 0 ” ; printf("\nEntrer un nombre entier positif ou nul :");
lire n ; scanf("%d", &n);

classique = expClassique(x, n) ; classique = expClassique(x, n);


indienne = expInd(x, n) ; indienne = expInd(x, n);

écrire “ Résultat par exp. classique :” classique ; printf("\nL'exponentiation classique de %f par %d donne
%f.\n", x, n, classique);
écrire “ Résultat par exp. indienne :” indienne ; printf("\nL'exponentiation indienne de %f par %d donne
%f.\n", x, n, indienne);

Fin return 0;
}
Fonction expClassique(flottant x, entier n)
Début float expClassique(float x, int n) {
si n = 0 faire if (n == 0) {
retourner 1 ; return 1;
}
sinon faire else {
retourner expClassique(x, n-1)*x ; return expClassique(x, n-1)*x;
finsi }
Fin }
Fonction expIndienne(flottant x, entier n)
Début float expInd(float x, int n) {
si n = 0 faire if (n == 0) {
retourner 1 ; return 1;
}
sinon n modulo 2 = 0 faire if (n%2 == 0) {
retourner expIndienne(x*x, n/2)*x ; return expInd(x*x, n/2);
}
sinon else {
retourner expIndienne(x, n-1)*x ; return expInd(x, n-1) * x;
finsi }
Fin }

Remarque : attention, les fonctions expClassique et expIndienne doivent retourner un flottant.