TP 3 : Fonctions arithmétiques récursives

L1-S1-IMP
Informatique
Ann´ee 2010 - 2011
Semestre 1
TP 3 : Fonctions arithm´etiques r´ecursives
1 Plus Petit Commun Multiple
Exercice 1 ´ Ecrire une fonction ppcm qui calcule le plus petit multiple commun de deux entiers positifs.
Si les entiers ne sont pas tous les deux positifs, ppcm devra renvoyer la valeur 0.
Indication : soit la paire d’entiers (a, b). Examinons, dans l’ordre croissant, les multiples successifs de
a(a, 2a, 3a, . . . ) jusqu’`a ce qu’on en trouve un qui soit divisible par b: ce nombre est, par d´efinition, le
P.P.C.M. de aet de b. La recherche est acc´el´er´ee si aest sup´erieur `a b.
Exemples d’application de la fonction ppcm :
# ppcm(12,28) ;; # ppcm(58,28) ;; # ppcm(10,21) ;; # ppcm(-14,28) ;;
- : int = 84 - : int = 812 - : int = 210 - : int = 0
Astuce : Vous pouvez tracer l’ex´ecution d’une fonction. Pour la fonction ppcm, faites :
# #trace ppcm ;;
Ensuite, vous pouvez ex´ecuter la fonction comme d’habitude. Pour vous d´ebarrasser de la trace, faites :
# #untrace ppcm ;;
Dans les deux cas, il y a deux #, dont le premier est l’invite de Caml et le deuxi`eme appartient `a la
commande trace/untrace.
2 Nombres premiers
Exercice 2 ´ Ecrire une fonction sigma qui calcule la somme des diviseurs d’un entier npositif ou nul.
Si nest n´egatif on conviendra que sigma(n) = 0. Indication : on sugg`ere d’´ecrire une fonction auxiliaire
r´ecursive qui calcule la somme des diviseurs de n compris entre ket n,k´etant un entier inf´erieur ou ´egal
`a n. Apr`es avoir ´ecrit une version simple de cette fonction auxiliaire, on pourra envisager de l’am´eliorer
en optimisant la recherche des diviseurs de n.
Exemples d’application de la fonction sigma :
# sigma 1 ;; # sigma 30 ;; # sigma 31 ;; # sigma 49 ;; # sigma (-1) ;;
-:int=1 -:int=72 -:int=32 -:int=57 -:int=0
Rappel : par d´efinition, un entier naturel nest premier s’il a exactement deux diviseurs (1 et n). Le
plus petit nombre premier est 2 (1 n’a qu’un seul diviseur . . .).
Exercice 3 ´ Ecrire une fonction est premier qui d´etermine si un entier est premier ou pas. Pour d´ecider
si un nombre est premier on se servira de la fonction sigma ´ecrite pr´ec´edemment.
Exemples d’application de la fonction est premier :
# est_premier 1 ;; # est_premier 30 ;; # est_premier 31 ;; # est_premier (-5);;
- : bool = false - : bool = false - : bool = true - : bool = false
Exercice 4 ´ Ecrire une fonction r´ecursive prochain premier qui, ´etant donn´e un entier nquelconque
renvoie le plus petit nombre premier strictement sup´erieur `a n.
Exemples d’application de la fonction prochain premier :
L1-S1 Info 2010 - 2011 1 TP3

# prochain_premier 0 ;; # prochain_premier 7 ;; # prochain_premier 523 ;;
- : int = 2 - : int = 11 - : int = 541
Exercice 5 ´ Ecrire une fonction keme premier qui, ´etant donn´e un entier k > 0, retourne le k`eme nombre
premier (2 est le 1er nombre premier, 3 le 2`eme, etc.). Si kest n´egatif ou nul, c’est une erreur. Indication :
ici aussi, on sugg`ere d’´ecrire une fonction auxiliaire r´ecursive qui, ´etant donn´e deux entiers net k, recherche
le k`eme nombre premier au-del`a de n(sup´erieur `a n).
Exemples d’application de la fonction keme premier :
# keme_premier 1;; # keme_premier 2;; # keme_premier 100;; # keme_premier 1000;;
- : int = 2 - : int = 3 - : int = 541 - : int = 7919
3 Autour de la dichotomie
3.1 Calcul de la racine carr´ee
Exercice (`a pr´eparer) 6 Concevoir une fonction racine carree qui calcule, en utilisant le principe de
la dichotomie, une valeur approch´ee par d´efaut, `a pr`es, de la racine carr´ee d’un nombre x(xet sont
les donn´ees du probl`eme).
Indications : on sugg`ere de prendre comme espace de recherche initial l’intervalle [1, x] si x > 1 et
[x, 1] si x < 1. ` A chaque ´etape de la dichotomie, l’espace de recherche sera partag´e en deux parties ´egales
(2 intervalles de mˆeme taille).
Vous devez pr´eparer la solution `a l’avance, puis l’implanter et la tester en s´eance de TP.
Votre solution:
Exemples d’application de la fonction racine carree :
# racine_carree(16.,1e-5) ;; # racine_carree(2.,1e-15) ;;
- : float = 3.9999971389770508 - : float = 1.4142135623730949
# racine_carree(2.,1e-4) ;; # racine_carree(1024.,1e-10) ;;
- : float = 1.4141845703125 - : float = 31.999999999971806
3.2 Am´elioration de la racine carr´ee
Faites ´evaluer racine carree(2.,1e-16). Que constate-t-on ? En vous appuyant sur ce que vous
savez sur la repr´esentation des nombres en virgule flottante, vous allez modifier la fonction pr´ec´edente
pour que la recherche s’arrˆete lorsque la pr´ecision maximum est atteinte.
Exercice 7 ´ Ecrire une fonction racine 2 qui calcule la racine carr´ee d’un nombre xavec la meilleure
pr´ecision possible (il n’y a plus qu’une seule donn´ee : x).
Exemples d’application de racines 2 :
# racine_2 2. ;; # racine_2 1024. ;; # racine_2 0.25 ;;
- : float = 1.4142135623730949 - : float = 32. - : float = 0.5
L1-S1 Info 2010 - 2011 2 TP3

4 Pavages
En cours, vous avez vu le probl`eme du d´enombrement des pavages d’un couloir avec deux sortes de
carreaux. Nous rappelons ici la fonction paver qui r´esout le probl`eme :
let rec paver = function
1 -> 1
|2->2
| n -> paver (n-1) + paver (n-2);;
La fonction paver calcule le nombre de pavages, mais ne les affiche pas directement.
Exercice (`a pr´eparer) 8 D´eveloppez l’arbre d’ex´ecution de paver 5.
G´en´eralisez le r´esultat et donnez une borne inf´erieure pour le nombre d’appels r´ecursifs pour calculer
paver n, pour n≥2.
Votre solution:
Exercice 9 Mesurez le temps d’ex´ecution de la fonction paver npour quelques valeurs repr´esentatives.
Voici comment faire, pour n= 30 :
# let t1 = Sys.time () in
let _ = paver 30 in
let t2 = Sys.time () in t2 -. t1 ;;
- : float = 0.160000000000003695
Il peut ˆetre instructif de choisir, par exemple, n= 35 et n= 40.
Que constatez-vous ? Comparez avec vos r´esultats de l’exercice 8.
Exercice 10 Nous essayons de rendre l’ex´ecution de la fonction consid´erablement plus efficace, en utili-
sant une technique connue comme m´emoization.
Pour cela, nous d´efinissons une fonction paver aux ndont le but est de calculer le couple des valeurs
(paver n, paver (n−1)), mais de mani`ere efficace. Pour le cas n= 1, on choisit (1,0) :
let rec paver_aux = function
1 -> (1, 0)
| 2 -> (2, 1)
| n -> ....
Compl´etez le cas r´ecursif de la d´efinition (bien sˆur, sans faire appel `a paver). D´efinissez la fonction
paver lin `a l’aide de paver aux, qui renvoie la premi`ere composante du r´esultat de paver aux et qui est
fonctionnellement ´equivalente `a paver :
# paver_lin 6 ;;
- : int = 13
Testez l’´equivalence avec quelques exemples !
Quel est le nombre d’appels r´ecursifs de paver aux n, pour n≥2 ?
Mesurez le temps d’ex´ecution de paver lin, comme vu dans l’exercice 9.
L1-S1 Info 2010 - 2011 3 TP3