yop

enoncé :

voila ce que j'ai fait pour le moment :

let rec chaines_croissantes l= 
  match l with
    |[]->[]
    |z::[]->[z]
    |x::y::s-> if x<=y
                then (x :: (chaines_croissantes (y::s)))
                else x :: [];(chaines_croissantes(y::s));;

message d'erreur :

ça fait 3 jours que je planche sur ce truc qui doit etre tout con, mais en tant que debutant je seche
sinon j'essaye de faire un truc du genre recursivement

mais j'ai un soucis avec le ; qui separe mes deux liste dans la liste global

si une personne a une idée, je suis tout ouie ^^

Déjà ton cas de base est faux si tu dois renvoyer une liste de liste.

let rec chaines_croissantes l= 
  match l with
    |[]->[]
    |z::[]->[z]
    |x::y::s-> if x<=y
                then (x :: (chaines_croissantes (y::s)))
                else x :: [];(chaines_croissantes(y::s));;

Je fais pas de caml, mais ça sent le type mismatch, tes cas n'ont pas tous l'air de renvoyer le même type. Genre (x :: (chaines_croissantes (y::s))) si je ne me trompe pas ça va renvoyer une list d'int, alors que tu veux des listes de listes d'int.

oui vous avez raison, la c'est en fait un essaie parmis tant d'autre, certain autre essaie etait bien typpé, mais le mieux que jai reussi ça donnait ça au final

chaines_croissantes [2;5;4;9;3];;
- int list list = [[2];[5];[4];[9];[3]];;

Je pense que tu as besoin de deux fonctions, une de base qui détecte une suite ascendante (ce que tu as, globalement) et une appelée par celle ci qui va renvoyer la liste ascendante et le reste de la liste.

En Haskell, ça donne un truc du genre:

growing [] = []
growing [x] = [[x]]
growing (x1:x2:xs)
    | x1 <= x2 =
        let (ys, zs) = growSpan (x1:x2:xs)
        in ys : growing zs
    | otherwise =
        [x1] : growing (x2:xs)
 
growSpan xs = _growSpan xs []
    where
      _growSpan [x] serie = (reverse (x:serie), [])
      _growSpan (x1:x2:xs) serie
              | x1 <= x2 =
                  _growSpan (x2:xs) (x1:serie)
              | otherwise =
                  (reverse (x1:serie), x2:xs)

et à l'appel:

Ca a l'air d'être bon.

haaaaa un grand merci a toi, tu m'as dirigé dans la bonne direction, j'ai fini par y arriver (au bout de 3heure d'acharnement dans cette voie)
pfiuuuuuuuu, hé bah dit donc

voila ce que ça donne en ocamL

let rec chaines_croissante l=
     if l=[] 
      then []
      else
        let rec morceau l1= 
           match l1 with
            |[]->([],[])
            |z::[]->([z],[])
            |x::y::s ->
                if x<=y 
                 then let (a,b) = morceau (y::s) in (x::a,b)
                 else (x::[],y::s)
        in let (a,b)=(morceau l)
        in  a::chaines_croissante b;;

apparemment le Haskell est un langage proche du caml, étant donné ton expérience, pourquoi le préfères tu au caml?

pas vraiment de raison, je trouve la syntaxe ML moche et quand je me demandais quel langage fonctionnel typé statiquement essayer j'ai trouve des gens faisant du haskell (online) rapidement.
 
Rien d'objectif donc et sur certains points ocaml>haskell (vitesse d'exécution par exemple)
 
Au oui, haskell n'est pas un langage strict (au niveau du modèle d'évaluation) ce qui a des conséquences intéressantes.
Et il est pur, ce qui a des conséquences complexifiantes

Masklinn >> J'ai une question : ne pourrais-tu pas éviter les reverse ?
En Prolog pour faire ça on parcourt la liste complète et on construit le résultat à partir de la fin en étudiant à chaque fois le nombre courant et celui qui vient d'être inséré dans la liste résultat.

Peut-être, mais je vois pas spécialement l'intérêt de s'embêter pour ça.

edit: et en construisant en partant de la fin, on risque de perdre le tail-rec. Construire le résultat en inversé et reverse à la fin est un idiôme fonctionnel standard, je vois pas pourquoi s'embêter.

Je préfère ce genre d'explications.