bonsoir,

j ai fait du Caml un peu, mais que represente les fonction hd (head?) et rev?

rev renverse la liste, c'est a dire que [1;2;3] devient [3;2;1].
hd prend le premier élément de liste. (hd=head)

Je suis boligé de renverser la liste, puisque dans la représentation du nombre, la premier chiffre est a la fin.

es tu bien sur que dans ta recurence il doit prendre compare(q,r) ?

si je prends 412 et 417  [2,1,4] et [7,1,4]
(a::q) (b::r)->if (hd(rev(a::q)))>(hd(rev(b::r))) then true
else if (hd(rev(a::q)))=(hd(rev(b::r))) then (compare q r)
else false;
dans mon cas a=2 et b=7    q=[1,4] et r=[1,4]
je suis dans le cas d egalite
je ne compare pas les bon nombre a l etape suivante

en effet,

il faut que je compare a::q moins le dernier element avec b::r moins le dernier element.

oui voila c est plus clair comme tu le dis....

bon, finalement j'obtiens:

let supprime_premier=fun
[]->[]
|(a::q)->q;;

let rec compare =fun
[a] [ b]->if a>=b then true else false
|[] (a::q)->false
|(a::q) []->true
|[] []->true
|(a::q) (b::r)->if (hd(rev(a::q)))>(hd(rev(b::r))) then true
else if (hd(rev(a::q)))>(hd(rev(b::r))) then false
else (compare (supprime_premier(rev(a::q))) (supprime_premier(rev(b::r))));;

J'ai fait quelques essais ca a l'ai de fonctionner, mais là je suis fatigué, je n'ai plus envie d'approfondir.
Merci de ton aide.

j'ai fait une erreur en copiant-collant, c'est :

let supprime_premier=fun
[]->[]
|(a::q)->q;;

let rec compare =fun
[a] [ b]->if a>=b then true else false
|[] (a::q)->false
|(a::q) []->true
|[] []->true
|(a::q) (b::r)->if (hd(rev(a::q)))>(hd(rev(b::r))) then true
else if (hd(rev(a::q)))>(hd(rev(b::r))) then false
else (compare (supprime_premier(rev(a::q))) (supprime_premier(rev(b::r))));;

Moi aussi j'ai fait un peu du CamL et moi ainsi que tous ceux que j'ai rencontrés qui en ont fait aussi nous demandons tous pourquoi on nous a fait faire du CamL ?

J'en ai fait aussi. Bon, d'un point de vue du monde de l'entreprise, c'est clair, sauf cas très particulier, ça ne te servira à rien. Dans la recherche, il est assez apprécié (langage fonctionnel, puissant...)

Mais bon, après tout, caml n'est pas trop compliqué, et pour une première approche de ce type de langage, pourquoi pas... le pascal, également enseigné en fac, n'est pas beaucoup plus utilisé ensuite.

Bonsoir, je peux paraître un peu idiot mais je voudrais savoir c'est quoi Cam light ? C'est juste pour savoir. Merci

Un langage de programmation, dérivé du Ocaml. Développé par des Français (INRIA, cocorico), il est enseigné dans les universités en France et utilisé (un peu) dans le monde de la recherche.

Très puissant (y paraît), mais très récent et donc inconnu dans les entreprises. plus de détails par là : http://caml.inria.fr/

Merci nicomart

bien, alors voilà mon programme final, pour ceux que ca interesse:

let sup l1 l2=
let supprime_premier=fun
[]->[]
|(a::q)->q
in let rec supprime_zero=fun
[]->[]
|(a::q)->if a=0
then (supprime_zero q)
else (a::q)
in
if list_length(supprime_zero(rev(l1)))>list_length(supprime_zero(rev(l2)))
then true
else if list_length(supprime_zero(rev(l1)))<list_length(supprime_zero(rev(l2)))
then false
else let rec compare =fun
[] []->true
|[] (a::q)->false
|(a::q) []->true
|(a::q) (b::r)->if (hd(supprime_zero(rev(a::q))))>(hd(supprime_zero(rev(b::r)))) then true
else if (hd(supprime_zero(rev(a::q))))<(hd(supprime_zero(rev(b::r)))) then false
else (compare (supprime_premier(rev(a::q))) (supprime_premier(rev(b::r))));
in (compare l1 l2);;

Superbe indentation

Salut à tous,

    Sinon comme programme, il y avait peut être plus simple (si le programme consiste uniquement à classer deux entiers écrits sous forme de liste renversée). Je te propose le programme suivant qui reprend dans la grande majorité les idées de la première version de ton programme. L'astuce (qui sert souvent) consiste juste à passer par une fonction intermédiaire récursive, de manière à pouvoir "Reverser" les listes avant de les envoyer dans la récurrence.

    Alors voici le programme (écrit sous CamL Light 0.74) :


let compare l1 l2 =
comp (rev l1) (rev l2) where rec comp = fun
  |[] [] -> true
  |entier1 [] -> true
  |[] entier1 -> false
  |(a :: b) (c :: d) when a > c -> true
  |(a :: b) (c :: d) when c > a -> false
  |(a :: b) (c :: d) when a = c -> comp b d
;;

À +