Algorithmique Correction Contrôle no 1 (C1) - Algo, la page

Algorithmique
Correction Contrôle no 1 (C1)
Info-sup (S1) Epita
10 nov 2014 - 10 :00
Solution 1 (Types Abstraits : Listes récursives 5 points )
1. L'opération rechercher n'est dénie que si l'élément recherché existe, d'où précondition. Ensuite les
trois axiomes appliquant l'observateur est-présent aux opérations internes liste-vide et cons.
Dans l'ordre : l'élément e n'existe pas dans une liste-vide, l'élément e existe dans une liste dont
il est égal au premier élément et dans le cas contraire... Essaie encore (il existe peut-être dans la
liste restante). Enn l'axiome expliquant que la place retournée par rechercher(e,λ) est celle qui
contient e.
préconditions
rechercher (e,
axiomes
λ) est-déni-ssi est-présent (e,λ)= vrai
est-présent (e, listevide) = faux
e = e′ ⇒ est-présent (e, cons(e′ , λ))
e ̸= e′ ⇒ est-présent (e, cons(e′ , λ))
contenu (rechercher(e, λ)) = e
= vrai
= est-présent (e, λ)
2. Deux axiomes suront, le premier explique que le résultat de la concaténation d'une liste vide avec
une liste λ est la liste λ, ce qui signie que l'on conserve les éléments en ordre et nombre de la
deuxième liste. Le second axiome explique que l'on conserve aussi les éléments en ordre et nombre
de la première liste. Comment ? En montrant que si l'on fait la concaténation avant ou après la
construction (cons), le résultat est le même, ce qui signie que la concaténation ne modie ni l'ordre,
ni les éléments.
axiomes
concaténer
concaténer
(listevide, λ2) = λ2
(cons(e, λ), λ2) = cons(e, concaténer (λ, λ2))
1
Algorithmique
Info-sup (S1)
Epita
Correction Contrôle no 1 (C1) D.S. 309858.67 BW
Solution 2 (Find it 5 points )
1. Spécications :
La fonction find_place prend en paramètre une fonction de test : f ainsi qu'une liste :
[a1 ; a2 ; · · · ; an ]. Elle recherche dans la liste la première valeur ai telle que f (ai ) soit vrai et
retourne le rang i correspondant. Elle déclenche une exception si aucune valeur n'a été trouvée.
♯ let find_place f list =
let rec find i = function
[] -> failwith "find_place: not found"
| e::l -> if f e then
i
else
find (i+1) l
in
find 1 list ;;
val find_place : ('a -> bool) -> 'a list -> int = <fun>
♯ let rec find_place p = function
(* another version *)
[]
-> failwith "find_place: not found"
| e::_ when p e -> 1
| _::l
-> 1 + find_place p l ;;
val find_place : ('a -> bool) -> 'a list -> int = <fun>
2. Spécications :
La fonction find_odd retourne la position du premier entier impair trouvé dans la liste passée
en paramètre.
♯ let find_odd = find_place (function x -> x mod 2 = 1) ;;
val find_odd : int list -> int = <fun>
2
Algorithmique
Info-sup (S1)
Epita
Correction Contrôle no 1 (C1) D.S. 309858.67 BW
Solution 3 (Test it 5 points )
1. Spécications :
La fonction test prend en paramètre une fonction de comparaison : f ainsi qu'une liste. Elle
vérie si la liste est triée selon la fonction f .
♯ let rec test_order f = function
[] | _::[] -> true
| e1::e2::l -> f e1 e2 && test_order f (e2::l) ;;
val test_order : ('a -> 'a -> bool) -> 'a list -> bool = <fun>
(* another version *)
♯ let rec test_order f = function
[] | _::[]
-> true
| e1::e2::l when f e1 e2 -> test_order f (e2::l)
| _
-> false ;;
val test_order : ('a -> 'a -> bool) -> 'a list -> bool = <fun>
2. Spécications :
La fonction is_geometric prend en paramètre un entier q et une liste l. Elle vérie si l suit
une progression arithmétique de raison q .
♯ let is_geometric q = test_order (function e1 -> function e2 -> e2 = q*e1) ;;
val is_geometric : int -> int list -> bool = <fun>
Solution 4 (Combine it 5 points )
Spécications :
La fonction combfilter prend en paramètre une fonction à deux paramètres : f
ainsi que deux listes : [a1 ; a2 ; · · · ; an ] et [b1 ; b2 ; · · · ; bn ].
Elle construit la liste des (ai , bi ) tels que f ai bi est vrai. L'ordre des éléments des listes initiales est
préservé.
Elle déclenche une exception si les deux listes sont de longueurs diérentes.
let rec combfilter p list1 list2 =
match (list1,list2) with
([],[])
-> []
| (_,[])|([],_) -> failwith "different lengths"
| (e1::l1,e2::l2) ->
if p e1 e2 then
(e1,e2) :: combfilter p l1 l2
else
combfilter p l1 l2 ;;
val combfilter : ('a -> 'b -> bool) -> 'a list -> 'b list -> ('a * 'b) list = <fun>
3