CamL Light : profondeur d'un type

Résolu
Étienne9 Messages postés 1022 Date d'inscription   Statut Membre Dernière intervention   -  
KX Messages postés 16761 Date d'inscription   Statut Modérateur Dernière intervention   -
Bonjour à tous,

J'ai ce type :
type kAtome = Rien | Tout
| Ent of int
| Car of char
| Lst of kAtome list;;

Et j'aimerais calculer la profondeur.
La profondeur initiale est 0.
Voici ce que j'ai fait mais cela ne marche pas :

let profondeur =
let rec profondeurbis = fun
Rien res -> res
| Tout res -> res
| Ent(a) res -> res
| Car(a) res -> res
| (Lst(a)::b) res -> max (profondeurbis a res+1) (profondeurbis b res)
| (a::b) res -> profondeurbis b
and
let max = fun
a b when a > b -> a
| a b -> b
in
function a -> profondeurbis a 0;;

Exemples :
L'appel de Lst([Tout]) renvoie 0
L'appel de Lst([Lst([Tout])]) renvoie 1

Merci beaucoup d'avance.




A voir également:

9 réponses

KX Messages postés 16761 Date d'inscription   Statut Modérateur Dernière intervention   3 020
 
Je ne comprends pas ce que tu veux faire, déjà ce ne sera pas la profondeur du type, mais de sa valeur. De plus tu ne peux pas faire "Tout res" car Tout n'est pas un type of, c'est un terminal, idem pour Rien.
De plus je ne comprends pas pourquoi "profondeur (Lst [Tout])" renvoie 0, parce que dans ce cas que vaudrait "profondeur Tout" ?

Bref, c'est très confus, qu'est-ce que tu veux faire exactement ?

Sans plus d'informations, moi je ne verrais que ça :

let rec profondeur = function
| Lst (x::y) -> 1 + max (profondeur x) (profondeur (Lst y))
| _ -> 0;;

profondeur Tout;;
profondeur (Lst [Tout]);;
profondeur (Lst [Lst [Tout]]);;
profondeur (Lst [Lst [Tout]; Lst [Tout]]);;
...
0
Étienne9 Messages postés 1022 Date d'inscription   Statut Membre Dernière intervention   49
 
Salut KX,

Voici le sujet en PDF il a deux pages :
https://www.fichier-pdf.fr/2013/01/09/fonctionnel-2eme-session/preview/page/1/

J'essaie de faire l'exercice 3 mais je n'arrive à faire que la question 1.

Cordialement et merci :)
0
Étienne9 Messages postés 1022 Date d'inscription   Statut Membre Dernière intervention   49
 
J'ai prix ce que vous avez fait mais j'ai mis -1 à la place de 0.
Ainsi Lst(....) ça donnera 0
Pour le Tout et Rien tout seul ça donnera -1
et pour le Lst(Lst...)) ça donnera 1 et ainsi de suite...
Pour substituer je ne vois pas comment faire...
0
KX Messages postés 16761 Date d'inscription   Statut Modérateur Dernière intervention   3 020
 
"je n'arrive à faire que la question 1"
Si tu dis que "Lst([Tout]) renvoie 0" et "Lst([Lst([Tout])]) renvoie 1", cela signifie que tu considères que ce sont des exemples de k-liste, alors que non, ce sont des kAtome. Donc ta question 1 est a priori déjà fausse...

Voici des exemples corrects de k-listes pour ta question 1, ça t'aidera sûrement à mieux comprendre ce qu'il faut faire pour ta question 2 :

Profondeur 0 :
[Rien; Tout; Ent 5; Car 'a'];;
Profondeur 1 :
[Tout; Lst [Car 'a'; Ent 5]; Lst [Rien]];;
Profondeur 2 :
[Car 'a'; Lst [ Lst [Tout; Ent 5]; Rien]];;
La confiance n'exclut pas le contrôle
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Étienne9 Messages postés 1022 Date d'inscription   Statut Membre Dernière intervention   49
 
D'accord ! Moi je pensais que le constructeur était Lst et que sans le Lst on ne pouvait rien faire.
0
Étienne9 Messages postés 1022 Date d'inscription   Statut Membre Dernière intervention   49
 
let rec substituer = fun
k1 k2 Lst(a::b)::c when a = k2-> Lst(k2::substituer k1 k2 b)::(substituer k1 k2 c)
| k1 k2 Lst(a::b)::c -> Lst(a::substituer k1 k2 b)::substituer k1 k2 c
| k1 k2 Lst(a::b) when a = k2 -> Lst(k2::substituer k1 k2 b)
| k1 k2 Lst(a::b) -> Lst(a::substituer k1 k2 b)
| k1 k2 (a::c) when k1 = a -> k2::subtituer k1 k2 c
| k1 k2 (a::c) -> a::substituer k1 k2 c;;

Je ne sais pas pourquoi mais à chaque fois je cherche compliqué du coup je n'y arrive pas...
0
KX Messages postés 16761 Date d'inscription   Statut Modérateur Dernière intervention   3 020
 
Déjà, je ne crois pas que la notation "fun" soit autorisée, il faudrait mettre "function", de plus tu ne peux remplacer qu'un paramètre par cette fonction lambda, c'est à dire qu'ici tu fais une fonction à un seul argument (on t'en demande trois) ce qui rend ton pattern matching totalement faux...

Voici le bon début :

(* substituer : kAtome -> kAtome -> kAtome list -> kAtome list = <fun> *)
let rec substituer k1 k2 = function ...
0
Étienne9 Messages postés 1022 Date d'inscription   Statut Membre Dernière intervention   49
 
Bonsoir KX,

J'ai un examen demain demain et si je ne comprends pas cet exercice et qu'un exercice de ce type tombe je suis mal barré.

Je dois en plus me coucher de bonne heure...

Bye. Je vais au lit, merci encore.
0
KX Messages postés 16761 Date d'inscription   Statut Modérateur Dernière intervention   3 020
 
Pour info, voici une "correction", bon courage !

let rec profondeur = function
| Lst x::y -> max (1 + profondeur x) (profondeur y)
| _::y -> profondeur y
| [] -> 0;;

let rec substituer k1 k2 = function
| x::y when x=k1 -> k2::(substituer k1 k2 y)
| Lst x::y -> Lst (substituer k1 k2 x)::(substituer k1 k2 y)
| x::y -> x::(substituer k1 k2 y)
| [] -> [];;
La confiance n'exclut pas le contrôle
0