Appel initial : Le premier appel de la fonction.

Licence 1 Année 2011 - 2012
UE Informatique
Programmation fonctionnelle
Thierry RAEDERSDORFF
TD n°6
On distingue deux manières d'appeler une fonction récursive :
• Appel initial : Le premier appel de la fonction.
• Appel récursif : Appel de la fonction lors de l'exécution de la fonction récursive.
Récursivité classique :
• Gestion des exceptions
On gère ici les cas où les arguments de la fonction ne permettent pas de
fournir un résultat.
• Gestion des cas particuliers
On gère ici les cas où les arguments de la fonction permettent de fournir un
résultat mais qui ne rentre pas dans le cadre de l'algorithme général. .
• Cas simple :
Dans le cas simple la fonction ne s'appelle pas elle-même.
On défnit un critère d'arrêt de la fonction ainsi que le résultat simple
correspondant à ce cas. Ce résultat correspond à l'initialisation du calcul.
• Cas général :
Dans le cas général un calcul intermédiaire est réalisé.
Un calcul intermédiaire utilisera le résultat d'un appel récursif de la
fonction. L'appel récursif empile les appels de la fonction. Ce n'est qu'au
retour de l'appel récursif que le calcul intermédiaire sera réalisé, dans la
phase où on désempile les appels.
Cas A :
On pourra faire le choix d'écrire une seule fonction récursive qui gère les quatre
situations. L'inconvénient étant qu'à chaque appel de la fonction on se demandera si
nous sommes en présence d'une exception ou d'un cas particulier.
Cas B :
On pourra faire le choix d'écrire une fonction principale non récursive qui gère les
exceptions et les cas particuliers et qui assure, si on n'est pas dans l'un des deux cas
précédents, le premier appel d'une fonction récursive auxiliaire qui applique
l'algorithme général.

Exemple :
Ecrire une fonction f qui calcule n!/p! avec n>=0 et p>=0
On désire simplifer le calcul. On calculera dans le cas général n(n-1)(n-2)...(p+1)
Cas A :
Si n ou p sont négatifs nous sommes en présence d'une exception.
Si on a n

Récursivité terminale :
Une fonction est récursive terminale quand le calcul d'un résultat intermédiaire est réalisé avant
l'appel récursif de la fonction. On utilisera un accumulateur pour empiler les résultats
intermédiaires. Au premier appel de la fonction on fournira la valeur initiale de l' accumulateur.
On utilise deux fonctions
Une fonction principale non récursive qui gère
• La gestion des exceptions
S'il existe des exceptions, la fonction vérife si les arguments fournis lors de
l'appel appartiennent au domaine de validité. Si une exception est
rencontrée la fonction ne réalise pas le calcul. On utilise les fonctions
prédéfnies failwith ou assert pour interrompre l'exécution de la fonction.
• La gestion des cas particuliers
S'il existe des cas particuliers, ils sont gérés dans la fonction principale. Il
s'agit de cas qui retourne un résultat prévu mais qui n'utilise pas
l'algorithme général.
• Le premier appel de la fonction auxiliaire récursive.
Lors de cet appel on fournira la valeur initiale de l'accumulateur suivi des
arguments de la fonction initiale. L'accumulateur est utilisé pour réaliser
les calculs intermédiaires.
Une fonction auxiliaire récursive qui gère
• le cas simple :
Dans le cas simple la fonction ne s'appelle pas elle-même.
On défnit un critère d'arrêt de la fonction ainsi que le résultat de la
fonction. Ce résultat correspond au résultat fnal de la fonction, il est
présent dans l'accumulateur.
• le cas général :
Dans le cas général un calcul intermédiaire est réalisé avant l'appel récursif
de la fonction, ce calcul modife la valeur de l'accumulateur. L'appel récursif
empile les appels de la fonction.
let f n p =
let rec calcul accumulateur n p =
if n=p then accumulateur
else calcul (n*accumulateur) (n-1) p
in
if n

Exemple factorielle de n :
Récursivité classique :
let rec f n = if n

Rappel : On dispose en ocaml
• d'un module Random qui contient des fonctions qui permettent de réaliser des
tirages aléatoires. La fonction Random.int appelée avec un argument x
retourne un entier compris entre 0 et x-1.
Random.int max → entier entre 0 et max-1
Random.int (max+1) → entier entre 0 et max
Random.int max + 1 → entier entre 1 et max
• D'une fonction prédéfinie read_int qui permet de lire un entier saisi au
clavier.
• D'une fonction prédéfinie List .map qui permet d'appliquer une fonction f à
l'ensemble des éléments d'une liste afin de générer une nouvelle liste
[a1;a2;...;an] -> [f a1;f a2;..;f an]
let rec map f liste =
match liste with
|[] -> []
|h::t -> f h::map f t;;

Exercices complémentaires :
a. Création d'une liste d'entiers qui contient les n premiers entiers > 0
Récursivité classique :
let rec create_first_n_strictly_positive_integers_list n =
match n=0 with
|true -> []
|_ -> n::create_first_n_strictly_positive_integers_list (n-1);;
val create_first_n_strictly_positive_integers : int -> int list =
create_first_n_strictly_positive_integers_list 6;;
- : int list = [6; 5; 4; 3; 2; 1]
Les entiers sont ordonnées par ordre décroissant. Si on désire les ordonner par ordre
croissant on utilisera l'opérateur de concaténation au lieu de l'opérateur d'insertion pour
construire la liste.
let rec create_first_n_strictly_positive_integers_list n =
match n=0 with
|true -> []
|_ -> create_first_n_strictly_positive_integers_list (n-1)@[n];;
val create_first_n_strictly_positive_integers : int -> int list =
create_first_n_strictly_positive_integers_list 6;;
- : int list = [1; 2; 3; 4; 5; 6]
Récursivité terminale :
let create_first_n_strictly_positive_integers_list n =
let rec auxiliaire accumulateur n =
match n=0 with
|true -> accumulateur
|_ -> auxiliaire (n::accumulateur) (n-1)
in
auxiliaire [] n;;
val create_first_n_strictly_positive_integers_list : int -> int list =
create_first_n_strictly_positive_integers_list 6;;
- : int list = [1; 2; 3; 4; 5; 6]

. Création d'une liste de n entiers tirés aléatoirement entre a et b.
Nombre de valeurs possible : b-a+1
Tirage aléatoire : Random.int (b-a+1)
Résultat compris entre : 0 et b-a
Plus petite valeur possible : a
Plus grande valeur possible : b
Tirage aléatoire d'un entier compris entre a et b : Random.int (b-a+1) + a
Récursivité classique :
let rec create_randomly_integers_list n a b =
match n=0 with
|true -> []
|_ -> let x = (Random.int (b-a+1) + a) in
x::create_randomly_integers_list (n-1) a b;;
val create_randomly_integers_list : int -> int -> int -> int list =
Récursivité terminale :
let create_randomly_integers_list n a b =
let rec auxiliaire accumulateur n =
match n=0 with
|true -> accumulateur
|_ -> let x = (Random.int (b-a+1) + a) in
auxiliaire (x::accumulateur) (n-1)
in
auxiliaire [] n;;
val create_first_n_strictly_positive_integers_list : int -> int list =

Exercice 1
1°/ Ecrire une fonction récursive qui permet de rentrer au clavier, les éléments d'une liste
d'entiers positifs ou nuls, la saisie s'arrête quand la valeur entrée est négative.
a. Création d'une nouvelle liste
Récursivité classique :
let rec lire_int_list () =
let x = read_int() in
if x int list =
L'absence d'argument d'une fonction doit être représenté par les parenthèses () dans l'en-ête de la
fonction et lors de l'appel de la fonction.
lire_int_list;;
- : unit -> int list =
lire_int_list ();;
1
2
3
-1
- : int list = [1; 2; 3]
Récursivité terminale :
let lire_int_list () =
let rec aux accumulateur =
let x = read_int() in
if x

lire_int_list ();;
1
2
3
-1
- : int list = [3; 2; 1]
La liste est inversée.
let lire_int_list () =
let rec aux accumulateur =
let x = read_int() in
if x int list =
lire_int_list ();;
1
2
3
-1
- : int list = [1; 2; 3]

. Complétez une liste
Récursivité classique :
let rec complete liste =
let x = read_int() in
if x int list =
complete [5;8];;
1
2
-1
- : int list = [1; 2; 5; 8]
Récursivité terminale :
let complete liste =
let rec aux accumulateur liste =
let x = read_int() in
if x int list =
complete [5;8];;
1
2
-1
- : int list = [2; 1; 5; 8]
let complete liste =
let rec aux accumulateur liste =
let x = read_int() in
if x int list =
complete [5;8];;
1
2
-1
- : int list = [1; 2; 5; 8]

2°/ Ecrire une fonction qui permet d’afficher les valeurs contenues dans une liste d'entier à
raison d'une valeur par ligne.
Récursivité classique ou terminale ?
let rec affiche_int_list liste =
match liste with
|[] -> ()
|h::t -> begin
end;;
val affiche_int_list : int list -> unit =
affiche_int_list [1;2;3];;
1
2
3
- : unit = ()
print_int h;
print_newline ();
affiche_int_list t
let rec affiche_int_list liste =
match liste with
|[] -> ()
|h::t -> print_int h;print_newline ();affiche_int_list t;;
Récursivité classique
let rec affiche_int_list liste =
match liste with
|[] -> []
|h::t -> print_newline ()::print_int h::affiche_int_list t;;
val affiche_int_list : int list -> unit list =
affiche_int_list [1;2;3];;
3
2
1
- : unit list = [(); (); (); (); (); ()]

Récursivité terminale
let affiche_int_list liste =
let rec aux accumulateur liste =
match liste with
|[] -> accumulateur
|h::t -> aux (print_newline ()::print_int h::accumulateur) t
in
aux [] liste;;
affiche_int_list [1;2;3];;
1
2
3
- : unit list = [(); (); (); (); (); ()]

3°/ Ecrire une fonction qui affiche sur une ligne de l'écran, un nombre de X égal à la valeur de
l'élément de la liste, et cela pour tous les termes de la liste en respectant l'ordre.
3°.a/ Fonction ligne qui affiche n fois le caractère c sur une ligne puis passe à la ligne.
Récursivité classique
let ligne c n =
let rec affiche c n =
if n=0 then []
else print_char c::affiche c (n-1)
in
print_newline ()::affiche c n;;
val affiche_char : char -> int -> unit list =
ligne 'X' 5;;
XXXXX
- : unit list = [(); (); (); (); (); ()]
La fonction principale affiche_char, n'est pas récursive, elle initialise le premier appel de la fonction
récursive affiche. Après exécution de la fonction affiche on exécute la fonction print_newline () qui
assure le passage à la ligne.
Récursivité terminale traditionnelle
let ligne c n =
let rec affiche acc c n =
if n=0 then print_newline ()
else affiche (print_char c) c (n-1)
in
affiche () c n;;
val ligne : char -> int -> unit =
ligne 'X' 5;;
XXXXX
- : unit = ()
Récursivité terminale s'appliquant à un affichage donc à un résultat de type unit → cas où on peut se
passer de l'accumulateur.
let rec ligne c n =
if n=0 then print_newline ()
else print_char c;ligne c (n-1);;
ou encore
let rec ligne c n =
if n=0 then print_newline ()
else begin
print_char c;
ligne c (n-1)
end;;
val ligne : char -> int -> unit =

Exemple complémentaire:
Fonction affiche_int qui affiche les n premiers entiers > 0 sur une ligne puis passe à la ligne.
Récursivité classique
let affiche_int n =
let rec affiche n =
if n=0 then []
else print_int n::affiche (n-1)
in
print_newline ()::affiche n;;
val affiche_int : int -> unit list =
affiche_int 4;;
1234
- : unit = ()
Remarquez l'ordre dans lequel les entiers sont affichés. Le premier affichage est réalisé quand on a
rencontré le cas simple. Le premier entier affiché sera donc 1.
Récursivité terminale
let affiche_int n =
let rec affiche acc u n =
if acc>n then print_newline ()
else affiche (acc+1) (print_int acc) n
in
affiche 1 () n;;
val affiche_int : int -> unit list =
affiche_int 4;;
1234
- : unit = ()
L'accumulateur n'est pas utilisé. On peut aussi écrire :
let rec affiche_int n =
if n=0 then print_newline ()
else
begin
print_int n;affiche_int (n-1)
end;;
affiche_int 4;;
4321
- : unit = ()

let rec affiche_int n =
if n=0 then print_newline ()
else
begin
affiche_int (n-1);print_int n
end;;
affiche_int 4;;
1234- : unit = ()
let affiche_int n =
let rec affiche n =
if n=0 then ()
else
begin
affiche (n-1);print_int n
end
in
affiche n;print_newline ();;
val affiche_int : int -> unit -> unit =
affiche_int 4;;
1234
- : unit = ()

3°.b/ Fonction histogramme qui affiche un histogramme horizontal représentant les entiers
contenus dans une liste.
Unit list :
Récursivité classique
let rec histogramme liste =
match liste with
|[] -> []
|h::t -> ligne 'X' h::histogramme t;;
val histogramme : int list -> unit list list =
histogramme [1;2;3];;
XXX
XX
X
- : unit list = [(); (); ()]
Récursivité terminale
let histogramme liste =
let rec aux accumulateur liste =
match liste with
|[] -> accumulateur
|h::t -> aux (ligne 'X' h::accumulateur) t
in
aux [] liste;;
val histogramme : int list -> unit list list =
histogramme [1;2;3];;
X
XX
XXX
- : unit list = [(); (); ()]
Unit
let rec histogramme liste =
match liste with
|[] -> ()
|h::t -> begin ligne 'X' h; histogramme t end;;

4°/ Ecrire une fonction qui permet d'augmenter de la valeur constante 3, tous les éléments de
la liste.
let rec augmente liste x =
match liste with
|[] -> []
|h::t -> (+) h x::(augmente t x);;
val augmente : int list -> int -> int list =
augmente [1;8;7] 3;;

5°/ Ecrire une fonction qui, à partir d'une liste, permet de créer une nouvelle liste comportant
le même nombre d'éléments, dont le premier élément est égal à la moyenne des deux premiers
termes de la liste, le dernier est égal à la moyenne des deux derniers termes de la liste et dont
les autres sont égaux à la moyenne de trois termes, la valeur de l’élément au rang j de la liste
et les valeurs des termes immédiatement avant et après dans la liste (j-1 et j+1). On affichera
les nouvelles valeurs contenues dans la liste ainsi construite. Les moyennes se calculent à
partir des valeurs de la liste initiales. On admet que la longueur de la liste en argument est
supérieure ou égale à 2.
On pourra construire des listes auxiliaires pour simplifier les calculs.
let rec lisse liste =
let rec calcul liste =
match liste with
|h1::h2::[] -> [(h1+h2)/2]
|h1::h2::h3::t -> ((h1+h2+h3)/3)::calcul (h2::h3::t)
|_ -> failwith "cas impossible"
in
match liste with
|[] -> []
|h::[] -> [h]
|h1::h2::[] -> [(h1+h2)/2;(h1+h2)/2]
|h1::h2::h3::t -> ((h1+h2)/2)::calcul liste;;
let lisse liste =
let rec calcul accumulateur liste =
match liste with
|h1::h2::[] -> accumulateur@[(h1+h2)/2]
|h1::h2::h3::t -> calcul (accumulateur@[(h1+h2+h3)/3]) (h2::h3::t)
in
match liste with
|[] -> []
|h::[] -> [h]
|h1::h2::[] -> [(h1+h2)/2;(h1+h2)/2]
|h1::h2::t -> calcul [(h1+h2)/2] liste;;
let rec lissage_stable liste =
let nouvelle_liste = lisse liste in
if nouvelle_liste = liste then liste
else lissage_stable nouvelle_liste;;

2°/ Ecrire la fonction puissance comportant 2 variables x et n, de manière récursive.
On proposera deux solutions récursives dont l'une terminale.
let rec puissance x n =
match n=0 with
|true -> 1
|_ -> x*puissance x (n-1);;
puissance x n n-1 Critère d'arrêt :
n=0
x*puissance x (n-1) Résultat
16 Retour 5
Appel 1 2 4 3 false 16 8 Retour 4
Appel 2 2 3 2 false 8 4 Retour 3
Appel 3 2 2 1 false 4 2 Retour 2
Appel 4 2 1 0 false 2 1 Retour 1
Appel 5 2 0 true
let puissance x n =
let rec auxiliaire accumulateur x n =
match n=0 with
|true -> accumulateur
|_ -> auxiliaire x*accumulateur x (n-1)
in
auxiliaire 1 x n;;
auxiliaire x n n-1 n=0 accumulateur x*accumulateur Résultat
16 Retour 5
Appel 1 2 4 3 false 1 2 16 Retour 4
Appel 2 2 3 2 false 2 4 16 Retour 3
Appel 3 2 2 1 false 4 8 16 Retour 2
Appel 4 2 1 0 false 8 16 16 Retour 1
Appel 5 2 0 true 16

Exercices complémentaires :
• Inversion d'une liste :
let inverse liste =
let rec auxiliaire accumulateur liste =
match liste with
|[] -> accumulateur
|h::t -> auxiliaire (h::accumulateur) t
in
auxiliaire [] liste;;
val inverse : 'a list -> 'a list =
auxiliaire liste h t liste=[] accumulateur h::accumulateur Résultat
[5;4;3;2] Retour 5
Appel 1 [2;3;4;5] 2 [3;4;5] false [] [2] [5;4;3;2] Retour 4
Appel 2 [3;4;5] 3 [4;5] false [2] [3;2] [5;4;3;2] Retour 3
Appel 3 [4;5] 4 [5] false [3;2] [4;3;2] [5;4;3;2] Retour 2
Appel 4 [5] 5 [] false [4;3;2] [5;4;3;2] [5;4;3;2] Retour 1
Appel 5 [] true [5;4;3;2]

Perfectionnement :
• Ecrire la fonction récursive terminale calcul_terminal qui applique à une liste la fonction f
en utilisant un accumulateur.
Le calcul d'un résultat intermédiaire s'appliquant à la tête de la liste (nouvelle valeur de
l'accumulateur) est réalisé avant l'appel récursif de la fonction qui s'appliquera au reste de la
liste.
Au premier appel de la fonction l'accumulateur aura pour valeur le résultat quand la liste est
vide (initialisation de l'accumulateur).
let rec calcul_terminal accumulateur liste f =
match liste with
|[] -> accumulateur
|h::t -> calcul_terminal (f h accumulateur) t f ;;
val calcul_terminal : 'a -> 'b list -> ('b -> 'a -> 'a) -> 'a =
• Ecrire la fonction récursive calcul qui applique à une liste la fonction f en lui fournissant le
résultat correspondant au cas simple.
Le calcul d'un résultat intermédiaire s'appliquant à la tête de la liste sera réalisé quand on
disposera du résultat pour le reste de la liste.
Au premier appel de la fonction on fournira le résultat quand la liste est vide.
let rec calcul liste f resultat_simple =
match liste with
|[] -> resultat_simple
|h::t -> f h (calcul t f resultat_simple);;
val calcul : 'a list -> ('a -> 'b -> 'b) -> 'b -> 'b =
let s_xpn x n r = x**n +. r;;
val s_xpn : float -> float -> float -> float =
calcul_terminal 0. [1.;2.;3.] (sn 3.);;
- : float = 39.
On calcule la somme des puissances de 3 pour les exposants présents dans la liste.
3**1 + 3**2 + 3**3 = 39
let s_npx x n r = n**x +. r;;
val s_npx : float -> float -> float -> float =
calcul_terminal 0. [1.;2.;3.] (s_npx 3.);;
- : float = 36.
On calcule la somme des éléments de la liste élevés à la puissance 3.
1.**3. +. 2.**3. +. 3.**3. = 36.
calcul_terminal 0 [1;2;3] (fun x r -> (x mod 2) + r);;

Calculez la somme des entiers de la liste [9;8;10;7;5;2]
calcul [9;8;10;7;5;2] (+) 0;;
- : int = 41
Concaténez les chaînes de caractères de la liste ["un ";"deux ";"trois "]
calcul_terminal ["un ";"deux ";"trois "] (^) "";;
- : string = "trois deux un "
calcul_terminal (inverse ["un ";"deux ";"trois "]) (^) "";;
- : string = "un deux trois "
• Ecrire la fonction récursive terminale calcul_conditionnel_terminal qui applique la
fonction f aux éléments d'une liste qui respecte le prédicat p.
let rec calcul_conditionnel_terminal liste f p accumulateur =
match liste with
|[] -> accumulateur
|h::t -> if p h then calcul_conditionnel_terminal (f h accumulateur) t f p
else calcul_conditionnel_terminal accumulateur t f p;;
val calcul_conditionnel _terminal:
'a -> 'b list -> ('b -> 'a -> 'a) -> ('b -> bool) -> 'a =
• Ecrire la fonction récursive terminale calcul_conditionnel qui applique la fonction f aux
éléments d'une liste qui respecte le prédicat p.
let rec calcul_conditionnel liste f p resultat_simple =
match liste with
|[] -> resultat_simple
|h::t -> if p h then f h (calcul_conditionnel t f p resultat_simple)
else calcul_conditionnel t f p resultat_simple;;
val calcul_conditionnel : 'a -> 'b list -> ('b -> 'a -> 'a) -> ('b -> bool) -> 'a =
Calculez la somme des entiers pairs de la liste [9;8;10;7;5;2]
calcul_conditionnel 0 [9;8;10;7;5;2] (+) (fun x -> x mod 2 = 0);;
Ecrire une fonction entiers_positifs qui construit une liste constituée des entiers positifs
présents dans une liste d'entiers.
let entiers_positifs liste =
calcul_conditionnel liste (fun h liste -> h::liste) (fun x -> x>=0) [];;
let entiers_positifs liste =
let positif x = x>=0 in
let insere h liste = h::liste in
calcul_conditionnel liste insere positif [];;