listes caml - Page 1

voila j ai un petit probleme avec un programme que je dois faire pour les cours....
en caml bien sur language que je connais depuis 2 jours ....AIE...
mon prof veut nous faire faire un morpion en caml gérer sous forme de listes et je coince sur quelques fonctions:
fonction permettant de lister les diff soluces encore jouable.
fonction precisant si une soluce est la derniere jouable
si vous pouviez m aider ca serait vraiment cool ........
merci encore!

C'est quoi une soluce?

Une configuration j'imagine.

cicdrek> si tu veux qu'on t'aide, il faudrait préciser quelles structures de données tu utilises, et sur quel point tu bloques... sinon ça revient à te faire ton exo, et pour ça tu peux toujours courir

Bah il a dit pour la structure de données. C'est des listes.
Donc

type case = 
  | Vide
  | X
  | O
;;

et

let plateau_vide () =
  [[Vide;Vide;Vide];[Vide;Vide;Vide][Vide;Vide;Vide]]
;;

je pense.
Sinon ça n'a pas l'air d'être une configuration une soluce, parce que j'ai pas l'impression qu'on puisse dire d'une configuration qu'elle est jouable.

la liste serait sous cette forme(9 elements c'est les 9 cases du morpion!)

(* on initialise la liste*)
let listdep = [ 0; 0; 0; 0; 0; 0; 0; 0; 0];;


en fait ce que je cherche c'est comment faire pour faire une permutation avec des 1 ou 2 qui remplacerait chaque 0 dans ma liste....

par exemple si j avais une liste de 3 elements

[0;1;0]
je cherche a afficher:

[1;1;0]
[2;1;0]
[0;1;0]
[0;1;1]
[0;1;2]
[2;1;1]
[2;1;2]
[1;1;1]
[1;1;2]

vous voyez?

C pas des listes qui sont adaptées à ton cas, c'est des tableaux, sinon tu vas énormément galérer et ce sera plus lent... (i.e. c'est [|0;1;2|] et pas [0;1;2])

Et il vaudrait mieux faire un tableau à deux dimensions (tableau de tableaux) plutôt qu'un gros tableau, ce serait plus zouli

en fait faudrait deja que j arrive a afficher toutes les soluce possible apres un etat:

par exemple apres [1;0;0]

on peut avoir

[1;2;0]
ou
[1;0;2]

ou 1 represente les coups joué par le joueur 1 et 2 ceux joué par le joueur 2

C pas des listes qui sont adaptées à ton cas, c'est des tableaux, sinon tu vas énormément galérer et ce sera plus lent... (i.e. c'est [|0;1;2|] et pas [0;1;2])

Et il vaudrait mieux faire un tableau à deux dimensions (tableau de tableaux) plutôt qu'un gros tableau, ce serait plus zouli



merci polux mais mon prof a vraiment insister pour les listes e tu c comment c un prof...

et dire qu 'au debut il voulait nous faire faire ca avec des arbres n-aire!!!!!!!!

a et deja comment on remplace un nombre par un autre dans une liste?

Si tu veux remplacer tous les 0 par des 1 dans une liste par exemple, il suffit de faire:

let rec fct = function
  | 0::q -> 1::q
  | t::q -> t::(fct q)
;;

BiHi :
Si tu veux remplacer tous les 0 par des 1 dans une liste par exemple, il suffit de faire:

let rec fct = function
  | 0::q -> 1::q
  | t::q -> t::(fct q)
;;

ba ouais mais la je veut en remplacer que un et pas necessairement le 1er ...

(Là ça les remplace tous et pas que le premier)

BiHi
: (Là ça les remplace tous et pas que le premier)

ouais ouais j avais bien compris mais je veut en remplacer que 1 seul et unique!

y a un equivalent de printf en caml

[nosmile]

let rec soluces_possibles plateau joueur =
  match plateau with
(* Quand ya pas de case ya pas de solution *)
    | []   -> []
(* Les coups possibles quand ça commence par un zéro (case vide) sont : *)
(*  -> jouer sur cette case vide donc joueur::q *)
(*  -> jouer sur une autre case vide (appel récursif) *)
(*     donc laisser cette case vide (mettre un zéro devant les coups de l'appel récursif) *)
    | 0::q -> (joueur::q)::(map (function l -> 0::l) (soluces_possibles q joueur)) 
(* si la case est pas vide *)
(* bah elle sera toujours pas vide même si on trouve une solution après *)
(* donc on remet le même coup en mettant le t devant tous les coups de l'appel récursif *)
    | t::q -> map (function l -> t::l) (soluces_possibles q joueur)
;;

Ce qui donne sans explications:

let rec soluces_possibles plateau joueur =
  match plateau with
    | []   -> []
    | 0::q -> (joueur::q)::(map (function l -> 0::l) (soluces_possibles q joueur)) 
    | t::q -> map (function l -> t::l) (soluces_possibles q joueur)
;;

[Edit: Quelques petites corrections ^^]

BiHi :
[nosmile]

let rec soluces_possibles plateau joueur =
  match plateau with
(* Quand ya pas de case ya pas de solution *)
    | []   -> []
(* Les coups possibles quand ça commence par un zéro (case vide) sont : *)
(*  -> jouer sur cette case vide donc joueur::q *)
(*  -> jouer sur une autre case vide (appel récursif) *)
(*     donc laisser cette case vide (mettre un zéro devant les coups de l'appel récursif) *)
    | 0::q -> (joueur::q)::(map (function l -> 0::l) (soluces_possibles q joueur)) 
(* si la case est pas vide *)
(* bah elle sera toujours pas vide même si on trouve une solution après *)
(* donc on remet le même coup en mettant le t devant tous les coups de l'appel récursif *)
    | t::q -> map (function l -> t::l) (soluces_possibles q joueur)
;;

Ce qui donne sans explications:

let rec soluces_possibles plateau joueur =
  match plateau with
    | []   -> []
    | 0::q -> (joueur::q)::(map (function l -> 0::l) (soluces_possibles q joueur)) 
    | t::q -> map (function l -> t::l) (soluces_possibles q joueur)
;;

[Edit: Quelques petites corrections ^^]

Merci BiHi je dis vive toi t es un bosss!!!!!!!!!