sujet caml - Page 1

salut a tous (et a toutes),

j'ai un sujet a rendre en caml et le caml, c'est pas trop ma tasse de the ...

Si qq'un pourrait m'aider, ca serait sympa de sa part !

Voila je sujet:






Il s’agit de réaliser une application en langage Caml permettant d’analyser un arbre binaire suivant certains critères. Les arbres binaires susceptibles d’être analysés pourront contenir un ensemble d’informations quelconques.
Dans une première phase, on définira les éléments nécessaires (type polymorphe et fonction générique) à l’analyse de l’arbre.
Dans une deuxième phase, on étudiera plus précisément un cas spécifique d’arbre binaire : un arbre généalogique inversé (une personne est à la racine de l’arbre, ses parents sont au 2ème niveau, ..., ses ancêtres sont les feuilles de l’arbre.)
Première phase

1. Définir un type polymorphe permettant de représenter un arbre binaire quelconque.

Exemple : #type 'a tree = Leaf of 'a | Node of 'a tree * 'a tree;;
Le type ‘a tree ainsi défini est un noeud d’un arbre binaire qui est :
- soit une feuille contenant une entité de type ‘a,
- soit un noeud interne contenant un fils gauche et un fils droit, tous deux de même type que leur père, codés sous la forme d’un couple.

2. Définir une fonction générique récursive prenant en argument une fonction f et un arbre binaire et qui retourne la liste des résultats de l’application de f à tous les noeuds de l’arbre.

Exemple : soit un type d’arbre binaire dont les feuilles (uniquement) contiennent des valeurs entières, défini comme suit :
#type inttree = Leaf of int | Node of inttree * inttree;;
Une fonction calculant la somme des entiers d'un tel arbre sera :
#let rec total = fun (Leaf n) -> n
| (Node (t1,t2)) -> total t1 + total t2;;
Remarque : dans cet exemple, uniquement les feuilles contiennent des valeurs ce qui n’est pas le cas du type demandé à la question précédente.

Deuxième phase

1. Définir un type particulier permettant de représenter un type contenant les informations suivantes :
- nom de la personne : chaîne de caractères
- année de naissance : entier
- année de décès : entier
- nationalité : chaîne de caractères

2. Définir une fonction prenant en argument une entité e du type défini à la question précédente et une chaîne de caractères ch et qui retourne 1 si ch est identique à la nationalité de e et 0 sinon.

3. En utilisant tout ce qui a été défini précédemment, écrire la fonction permettant de dénombrer les personnes d’un arbre généalogique qui sont d’une même nationalité donnée en argument d’entrée.

4. Définir et initialiser une variable globale décrivant un exemple d’arbre généalogique inversé. Tester vos fonctions avec cette variable.

t'aider mais comment ? qu'est-ce que tu comprends pas ?
parce qu'il est certain que personne ici ne le fera à ta place.

tamara :
salut a tous (et a toutes),

j'ai un sujet a rendre en caml et le caml, c'est pas trop ma tasse de the ...

Si qq'un pourrait m'aider, ca serait sympa de sa part !

Voila je sujet:

hum, ya deja presque toutes les réponses dans les exemples ...

1. Définir un type polymorphe permettant de représenter un arbre binaire quelconque.
Exemple : #type 'a tree = Leaf of 'a | Node of 'a tree * 'a tree;;

genre là t'as presque rien a faire
il suffit juste que tu rajoute une valeur sur chaque noeud (on va dire qu'on ne compte pas les arbres vides et que les données des feuilles sont du meme type que celles des noeuds ...)

#type 'a arbre = 
   | Feuille of 'a
   | Noeud of 'a arbre * 'a * 'a arbre ;;
Type arbre defined.

2. Définir une fonction générique récursive prenant en argument une fonction f et un arbre binaire et qui retourne la liste des résultats de l’application de f à tous les noeuds de l’arbre.

Exemple : soit un type d’arbre binaire dont les feuilles (uniquement) contiennent des valeurs entières, défini comme suit :
#type inttree = Leaf of int | Node of inttree * inttree;;
Une fonction calculant la somme des entiers d'un tel arbre sera :
#let rec total = fun (Leaf n) -> n
| (Node (t1,t2)) -> total t1 + total t2;;
Remarque : dans cet exemple, uniquement les feuilles contiennent des valeurs ce qui n’est pas le cas du type demandé à la question précédente.

bon bah tu vais presque comme dans l'exemple aussi

#let rec applique f = function
 | Feuille x -> [f(x)]
 | Noeud(fg,x,fd) -> (applique f fg)@((f x):: (applique f fd)) ;;
applique : ('a -> 'b) -> 'a arbre -> 'b list = <fun>

#let arbre_test = Noeud(Noeud(Feuille 1, 2, Feuille 3),4,Noeud(Feuille 5,6,Feuille 7));;
arbre_test : int arbre =
 Noeud (Noeud (Feuille 1, 2, Feuille 3), 4, Noeud (Feuille 5, 6, Feuille 7))

#let f x = x*x ;;
f : int -> int = <fun>

#applique f arbre_test ;;
- : int list = [1; 4; 9; 16; 25; 36; 49]

1. Définir un type particulier permettant de représenter un type contenant les informations suivantes :
- nom de la personne : chaîne de caractères
- année de naissance : entier
- année de décès : entier - nationalité : chaîne de caractères

#type qqun = {
	nom    : string ;
	naiss  : int    ;
	deces  : int    ;
	nation : string   } ;;
Type qqun defined.

2. Définir une fonction prenant en argument une entité e du type défini à la question précédente et une chaîne de caractères ch et qui retourne 1 si ch est identique à la nationalité de e et 0 sinon.

#let bonne_nation s = function
  | e when s=e.nation -> 1
  | _ -> 0 ;;
bonne_nation : string -> qqun -> int = <fun>

3. En utilisant tout ce qui a été défini précédemment, écrire la fonction permettant de dénombrer les personnes d’un arbre généalogique qui sont d’une même nationalité donnée en argument d’entrée.

#let nombre_nation arbre nation =
 let rec somme = function
   | [] -> 0
   | t::q -> t+(somme q)
 in somme (applique (bonne_nation nation) arbre) ;;
nombre_nation : qqun arbre -> string -> int = <fun>

4. Définir et initialiser une variable globale décrivant un exemple d’arbre généalogique inversé. Tester vos fonctions avec cette variable.

je vois pas bien pourquoi "inversé" et j'ai la flemme de rentrer plein de truc mais bon

#let moi = { nom = "moi" ; naiss = 0 ; deces = 123 ; nation = "yN" } ;;
moi : qqun = {nom = "moi"; naiss = 0; deces = 123; nation = "yN"}
#let arbre_gene = Noeud(Noeud(Feuille moi, moi, Feuille moi),moi,Noeud(Feuille moi,moi,Feuille moi));;
arbre_gene : qqun arbre =
 Noeud
  (Noeud
    (Feuille {nom = "moi"; naiss = 0; deces = 123; nation = "yN"},
     {nom = "moi"; naiss = 0; deces = 123; nation = "yN"},
     Feuille {nom = "moi"; naiss = 0; deces = 123; nation = "yN"}),
   {nom = "moi"; naiss = 0; deces = 123; nation = "yN"},
   Noeud
    (Feuille {nom = "moi"; naiss = 0; deces = 123; nation = "yN"},
     {nom = "moi"; naiss = 0; deces = 123; nation = "yN"},
     Feuille {nom = "moi"; naiss = 0; deces = 123; nation = "yN"}))
#nombre_nation arbre_gene "yN" ;;
- : int = 7

j'ai fait ca vite fait et sans explications, si tu comprend pas un truc, n'hesite pas.

Ca devrait meme pas exister ce langage

un peu comme tes vannes

je vanne jamais moi

+correctement ouais

espece de vieu geek va !
va plutot rechercher une FAC ou alors te faire prendre (en anglais si tu veux) plutot que de raconter des conneries sur des personnes aussi gentilles et innocentes que moi

deja que tu dis pas mal de la merde mais alors là ceux qui sont pas au courant des vannes ils doivent bien s'en rendre compte

c etonnant en plus

arrete de flooder un topic sur un langage qui poutre !

oui mossieur

merci bcoup Nheryvra de m'avoir repondu si vite !

quel langage as tu utilise au fait??

caml light ? o-caml??

car dans une des fonctions que tu as ecrite, tu as utilise "when" et je n'ai jamais vu ca ds mes cours !


de plus, dans cette question: définir une fonction prenant en argument une entité e du type défini à la question précédente et une chaîne de caractères ch et qui retourne 1 si ch est identique à la nationalité de e et 0 sinon.

je crois que tu as oublie "ch".

merci et a plus tard.

c'est du caml ligth

tamara :
car dans une des fonctions que tu as ecrite, tu as utilise "when" et je n'ai jamais vu ca ds mes cours !

when sert a faire un test dans un pattern matching

let f = function
 | x when x*x = 9 -> 3

est a peu pres equivalent a
let f x = if x*x = 9 then 3

de plus, dans cette question: définir une fonction prenant en argument une entité e du type défini à la question précédente et une chaîne de caractères ch et qui retourne 1 si ch est identique à la nationalité de e et 0 sinon.

je crois que tu as oublie "ch".

j'ai changé les noms des variables mais ce que j'avais poster devrait convenir
en gros en changeant un peu

let bonne_nation ch = function 
  | e when ch=e.nation -> 1
(* ce qui veut dire : "si le deuxieme argument est une entité e du type qqun donc le champ nation est egal a la chaine ch, retourner 1 *)
  | _ -> 0 ;; 
(* sinon on retourne 0 *)

ah ok !! tout est a peu pres clair !!

par contre qd je compile cette question:

En utilisant tout ce qui a été défini précédemment, écrire la fonction permettant de dénombrer les personnes d’un arbre généalogique qui sont d’une même nationalité donnée en argument d’entrée.

#let nombre_nation arbre nation =
let rec somme = function
| [] -> 0
| t::q -> t+(somme q)
in somme (applique (bonne_nation nation) arbre) ;;

qu'est que represente t et q??


Aussi, peux tu m expliquer une derniere chose:
concernant la derniere question ...
4. Définir et initialiser une variable globale décrivant un exemple d’arbre généalogique inversé. Tester vos fonctions avec cette variable.

tu as ecrrit: "je vois pas bien pourquoi "inversé" et j'ai la flemme de rentrer plein de truc mais bon"

Je n'ai pqs compris puisque tu n'as pas d'explications ...


Je sais je suis CASSE TETE !!

tamara :
#let nombre_nation arbre nation =
let rec somme = function
| [] -> 0
| t::q -> t+(somme q)
in somme (applique (bonne_nation nation) arbre) ;;

qu'est que represente t et q??

t et q représentent la tete et la queue de la liste, c'est a dire que t est le premier element de la liste et q est tout le reste

tu as ecrrit: "je vois pas bien pourquoi "inversé" et j'ai la flemme de rentrer plein de truc mais bon"

Je n'ai pqs compris puisque tu n'as pas d'explications ...

j'ai pas compris ta phrase là ...
en gros la question c'est juste de definir un arbre dont les elements sont de type "qqun" et de tester les fonctions dessus

lorsque je compile :

#let nombre_nation arbre nation =
let rec somme = function
| [] -> 0
| t::q -> t+(somme q)
in somme (applique (bonne_nation nation) arbre) ;;


cela me donne un message d erreur ...



j'ai egalement une autre question:

peut on remplacer dans cette fonction:

#let rec applique f = function
| Feuille x -> [f(x)]
| Noeud(fg,x,fd) -> (applique f fg)@((f x):: (applique f fd)) ;;
applique : ('a -> 'b) -> 'a arbre -> 'b list = <fun>


@ par :: sinon pourquoi??



merci

tamara :
#let nombre_nation arbre nation =
let rec somme = function
| [] -> 0
| t::q -> t+(somme q)
in somme (applique (bonne_nation nation) arbre) ;;

cela me donne un message d erreur ...

quoi comme erreur ? (parce que dans mon premier post j'avais mis les resultats de la compilation et il n'y avait pas d'erreurs)

peut on remplacer dans cette fonction:

#let rec applique f = function
| Feuille x -> [f(x)]
| Noeud(fg,x,fd) -> (applique f fg)@((f x):: (applique f fd)) ;;
applique : ('a -> 'b) -> 'a arbre -> 'b list = <fun>

@ par : sinon pourquoi??

non on ne peut pas
pour les :: on doit avoir a gauche un element et a droite une liste, et le tout donne une liste, en gros
:: : 'a -> 'a list -> 'a list
pour les @ on doit avoir des deux cotés une liste et on recupere une liste
@ : 'a list -> 'a list -> 'a list

dans mon exemple on a :
(f x) de type 'a
(applique f fd) de type 'a list
-> ((f x):: (applique f fd)) de type 'a list

(applique f fg) de type 'a list
-> (applique f fg)@((f x):: (applique f fd)) de type 'a list

par contre j'aurais pu remplacer
(applique f fg)@((f x):: (applique f fd))
par
(applique f fg)@[f x]@(applique f fd)

merci tes precisions, tu devrais faire prof !! (si tu ne l es pas deja)

mon erreur de compilation:

#Toplevel input:
>#let nombre_nation arbre nation =
> ^^^

il manque la partie interessante du message d'erreur là ...
(une syntax error ?)

#Toplevel input:
> in somme (applique (bonne_nation nation) arbre) ;;
> ^^^^^^^^^^^^
The value identifier bonne_nation is unbound.
#

tu as definit la fonction

let bonne_nation ch = function 
  | e when ch=e.nation -> 1 
  | _ -> 0 ;; 

?

honte a moi !! je suis nulle !!

oki dokey ca marche !!

derniere des dernieres questions:
pour la derniere fonction:
Définir et initialiser une variable globale décrivant un exemple d’arbre généalogique inversé. Tester vos fonctions avec cette variable.

que represente le 7 de la fin??

je te met la source complete qui compile sans erreur :

type 'a arbre =
   | Feuille of 'a
   | Noeud of 'a arbre * 'a * 'a arbre ;;

let rec applique f = function
 | Feuille x -> [f(x)]
 | Noeud(fg,x,fd) -> (applique f fg)@((f x):: (applique f fd)) ;;

type particulier = {
	nom    : string ;
	naiss  : int    ;
	deces  : int    ;
	nation : string   } ;;

let bonne_nation ch = function
  | e when ch=e.nation -> 1
  | _ -> 0 ;;

let nombre_nation arbre nation =
 let rec somme = function
   | [] -> 0
   | t::q -> t+(somme q)
 in somme (applique (bonne_nation nation) arbre) ;;

let moi = { nom = "moi" ; naiss = 0 ; deces = 123 ; nation = "yN" } ;;

let arbre_gene = Noeud(Noeud(Feuille moi, moi, Feuille moi),moi,Noeud(Feuille moi,moi,Feuille moi));;

nombre_nation arbre_gene "yN" ;;

le 7 c'est le nombre de personnes dans l'arbre qui ont la nationalité "yN", ici ils l'ont tous et ils sont 7, donc ca fait 7 ^^ (c'est un exemple de test, comme demandé dans la question)

ok merci pour ton aide !!!



je te fais des gros bisous !!